src/ink-action.cpp

   1
   2
   3
   4 #include <glib/gi18n.h>
   5 #include <gtk/gtktooltips.h>
   6 #include <gtk/gtktoolitem.h>
   7 #include <gtk/gtktoggletoolbutton.h>
   8 #include <gtk/gtkcheckmenuitem.h>
   9
  10 #include "icon-size.h"
  11 #include "ink-action.h"
  12
  13 #include "widgets/button.h"
  14 #include "widgets/icon.h"
  15
  16
  17
  18 static void ink_action_class_init( InkActionClass* klass );
  19 static void ink_action_init( InkAction* action );
  20 static void ink_action_finalize( GObject* obj );
  21 static void ink_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
  22 static void ink_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
  23
  24 static GtkWidget* ink_action_create_menu_item( GtkAction* action );
  25 static GtkWidget* ink_action_create_tool_item( GtkAction* action );
  26
  27 static GtkActionClass* gInkActionParentClass = 0;
  28
  29 struct _InkActionPrivate
  30 {
  31     gchar* iconId;
  32     Inkscape::IconSize iconSize;
  33 };
  34
  35 #define INK_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), INK_ACTION_TYPE, InkActionPrivate ) )
  36
  37 GType ink_action_get_type( void )
  38 {
  39     static GType myType = 0;
  40     if ( !myType ) {
  41         static const GTypeInfo myInfo = {
  42             sizeof( InkActionClass ),
  43             NULL, /* base_init */
  44             NULL, /* base_finalize */
  45             (GClassInitFunc)ink_action_class_init,
  46             NULL, /* class_finalize */
  47             NULL, /* class_data */
  48             sizeof( InkAction ),
  49             0, /* n_preallocs */
  50             (GInstanceInitFunc)ink_action_init,
  51             NULL
  52         };
  53
  54         myType = g_type_register_static( GTK_TYPE_ACTION, "InkAction", &myInfo, (GTypeFlags)0 );
  55     }
  56
  57     return myType;
  58 }
  59
  60 enum {
  61     PROP_INK_ID = 1,
  62     PROP_INK_SIZE
  63 };
  64
  65 static void ink_action_class_init( InkActionClass* klass )
  66 {
  67     if ( klass ) {
  68         gInkActionParentClass = GTK_ACTION_CLASS( g_type_class_peek_parent( klass ) );
  69         GObjectClass * objClass = G_OBJECT_CLASS( klass );
  70
  71         objClass->finalize = ink_action_finalize;
  72         objClass->get_property = ink_action_get_property;
  73         objClass->set_property = ink_action_set_property;
  74
  75         klass->parent_class.create_menu_item = ink_action_create_menu_item;
  76         klass->parent_class.create_tool_item = ink_action_create_tool_item;
  77         /*klass->parent_class.connect_proxy = connect_proxy;*/
  78         /*klass->parent_class.disconnect_proxy = disconnect_proxy;*/
  79
  80         g_object_class_install_property( objClass,
  81                                          PROP_INK_ID,
  82                                          g_param_spec_string( "iconId",
  83                                                               "Icon ID",
  84                                                               "The id for the icon",
  85                                                               "",
  86                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
  87
  88         g_object_class_install_property( objClass,
  89                                          PROP_INK_SIZE,
  90                                          g_param_spec_int( "iconSize",
  91                                                            "Icon Size",
  92                                                            "The size the icon",
  93                                                            (int)Inkscape::ICON_SIZE_MENU,
  94                                                            (int)Inkscape::ICON_SIZE_DECORATION,
  95                                                            (int)Inkscape::ICON_SIZE_SMALL_TOOLBAR,
  96                                                            (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
  97
  98         g_type_class_add_private( klass, sizeof(InkActionClass) );
  99     }
 100 }
 101
 102 static void ink_action_init( InkAction* action )
 103 {
 104     action->private_data = INK_ACTION_GET_PRIVATE( action );
 105     action->private_data->iconId = 0;
 106     action->private_data->iconSize = Inkscape::ICON_SIZE_SMALL_TOOLBAR;
 107 }
 108
 109 static void ink_action_finalize( GObject* obj )
 110 {
 111     InkAction* action = INK_ACTION( obj );
 112
 113     g_free( action->private_data->iconId );
 114     g_free( action->private_data );
 115
 116 }
 117
 118 InkAction* ink_action_new( const gchar *name,
 119                            const gchar *label,
 120                            const gchar *tooltip,
 121                            const gchar *inkId,
 122                            Inkscape::IconSize size )
 123 {
 124     GObject* obj = (GObject*)g_object_new( INK_ACTION_TYPE,
 125                                            "name", name,
 126                                            "label", label,
 127                                            "tooltip", tooltip,
 128                                            "iconId", inkId,
 129                                            "iconSize", size,
 130                                            NULL );
 131
 132     InkAction* action = INK_ACTION( obj );
 133
 134     return action;
 135 }
 136
 137 static void ink_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
 138 {
 139     InkAction* action = INK_ACTION( obj );
 140     (void)action;
 141     switch ( propId ) {
 142         case PROP_INK_ID:
 143         {
 144             g_value_set_string( value, action->private_data->iconId );
 145         }
 146         break;
 147
 148         case PROP_INK_SIZE:
 149         {
 150             g_value_set_int( value, action->private_data->iconSize );
 151         }
 152         break;
 153
 154         default:
 155             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 156     }
 157 }
 158
 159 void ink_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
 160 {
 161     InkAction* action = INK_ACTION( obj );
 162     (void)action;
 163     switch ( propId ) {
 164         case PROP_INK_ID:
 165         {
 166             gchar* tmp = action->private_data->iconId;
 167             action->private_data->iconId = g_value_dup_string( value );
 168             g_free( tmp );
 169         }
 170         break;
 171
 172         case PROP_INK_SIZE:
 173         {
 174             action->private_data->iconSize = (Inkscape::IconSize)g_value_get_int( value );
 175         }
 176         break;
 177
 178         default:
 179         {
 180             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 181         }
 182     }
 183 }
 184
 185 static GtkWidget* ink_action_create_menu_item( GtkAction* action )
 186 {
 187     GtkWidget* item = gInkActionParentClass->create_menu_item( action );
 188
 189     return item;
 190 }
 191
 192 static GtkWidget* ink_action_create_tool_item( GtkAction* action )
 193 {
 194     InkAction* act = INK_ACTION( action );
 195     GtkWidget* item = gInkActionParentClass->create_tool_item(action);
 196
 197     if ( act->private_data->iconId ) {
 198         if ( GTK_IS_TOOL_BUTTON(item) ) {
 199             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 200
 201             GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );
 202             gtk_tool_button_set_icon_widget( button, child );
 203         } else {
 204             // For now trigger a warning but don't do anything else
 205             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 206             (void)button;
 207         }
 208     }
 209
 210     // TODO investigate if needed
 211     gtk_widget_show_all( item );
 212
 213     return item;
 214 }
 215
 216
 217
 218 /* --------------------------------------------------------------- */
 219 /* --------------------------------------------------------------- */
 220 /* --------------------------------------------------------------- */
 221 /* --------------------------------------------------------------- */
 222
 223
 224 static void ink_toggle_action_class_init( InkToggleActionClass* klass );
 225 static void ink_toggle_action_init( InkToggleAction* action );
 226 static void ink_toggle_action_finalize( GObject* obj );
 227 static void ink_toggle_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
 228 static void ink_toggle_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
 229
 230 static GtkWidget* ink_toggle_action_create_menu_item( GtkAction* action );
 231 static GtkWidget* ink_toggle_action_create_tool_item( GtkAction* action );
 232
 233 static GtkToggleActionClass* gInkToggleActionParentClass = 0;
 234
 235 struct _InkToggleActionPrivate
 236 {
 237     gchar* iconId;
 238     Inkscape::IconSize iconSize;
 239 };
 240
 241 #define INK_TOGGLE_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), INK_TOGGLE_ACTION_TYPE, InkToggleActionPrivate ) )
 242
 243 GType ink_toggle_action_get_type( void )
 244 {
 245     static GType myType = 0;
 246     if ( !myType ) {
 247         static const GTypeInfo myInfo = {
 248             sizeof( InkToggleActionClass ),
 249             NULL, /* base_init */
 250             NULL, /* base_finalize */
 251             (GClassInitFunc)ink_toggle_action_class_init,
 252             NULL, /* class_finalize */
 253             NULL, /* class_data */
 254             sizeof( InkToggleAction ),
 255             0, /* n_preallocs */
 256             (GInstanceInitFunc)ink_toggle_action_init,
 257             NULL
 258         };
 259
 260         myType = g_type_register_static( GTK_TYPE_TOGGLE_ACTION, "InkToggleAction", &myInfo, (GTypeFlags)0 );
 261     }
 262
 263     return myType;
 264 }
 265
 266
 267 static void ink_toggle_action_class_init( InkToggleActionClass* klass )
 268 {
 269     if ( klass ) {
 270         gInkToggleActionParentClass = GTK_TOGGLE_ACTION_CLASS( g_type_class_peek_parent( klass ) );
 271         GObjectClass * objClass = G_OBJECT_CLASS( klass );
 272
 273         objClass->finalize = ink_toggle_action_finalize;
 274         objClass->get_property = ink_toggle_action_get_property;
 275         objClass->set_property = ink_toggle_action_set_property;
 276
 277         klass->parent_class.parent_class.create_menu_item = ink_toggle_action_create_menu_item;
 278         klass->parent_class.parent_class.create_tool_item = ink_toggle_action_create_tool_item;
 279         /*klass->parent_class.connect_proxy = connect_proxy;*/
 280         /*klass->parent_class.disconnect_proxy = disconnect_proxy;*/
 281
 282         g_object_class_install_property( objClass,
 283                                          PROP_INK_ID,
 284                                          g_param_spec_string( "iconId",
 285                                                               "Icon ID",
 286                                                               "The id for the icon",
 287                                                               "",
 288                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 289
 290         g_object_class_install_property( objClass,
 291                                          PROP_INK_SIZE,
 292                                          g_param_spec_int( "iconSize",
 293                                                            "Icon Size",
 294                                                            "The size the icon",
 295                                                            (int)Inkscape::ICON_SIZE_MENU,
 296                                                            (int)Inkscape::ICON_SIZE_DECORATION,
 297                                                            (int)Inkscape::ICON_SIZE_SMALL_TOOLBAR,
 298                                                            (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 299
 300         g_type_class_add_private( klass, sizeof(InkToggleActionClass) );
 301     }
 302 }
 303
 304 static void ink_toggle_action_init( InkToggleAction* action )
 305 {
 306     action->private_data = INK_TOGGLE_ACTION_GET_PRIVATE( action );
 307     action->private_data->iconId = 0;
 308     action->private_data->iconSize = Inkscape::ICON_SIZE_SMALL_TOOLBAR;
 309 }
 310
 311 static void ink_toggle_action_finalize( GObject* obj )
 312 {
 313     InkToggleAction* action = INK_TOGGLE_ACTION( obj );
 314
 315     g_free( action->private_data->iconId );
 316     g_free( action->private_data );
 317
 318 }
 319
 320 InkToggleAction* ink_toggle_action_new( const gchar *name,
 321                            const gchar *label,
 322                            const gchar *tooltip,
 323                            const gchar *inkId,
 324                            Inkscape::IconSize size )
 325 {
 326     GObject* obj = (GObject*)g_object_new( INK_TOGGLE_ACTION_TYPE,
 327                                            "name", name,
 328                                            "label", label,
 329                                            "tooltip", tooltip,
 330                                            "iconId", inkId,
 331                                            "iconSize", size,
 332                                            NULL );
 333
 334     InkToggleAction* action = INK_TOGGLE_ACTION( obj );
 335
 336     return action;
 337 }
 338
 339 static void ink_toggle_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
 340 {
 341     InkToggleAction* action = INK_TOGGLE_ACTION( obj );
 342     (void)action;
 343     switch ( propId ) {
 344         case PROP_INK_ID:
 345         {
 346             g_value_set_string( value, action->private_data->iconId );
 347         }
 348         break;
 349
 350         case PROP_INK_SIZE:
 351         {
 352             g_value_set_int( value, action->private_data->iconSize );
 353         }
 354         break;
 355
 356         default:
 357             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 358     }
 359 }
 360
 361 void ink_toggle_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
 362 {
 363     InkToggleAction* action = INK_TOGGLE_ACTION( obj );
 364     (void)action;
 365     switch ( propId ) {
 366         case PROP_INK_ID:
 367         {
 368             gchar* tmp = action->private_data->iconId;
 369             action->private_data->iconId = g_value_dup_string( value );
 370             g_free( tmp );
 371         }
 372         break;
 373
 374         case PROP_INK_SIZE:
 375         {
 376             action->private_data->iconSize = (Inkscape::IconSize)g_value_get_int( value );
 377         }
 378         break;
 379
 380         default:
 381         {
 382             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 383         }
 384     }
 385 }
 386
 387 static GtkWidget* ink_toggle_action_create_menu_item( GtkAction* action )
 388 {
 389     GtkWidget* item = gInkToggleActionParentClass->parent_class.create_menu_item(action);
 390
 391     return item;
 392 }
 393
 394 static GtkWidget* ink_toggle_action_create_tool_item( GtkAction* action )
 395 {
 396     InkToggleAction* act = INK_TOGGLE_ACTION( action );
 397     GtkWidget* item = gInkToggleActionParentClass->parent_class.create_tool_item(action);
 398
 399     if ( act->private_data->iconId ) {
 400         if ( GTK_IS_TOOL_BUTTON(item) ) {
 401             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 402
 403             GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );
 404             gtk_tool_button_set_icon_widget( button, child );
 405         } else {
 406             // For now trigger a warning but don't do anything else
 407             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 408             (void)button;
 409         }
 410     }
 411
 412     // TODO investigate if needed
 413     gtk_widget_show_all( item );
 414
 415     return item;
 416 }
 417
 418
 419
 420 /* --------------------------------------------------------------- */
 421 /* --------------------------------------------------------------- */
 422 /* --------------------------------------------------------------- */
 423 /* --------------------------------------------------------------- */
 424
 425
 426 static void ink_radio_action_class_init( InkRadioActionClass* klass );
 427 static void ink_radio_action_init( InkRadioAction* action );
 428 static void ink_radio_action_finalize( GObject* obj );
 429 static void ink_radio_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
 430 static void ink_radio_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
 431
 432 static GtkWidget* ink_radio_action_create_menu_item( GtkAction* action );
 433 static GtkWidget* ink_radio_action_create_tool_item( GtkAction* action );
 434
 435 static GtkRadioActionClass* gInkRadioActionParentClass = 0;
 436
 437 struct _InkRadioActionPrivate
 438 {
 439     gchar* iconId;
 440     Inkscape::IconSize iconSize;
 441 };
 442
 443 #define INK_RADIO_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), INK_RADIO_ACTION_TYPE, InkRadioActionPrivate ) )
 444
 445 GType ink_radio_action_get_type( void )
 446 {
 447     static GType myType = 0;
 448     if ( !myType ) {
 449         static const GTypeInfo myInfo = {
 450             sizeof( InkRadioActionClass ),
 451             NULL, /* base_init */
 452             NULL, /* base_finalize */
 453             (GClassInitFunc)ink_radio_action_class_init,
 454             NULL, /* class_finalize */
 455             NULL, /* class_data */
 456             sizeof( InkRadioAction ),
 457             0, /* n_preallocs */
 458             (GInstanceInitFunc)ink_radio_action_init,
 459             NULL
 460         };
 461
 462         myType = g_type_register_static( GTK_TYPE_RADIO_ACTION, "InkRadioAction", &myInfo, (GTypeFlags)0 );
 463     }
 464
 465     return myType;
 466 }
 467
 468
 469 static void ink_radio_action_class_init( InkRadioActionClass* klass )
 470 {
 471     if ( klass ) {
 472         gInkRadioActionParentClass = GTK_RADIO_ACTION_CLASS( g_type_class_peek_parent( klass ) );
 473         GObjectClass * objClass = G_OBJECT_CLASS( klass );
 474
 475         objClass->finalize = ink_radio_action_finalize;
 476         objClass->get_property = ink_radio_action_get_property;
 477         objClass->set_property = ink_radio_action_set_property;
 478
 479         klass->parent_class.parent_class.parent_class.create_menu_item = ink_radio_action_create_menu_item;
 480         klass->parent_class.parent_class.parent_class.create_tool_item = ink_radio_action_create_tool_item;
 481         /*klass->parent_class.connect_proxy = connect_proxy;*/
 482         /*klass->parent_class.disconnect_proxy = disconnect_proxy;*/
 483
 484         g_object_class_install_property( objClass,
 485                                          PROP_INK_ID,
 486                                          g_param_spec_string( "iconId",
 487                                                               "Icon ID",
 488                                                               "The id for the icon",
 489                                                               "",
 490                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 491
 492         g_object_class_install_property( objClass,
 493                                          PROP_INK_SIZE,
 494                                          g_param_spec_int( "iconSize",
 495                                                            "Icon Size",
 496                                                            "The size the icon",
 497                                                            (int)Inkscape::ICON_SIZE_MENU,
 498                                                            (int)Inkscape::ICON_SIZE_DECORATION,
 499                                                            (int)Inkscape::ICON_SIZE_SMALL_TOOLBAR,
 500                                                            (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 501
 502         g_type_class_add_private( klass, sizeof(InkRadioActionClass) );
 503     }
 504 }
 505
 506 static void ink_radio_action_init( InkRadioAction* action )
 507 {
 508     action->private_data = INK_RADIO_ACTION_GET_PRIVATE( action );
 509     action->private_data->iconId = 0;
 510     action->private_data->iconSize = Inkscape::ICON_SIZE_SMALL_TOOLBAR;
 511 }
 512
 513 static void ink_radio_action_finalize( GObject* obj )
 514 {
 515     InkRadioAction* action = INK_RADIO_ACTION( obj );
 516
 517     g_free( action->private_data->iconId );
 518     g_free( action->private_data );
 519
 520 }
 521
 522 InkRadioAction* ink_radio_action_new( const gchar *name,
 523                            const gchar *label,
 524                            const gchar *tooltip,
 525                            const gchar *inkId,
 526                            Inkscape::IconSize size )
 527 {
 528     GObject* obj = (GObject*)g_object_new( INK_RADIO_ACTION_TYPE,
 529                                            "name", name,
 530                                            "label", label,
 531                                            "tooltip", tooltip,
 532                                            "iconId", inkId,
 533                                            "iconSize", size,
 534                                            NULL );
 535
 536     InkRadioAction* action = INK_RADIO_ACTION( obj );
 537
 538     return action;
 539 }
 540
 541 static void ink_radio_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
 542 {
 543     InkRadioAction* action = INK_RADIO_ACTION( obj );
 544     (void)action;
 545     switch ( propId ) {
 546         case PROP_INK_ID:
 547         {
 548             g_value_set_string( value, action->private_data->iconId );
 549         }
 550         break;
 551
 552         case PROP_INK_SIZE:
 553         {
 554             g_value_set_int( value, action->private_data->iconSize );
 555         }
 556         break;
 557
 558         default:
 559             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 560     }
 561 }
 562
 563 void ink_radio_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
 564 {
 565     InkRadioAction* action = INK_RADIO_ACTION( obj );
 566     (void)action;
 567     switch ( propId ) {
 568         case PROP_INK_ID:
 569         {
 570             gchar* tmp = action->private_data->iconId;
 571             action->private_data->iconId = g_value_dup_string( value );
 572             g_free( tmp );
 573         }
 574         break;
 575
 576         case PROP_INK_SIZE:
 577         {
 578             action->private_data->iconSize = (Inkscape::IconSize)g_value_get_int( value );
 579         }
 580         break;
 581
 582         default:
 583         {
 584             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 585         }
 586     }
 587 }
 588
 589 static GtkWidget* ink_radio_action_create_menu_item( GtkAction* action )
 590 {
 591     GtkWidget* item = gInkRadioActionParentClass->parent_class.parent_class.create_menu_item(action);
 592
 593     return item;
 594 }
 595
 596 static GtkWidget* ink_radio_action_create_tool_item( GtkAction* action )
 597 {
 598     InkRadioAction* act = INK_RADIO_ACTION( action );
 599     GtkWidget* item = gInkRadioActionParentClass->parent_class.parent_class.create_tool_item(action);
 600
 601     if ( act->private_data->iconId ) {
 602         if ( GTK_IS_TOOL_BUTTON(item) ) {
 603             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 604
 605             GtkWidget* child = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );
 606             gtk_tool_button_set_icon_widget( button, child );
 607         } else {
 608             // For now trigger a warning but don't do anything else
 609             GtkToolButton* button = GTK_TOOL_BUTTON(item);
 610             (void)button;
 611         }
 612     }
 613
 614     // TODO investigate if needed
 615     gtk_widget_show_all( item );
 616
 617     return item;
 618 }