src/knotholder.cpp

   1 #define __KNOT_HOLDER_C__
   2
   3 /*
   4  * Container for SPKnot visual handles
   5  *
   6  * Authors:
   7  *   Mitsuru Oka <oka326@parkcity.ne.jp>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 2001-2005 authors
  11  *
  12  * Released under GNU GPL, read the file 'COPYING' for more information
  13  */
  14
  15 #define noKNOT_HOLDER_DEBUG
  16
  17
  18 #include "document.h"
  19 #include "sp-shape.h"
  20 #include "knot.h"
  21 #include "knotholder.h"
  22 #include "knot-holder-entity.h"
  23 #include "rect-context.h"
  24 #include "sp-rect.h"
  25 #include "arc-context.h"
  26 #include "sp-ellipse.h"
  27 #include "star-context.h"
  28 #include "sp-star.h"
  29 #include "spiral-context.h"
  30 #include "sp-spiral.h"
  31 #include "sp-offset.h"
  32 #include "box3d.h"
  33
  34 #include <libnr/nr-matrix-div.h>
  35 #include <glibmm/i18n.h>
  36
  37 class SPDesktop;
  38
  39 static void knot_clicked_handler (SPKnot *knot, guint state, gpointer data);
  40 static void knot_moved_handler(SPKnot *knot, NR::Point const *p, guint state, gpointer data);
  41 static void knot_ungrabbed_handler (SPKnot *knot, unsigned int state, SPKnotHolder *kh);
  42 static void sp_knot_holder_class_init(SPKnotHolderClass *klass);
  43
  44 void sp_knot_holder_dispose(GObject *object);
  45
  46 #ifdef KNOT_HOLDER_DEBUG
  47
  48 static void sp_knot_holder_debug(GtkObject *object, gpointer data)
  49 {
  50     g_print("sp-knot-holder-debug: [type=%s] [data=%s]\n", gtk_type_name(GTK_OBJECT_TYPE(object)), (const gchar *) data);
  51 }
  52 #endif
  53
  54 static GObjectClass *parent_class;
  55
  56 /**
  57  * Registers SPKnotHolder class and returns its type number.
  58  */
  59 GType sp_knot_holder_get_type()
  60 {
  61     static GType type = 0;
  62     if (!type) {
  63         GTypeInfo info = {
  64             sizeof(SPKnotHolderClass),
  65             NULL,       /* base_init */
  66             NULL,       /* base_finalize */
  67             (GClassInitFunc) sp_knot_holder_class_init,
  68             NULL,       /* class_finalize */
  69             NULL,       /* class_data */
  70             sizeof (SPKnotHolder),
  71             16, /* n_preallocs */
  72             NULL,
  73             NULL
  74         };
  75         type = g_type_register_static (G_TYPE_OBJECT, "SPKnotHolder", &info, (GTypeFlags) 0);
  76     }
  77     return type;
  78 }
  79
  80 /**
  81  * SPKnotHolder vtable initialization.
  82  */
  83 static void sp_knot_holder_class_init(SPKnotHolderClass *klass){
  84     parent_class = (GObjectClass*) g_type_class_peek_parent(klass);
  85     klass->dispose = sp_knot_holder_dispose;
  86 }
  87
  88 SPKnotHolder *sp_knot_holder_new(SPDesktop *desktop, SPItem *item, SPKnotHolderReleasedFunc relhandler)
  89 {
  90     Inkscape::XML::Node *repr = SP_OBJECT(item)->repr;
  91
  92     g_return_val_if_fail(desktop != NULL, NULL);
  93     g_return_val_if_fail(item != NULL, NULL);
  94     g_return_val_if_fail(SP_IS_ITEM(item), NULL);
  95
  96     SPKnotHolder *knot_holder = (SPKnotHolder*)g_object_new (SP_TYPE_KNOT_HOLDER, 0);
  97     knot_holder->desktop = desktop;
  98     knot_holder->item = item;
  99     g_object_ref(G_OBJECT(item));
 100     knot_holder->entity = NULL;
 101
 102     knot_holder->released = relhandler;
 103
 104     knot_holder->repr = repr;
 105     knot_holder->local_change = FALSE;
 106
 107 #ifdef KNOT_HOLDER_DEBUG
 108     g_signal_connect(G_OBJECT(desktop), "destroy", sp_knot_holder_debug, (gpointer) "SPKnotHolder::item");
 109 #endif
 110
 111     return knot_holder;
 112 }
 113
 114 void sp_knot_holder_dispose(GObject *object) {
 115     SPKnotHolder *kh = G_TYPE_CHECK_INSTANCE_CAST((object), SP_TYPE_KNOT_HOLDER, SPKnotHolder);
 116
 117     g_object_unref(G_OBJECT(kh->item));
 118     while (kh->entity) {
 119         SPKnotHolderEntity *e = (SPKnotHolderEntity *) kh->entity->data;
 120         g_signal_handler_disconnect(e->knot, e->_click_handler_id);
 121         g_signal_handler_disconnect(e->knot, e->_ungrab_handler_id);
 122         /* unref should call destroy */
 123         g_object_unref(e->knot);
 124         g_free(e);
 125         kh->entity = g_slist_remove(kh->entity, e);
 126     }
 127 }
 128
 129 void sp_knot_holder_destroy(SPKnotHolder *kh) {
 130     g_object_unref(kh);
 131     }
 132
 133 void sp_knot_holder_add(
 134     SPKnotHolder *knot_holder,
 135     SPKnotHolderSetFunc knot_set,
 136     SPKnotHolderGetFunc knot_get,
 137     void (* knot_click) (SPItem *item, guint state),
 138     const gchar *tip
 139     )
 140 {
 141     sp_knot_holder_add_full(knot_holder, knot_set, knot_get, knot_click, SP_KNOT_SHAPE_DIAMOND, SP_KNOT_MODE_XOR, tip);
 142 }
 143
 144 void sp_knot_holder_add_full(
 145     SPKnotHolder *knot_holder,
 146     SPKnotHolderSetFunc knot_set,
 147     SPKnotHolderGetFunc knot_get,
 148     void (* knot_click) (SPItem *item, guint state),
 149     SPKnotShapeType     shape,
 150     SPKnotModeType      mode,
 151     const gchar *tip
 152     )
 153 {
 154     g_return_if_fail(knot_holder != NULL);
 155     g_return_if_fail(knot_set != NULL);
 156     g_return_if_fail(knot_get != NULL);
 157
 158     SPItem *item = SP_ITEM(knot_holder->item);
 159
 160     /* create new SPKnotHolderEntry */
 161     SPKnotHolderEntity *e = g_new(SPKnotHolderEntity, 1);
 162     e->knot = sp_knot_new(knot_holder->desktop, tip);
 163     e->knot_set = knot_set;
 164     e->knot_get = knot_get;
 165     if (knot_click) {
 166         e->knot_click = knot_click;
 167     } else {
 168         e->knot_click = NULL;
 169     }
 170
 171     g_object_set(G_OBJECT (e->knot->item), "shape", shape, NULL);
 172     g_object_set(G_OBJECT (e->knot->item), "mode", mode, NULL);
 173
 174     // TODO: add a color argument
 175     //e->knot->fill [SP_KNOT_STATE_NORMAL] = 0x00ff0000;
 176     //g_object_set (G_OBJECT (e->knot->item), "fill_color", 0x00ff0000, NULL);
 177
 178     knot_holder->entity = g_slist_append(knot_holder->entity, e);
 179
 180     /* Move to current point. */
 181     NR::Point dp = e->knot_get(item) * sp_item_i2d_affine(item);
 182     sp_knot_set_position(e->knot, &dp, SP_KNOT_STATE_NORMAL);
 183
 184     e->handler_id = g_signal_connect(e->knot, "moved", G_CALLBACK(knot_moved_handler), knot_holder);
 185     e->_click_handler_id = g_signal_connect(e->knot, "clicked", G_CALLBACK(knot_clicked_handler), knot_holder);
 186     e->_ungrab_handler_id = g_signal_connect(e->knot, "ungrabbed", G_CALLBACK(knot_ungrabbed_handler), knot_holder);
 187
 188 #ifdef KNOT_HOLDER_DEBUG
 189     g_signal_connect(ob, "destroy", sp_knot_holder_debug, "SPKnotHolder::knot");
 190 #endif
 191     sp_knot_show(e->knot);
 192 }
 193
 194 /**
 195  * \param p In desktop coordinates.
 196  */
 197
 198 //static
 199 void knotholder_update_knots(SPKnotHolder *knot_holder, SPItem *item)
 200 {
 201     NR::Matrix const i2d(sp_item_i2d_affine(item));
 202
 203     for (GSList *el = knot_holder->entity; el; el = el->next) {
 204         SPKnotHolderEntity *e = (SPKnotHolderEntity *) el->data;
 205         GObject *kob = e->knot;
 206
 207         NR::Point dp( e->knot_get(item) * i2d );
 208         g_signal_handler_block(kob, e->handler_id);
 209         sp_knot_set_position(e->knot, &dp, SP_KNOT_STATE_NORMAL);
 210         g_signal_handler_unblock(kob, e->handler_id);
 211     }
 212 }
 213
 214 static void knot_clicked_handler(SPKnot *knot, guint state, gpointer data)
 215 {
 216     SPKnotHolder *knot_holder = (SPKnotHolder *) data;
 217     SPItem *item  = SP_ITEM (knot_holder->item);
 218
 219     g_object_ref(knot_holder);
 220     for (GSList *el = knot_holder->entity; el; el = el->next) {
 221         SPKnotHolderEntity *e = (SPKnotHolderEntity *) el->data;
 222         if (e->knot == knot) {
 223             if (e->knot_click) {
 224                 e->knot_click(item, state);
 225             }
 226             break;
 227         }
 228     }
 229
 230     if (SP_IS_SHAPE(item)) {
 231         sp_shape_set_shape(SP_SHAPE(item));
 232     }
 233
 234     knotholder_update_knots(knot_holder, item);
 235     g_object_unref(knot_holder);
 236
 237     unsigned int object_verb = SP_VERB_NONE;
 238
 239     if (SP_IS_RECT(item))
 240         object_verb = SP_VERB_CONTEXT_RECT;
 241     else if (SP_IS_BOX3D(item))
 242         object_verb = SP_VERB_CONTEXT_3DBOX;
 243     else if (SP_IS_GENERICELLIPSE(item))
 244         object_verb = SP_VERB_CONTEXT_ARC;
 245     else if (SP_IS_STAR(item))
 246         object_verb = SP_VERB_CONTEXT_STAR;
 247     else if (SP_IS_SPIRAL(item))
 248         object_verb = SP_VERB_CONTEXT_SPIRAL;
 249     else if (SP_IS_OFFSET(item)) {
 250         if (SP_OFFSET(item)->sourceHref)
 251             object_verb = SP_VERB_SELECTION_LINKED_OFFSET;
 252         else
 253             object_verb = SP_VERB_SELECTION_DYNAMIC_OFFSET;
 254     }
 255
 256     // for drag, this is done by ungrabbed_handler, but for click we must do it here
 257     sp_document_done(SP_OBJECT_DOCUMENT(knot_holder->item), object_verb,
 258                      _("Change handle"));
 259 }
 260
 261 static void knot_moved_handler(SPKnot *knot, NR::Point const *p, guint state, gpointer data)
 262 {
 263     SPKnotHolder *knot_holder = (SPKnotHolder *) data;
 264     SPItem *item  = SP_ITEM (knot_holder->item);
 265     // this was a local change and the knotholder does not need to be recreated:
 266     knot_holder->local_change = TRUE;
 267
 268     for (GSList *el = knot_holder->entity; el; el = el->next) {
 269         SPKnotHolderEntity *e = (SPKnotHolderEntity *) el->data;
 270         if (e->knot == knot) {
 271             NR::Point const q = *p / sp_item_i2d_affine(item);
 272             e->knot_set(item, q, e->knot->drag_origin / sp_item_i2d_affine(item), state);
 273             break;
 274         }
 275     }
 276
 277     if (SP_IS_SHAPE (item)) {
 278         sp_shape_set_shape(SP_SHAPE (item));
 279     }
 280
 281     knotholder_update_knots(knot_holder, item);
 282 }
 283
 284 static void knot_ungrabbed_handler(SPKnot */*knot*/, unsigned int /*state*/, SPKnotHolder *kh)
 285 {
 286     if (kh->released) {
 287         kh->released(kh->item);
 288     } else {
 289         SPObject *object = (SPObject *) kh->item;
 290         object->updateRepr(object->repr, SP_OBJECT_WRITE_EXT);
 291
 292         unsigned int object_verb = SP_VERB_NONE;
 293
 294         if (SP_IS_RECT(object))
 295             object_verb = SP_VERB_CONTEXT_RECT;
 296         else if (SP_IS_BOX3D(object))
 297             object_verb = SP_VERB_CONTEXT_3DBOX;
 298         else if (SP_IS_GENERICELLIPSE(object))
 299             object_verb = SP_VERB_CONTEXT_ARC;
 300         else if (SP_IS_STAR(object))
 301             object_verb = SP_VERB_CONTEXT_STAR;
 302         else if (SP_IS_SPIRAL(object))
 303             object_verb = SP_VERB_CONTEXT_SPIRAL;
 304         else if (SP_IS_OFFSET(object)) {
 305             if (SP_OFFSET(object)->sourceHref)
 306                 object_verb = SP_VERB_SELECTION_LINKED_OFFSET;
 307             else
 308                 object_verb = SP_VERB_SELECTION_DYNAMIC_OFFSET;
 309         }
 310
 311         sp_document_done(SP_OBJECT_DOCUMENT (object), object_verb,
 312                          _("Move handle"));
 313     }
 314 }
 315
 316 /*
 317   Local Variables:
 318   mode:c++
 319   c-file-style:"stroustrup"
 320   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 321   indent-tabs-mode:nil
 322   fill-column:99
 323   End:
 324 */
 325 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :