src/ege-adjustment-action.cpp

   1
   2
   3 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   4  *
   5  */
   6 /* ***** BEGIN LICENSE BLOCK *****
   7  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   8  *
   9  * The contents of this file are subject to the Mozilla Public License Version
  10  * 1.1 (the "License"); you may not use this file except in compliance with
  11  * the License. You may obtain a copy of the License at
  12  * http://www.mozilla.org/MPL/
  13  *
  14  * Software distributed under the License is distributed on an "AS IS" basis,
  15  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  16  * for the specific language governing rights and limitations under the
  17  * License.
  18  *
  19  * The Original Code is EGE Adjustment Action.
  20  *
  21  * The Initial Developer of the Original Code is
  22  * Jon A. Cruz.
  23  * Portions created by the Initial Developer are Copyright (C) 2006
  24  * the Initial Developer. All Rights Reserved.
  25  *
  26  * Contributor(s):
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * either the GNU General Public License Version 2 or later (the "GPL"), or
  30  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  31  * in which case the provisions of the GPL or the LGPL are applicable instead
  32  * of those above. If you wish to allow use of your version of this file only
  33  * under the terms of either the GPL or the LGPL, and not to allow others to
  34  * use your version of this file under the terms of the MPL, indicate your
  35  * decision by deleting the provisions above and replace them with the notice
  36  * and other provisions required by the GPL or the LGPL. If you do not delete
  37  * the provisions above, a recipient may use your version of this file under
  38  * the terms of any one of the MPL, the GPL or the LGPL.
  39  *
  40  * ***** END LICENSE BLOCK ***** */
  41
  42 /* Note: this file should be kept compilable as both .cpp and .c */
  43
  44 #include <cmath>
  45 #include <string.h>
  46
  47 #include <gdk/gdkkeysyms.h>
  48 #include <gtk/gtkversion.h>
  49 #include <gtk/gtktoolitem.h>
  50 #include <gtk/gtk.h>
  51 #include <gtk/gtkhscale.h>
  52 #if GTK_CHECK_VERSION(2,12,0)
  53 #include <gtk/gtkscalebutton.h>
  54 #include <gtk/gtkstock.h>
  55 #endif /* GTK_CHECK_VERSION(2,12,0) */
  56 #include <gtk/gtkhbox.h>
  57 #include <gtk/gtklabel.h>
  58 #include <gtk/gtkmisc.h>
  59 #include <gtk/gtktoolbar.h>
  60 #include <gtk/gtktooltips.h>
  61 #include <gtk/gtkradiomenuitem.h>
  62
  63 #include "widgets/icon.h"
  64 #include "icon-size.h"
  65 #include "ege-adjustment-action.h"
  66
  67
  68 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass );
  69 static void ege_adjustment_action_init( EgeAdjustmentAction* action );
  70 static void ege_adjustment_action_finalize( GObject* object );
  71 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
  72 static void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
  73
  74 static GtkWidget* create_menu_item( GtkAction* action );
  75 static GtkWidget* create_tool_item( GtkAction* action );
  76 static void connect_proxy( GtkAction *action, GtkWidget *proxy );
  77 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy );
  78
  79 static gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  80 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  81 static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  82
  83 static void ege_adjustment_action_defocus( EgeAdjustmentAction* action );
  84
  85 static void egeAct_free_description( gpointer data, gpointer user_data );
  86 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action );
  87
  88
  89 static GtkActionClass* gParentClass = 0;
  90 static GQuark gDataName = 0;
  91
  92 enum {
  93     APPEARANCE_UNKNOWN = -1,
  94     APPEARANCE_NONE = 0,
  95     APPEARANCE_FULL,    // label, then all choices represented by separate buttons
  96     APPEARANCE_COMPACT, // label, then choices in a drop-down menu
  97     APPEARANCE_MINIMAL, // no label, just choices in a drop-down menu
  98 };
  99
 100 #if GTK_CHECK_VERSION(2,12,0)
 101 /* TODO need to have appropriate icons setup for these: */
 102 static const gchar *floogles[] = {
 103     GTK_STOCK_REMOVE,
 104     GTK_STOCK_ADD,
 105     GTK_STOCK_GO_DOWN,
 106     GTK_STOCK_ABOUT,
 107     GTK_STOCK_GO_UP,
 108     0};
 109 #endif /* GTK_CHECK_VERSION(2,12,0) */
 110
 111 typedef struct _EgeAdjustmentDescr EgeAdjustmentDescr;
 112
 113 struct _EgeAdjustmentDescr
 114 {
 115     gchar* descr;
 116     gdouble value;
 117 };
 118
 119 struct _EgeAdjustmentActionPrivate
 120 {
 121     GtkAdjustment* adj;
 122     GtkTooltips* toolTips;
 123     GtkWidget* focusWidget;
 124     gdouble climbRate;
 125     guint digits;
 126     gdouble epsilon;
 127     gchar* format;
 128     gchar* selfId;
 129     EgeWidgetFixup toolPost;
 130     gdouble lastVal;
 131     gdouble step;
 132     gdouble page;
 133     gint appearanceMode;
 134     gboolean transferFocus;
 135     GList* descriptions;
 136     gchar* appearance;
 137     gchar* iconId;
 138     Inkscape::IconSize iconSize;
 139 };
 140
 141 #define EGE_ADJUSTMENT_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionPrivate ) )
 142
 143 enum {
 144     PROP_ADJUSTMENT = 1,
 145     PROP_FOCUS_WIDGET,
 146     PROP_CLIMB_RATE,
 147     PROP_DIGITS,
 148     PROP_SELFID,
 149     PROP_TOOL_POST,
 150     PROP_APPEARANCE,
 151     PROP_ICON_ID,
 152     PROP_ICON_SIZE
 153 };
 154
 155 enum {
 156     BUMP_TOP = 0,
 157     BUMP_PAGE_UP,
 158     BUMP_UP,
 159     BUMP_NONE,
 160     BUMP_DOWN,
 161     BUMP_PAGE_DOWN,
 162     BUMP_BOTTOM,
 163     BUMP_CUSTOM = 100
 164 };
 165
 166 GType ege_adjustment_action_get_type( void )
 167 {
 168     static GType myType = 0;
 169     if ( !myType ) {
 170         static const GTypeInfo myInfo = {
 171             sizeof( EgeAdjustmentActionClass ),
 172             NULL, /* base_init */
 173             NULL, /* base_finalize */
 174             (GClassInitFunc)ege_adjustment_action_class_init,
 175             NULL, /* class_finalize */
 176             NULL, /* class_data */
 177             sizeof( EgeAdjustmentAction ),
 178             0, /* n_preallocs */
 179             (GInstanceInitFunc)ege_adjustment_action_init,
 180             NULL
 181         };
 182
 183         myType = g_type_register_static( GTK_TYPE_ACTION, "EgeAdjustmentAction", &myInfo, (GTypeFlags)0 );
 184     }
 185
 186     return myType;
 187 }
 188
 189
 190 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass )
 191 {
 192     if ( klass ) {
 193         gParentClass = GTK_ACTION_CLASS( g_type_class_peek_parent( klass ) );
 194         GObjectClass * objClass = G_OBJECT_CLASS( klass );
 195
 196         gDataName = g_quark_from_string("ege-adj-action");
 197
 198         objClass->finalize = ege_adjustment_action_finalize;
 199
 200         objClass->get_property = ege_adjustment_action_get_property;
 201         objClass->set_property = ege_adjustment_action_set_property;
 202
 203         klass->parent_class.create_menu_item = create_menu_item;
 204         klass->parent_class.create_tool_item = create_tool_item;
 205         klass->parent_class.connect_proxy = connect_proxy;
 206         klass->parent_class.disconnect_proxy = disconnect_proxy;
 207
 208         g_object_class_install_property( objClass,
 209                                          PROP_ADJUSTMENT,
 210                                          g_param_spec_object( "adjustment",
 211                                                               "Adjustment",
 212                                                               "The adjustment to change",
 213                                                               GTK_TYPE_ADJUSTMENT,
 214                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 215
 216         g_object_class_install_property( objClass,
 217                                          PROP_FOCUS_WIDGET,
 218                                          g_param_spec_pointer( "focus-widget",
 219                                                                "Focus Widget",
 220                                                                "The widget to return focus to",
 221                                                                (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 222
 223         g_object_class_install_property( objClass,
 224                                          PROP_CLIMB_RATE,
 225                                          g_param_spec_double( "climb-rate",
 226                                                               "Climb Rate",
 227                                                               "The acelleraton rate",
 228                                                               0.0, G_MAXDOUBLE, 0.0,
 229                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 230
 231         g_object_class_install_property( objClass,
 232                                          PROP_DIGITS,
 233                                          g_param_spec_uint( "digits",
 234                                                             "Digits",
 235                                                             "The number of digits to show",
 236                                                             0, 20, 0,
 237                                                             (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 238
 239         g_object_class_install_property( objClass,
 240                                          PROP_SELFID,
 241                                          g_param_spec_string( "self-id",
 242                                                               "Self ID",
 243                                                               "Marker for self pointer",
 244                                                               0,
 245                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 246
 247         g_object_class_install_property( objClass,
 248                                          PROP_TOOL_POST,
 249                                          g_param_spec_pointer( "tool-post",
 250                                                                "Tool Widget post process",
 251                                                                "Function for final adjustments",
 252                                                                (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 253
 254         g_object_class_install_property( objClass,
 255                                          PROP_APPEARANCE,
 256                                          g_param_spec_string( "appearance",
 257                                                               "Appearance hint",
 258                                                               "A hint for how to display",
 259                                                               "",
 260                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 261
 262         g_object_class_install_property( objClass,
 263                                          PROP_ICON_ID,
 264                                          g_param_spec_string( "iconId",
 265                                                               "Icon ID",
 266                                                               "The id for the icon",
 267                                                               "",
 268                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 269
 270         g_object_class_install_property( objClass,
 271                                          PROP_ICON_SIZE,
 272                                          g_param_spec_int( "iconSize",
 273                                                            "Icon Size",
 274                                                            "The size the icon",
 275                                                            (int)Inkscape::ICON_SIZE_MENU,
 276                                                            (int)Inkscape::ICON_SIZE_DECORATION,
 277                                                            (int)Inkscape::ICON_SIZE_SMALL_TOOLBAR,
 278                                                            (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 279
 280         g_type_class_add_private( klass, sizeof(EgeAdjustmentActionClass) );
 281     }
 282 }
 283
 284 static void ege_adjustment_action_init( EgeAdjustmentAction* action )
 285 {
 286     action->private_data = EGE_ADJUSTMENT_ACTION_GET_PRIVATE( action );
 287     action->private_data->adj = 0;
 288     action->private_data->toolTips = 0;
 289     action->private_data->focusWidget = 0;
 290     action->private_data->climbRate = 0.0;
 291     action->private_data->digits = 2;
 292     action->private_data->epsilon = 0.009;
 293     action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
 294     action->private_data->selfId = 0;
 295     action->private_data->toolPost = 0;
 296     action->private_data->lastVal = 0.0;
 297     action->private_data->step = 0.0;
 298     action->private_data->page = 0.0;
 299     action->private_data->appearanceMode = APPEARANCE_NONE;
 300     action->private_data->transferFocus = FALSE;
 301     action->private_data->descriptions = 0;
 302     action->private_data->appearance = 0;
 303     action->private_data->iconId = 0;
 304     action->private_data->iconSize = Inkscape::ICON_SIZE_SMALL_TOOLBAR;
 305 }
 306
 307 static void ege_adjustment_action_finalize( GObject* object )
 308 {
 309     EgeAdjustmentAction* action = 0;
 310     g_return_if_fail( object != NULL );
 311     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(object) );
 312
 313     action = EGE_ADJUSTMENT_ACTION( object );
 314
 315     if ( action->private_data->format ) {
 316         g_free( action->private_data->format );
 317         action->private_data->format = 0;
 318     }
 319
 320     egeAct_free_all_descriptions( action );
 321
 322     if ( G_OBJECT_CLASS(gParentClass)->finalize ) {
 323         (*G_OBJECT_CLASS(gParentClass)->finalize)(object);
 324     }
 325 }
 326
 327 EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
 328                                                 const gchar *name,
 329                                                 const gchar *label,
 330                                                 const gchar *tooltip,
 331                                                 const gchar *stock_id,
 332                                                 gdouble climb_rate,
 333                                                 guint digits )
 334 {
 335     GObject* obj = (GObject*)g_object_new( EGE_ADJUSTMENT_ACTION_TYPE,
 336                                            "name", name,
 337                                            "label", label,
 338                                            "tooltip", tooltip,
 339                                            "stock_id", stock_id,
 340                                            "adjustment", adjustment,
 341                                            "climb-rate", climb_rate,
 342                                            "digits", digits,
 343                                            NULL );
 344
 345     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 346
 347     return action;
 348 }
 349
 350 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
 351 {
 352     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 353     switch ( propId ) {
 354         case PROP_ADJUSTMENT:
 355             g_value_set_object( value, action->private_data->adj );
 356             break;
 357
 358         case PROP_FOCUS_WIDGET:
 359             g_value_set_pointer( value, action->private_data->focusWidget );
 360             break;
 361
 362         case PROP_CLIMB_RATE:
 363             g_value_set_double( value, action->private_data->climbRate );
 364             break;
 365
 366         case PROP_DIGITS:
 367             g_value_set_uint( value, action->private_data->digits );
 368             break;
 369
 370         case PROP_SELFID:
 371             g_value_set_string( value, action->private_data->selfId );
 372             break;
 373
 374         case PROP_TOOL_POST:
 375             g_value_set_pointer( value, (void*)action->private_data->toolPost );
 376             break;
 377
 378         case PROP_APPEARANCE:
 379             g_value_set_string( value, action->private_data->appearance );
 380             break;
 381
 382         case PROP_ICON_ID:
 383             g_value_set_string( value, action->private_data->iconId );
 384             break;
 385
 386         case PROP_ICON_SIZE:
 387             g_value_set_int( value, action->private_data->iconSize );
 388             break;
 389
 390         default:
 391             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 392     }
 393 }
 394
 395 void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
 396 {
 397     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 398     switch ( propId ) {
 399         case PROP_ADJUSTMENT:
 400         {
 401             action->private_data->adj = GTK_ADJUSTMENT( g_value_get_object( value ) );
 402             g_object_get( G_OBJECT(action->private_data->adj),
 403                           "step-increment", &action->private_data->step,
 404                           "page-increment", &action->private_data->page,
 405                           NULL );
 406         }
 407         break;
 408
 409         case PROP_FOCUS_WIDGET:
 410         {
 411             /* TODO unhook prior */
 412             action->private_data->focusWidget = (GtkWidget*)g_value_get_pointer( value );
 413         }
 414         break;
 415
 416         case PROP_CLIMB_RATE:
 417         {
 418             /* TODO pass on */
 419             action->private_data->climbRate = g_value_get_double( value );
 420         }
 421         break;
 422
 423         case PROP_DIGITS:
 424         {
 425             /* TODO pass on */
 426             action->private_data->digits = g_value_get_uint( value );
 427             switch ( action->private_data->digits ) {
 428                 case 0: action->private_data->epsilon = 0.9; break;
 429                 case 1: action->private_data->epsilon = 0.09; break;
 430                 case 2: action->private_data->epsilon = 0.009; break;
 431                 case 3: action->private_data->epsilon = 0.0009; break;
 432                 case 4: action->private_data->epsilon = 0.00009; break;
 433             }
 434             if ( action->private_data->format ) {
 435                 g_free( action->private_data->format );
 436             }
 437             action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
 438         }
 439         break;
 440
 441         case PROP_SELFID:
 442         {
 443             /* TODO pass on */
 444             gchar* prior = action->private_data->selfId;
 445             action->private_data->selfId = g_value_dup_string( value );
 446             g_free( prior );
 447         }
 448         break;
 449
 450         case PROP_TOOL_POST:
 451         {
 452             action->private_data->toolPost = (EgeWidgetFixup)g_value_get_pointer( value );
 453         }
 454         break;
 455
 456         case PROP_APPEARANCE:
 457         {
 458             gchar* tmp = action->private_data->appearance;
 459             gchar* newVal = g_value_dup_string( value );
 460             action->private_data->appearance = newVal;
 461             g_free( tmp );
 462
 463             if ( !action->private_data->appearance || (strcmp("", newVal) == 0) ) {
 464                 action->private_data->appearanceMode = APPEARANCE_NONE;
 465             } else if ( strcmp("full", newVal) == 0 ) {
 466                 action->private_data->appearanceMode = APPEARANCE_FULL;
 467             } else if ( strcmp("compact", newVal) == 0 ) {
 468                 action->private_data->appearanceMode = APPEARANCE_COMPACT;
 469             } else if ( strcmp("minimal", newVal) == 0 ) {
 470                 action->private_data->appearanceMode = APPEARANCE_MINIMAL;
 471             } else {
 472                 action->private_data->appearanceMode = APPEARANCE_UNKNOWN;
 473             }
 474         }
 475         break;
 476
 477         case PROP_ICON_ID:
 478         {
 479             gchar* tmp = action->private_data->iconId;
 480             action->private_data->iconId = g_value_dup_string( value );
 481             g_free( tmp );
 482         }
 483         break;
 484
 485         case PROP_ICON_SIZE:
 486         {
 487             action->private_data->iconSize = (Inkscape::IconSize)g_value_get_int( value );
 488         }
 489         break;
 490
 491         default:
 492             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 493     }
 494 }
 495
 496 GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action )
 497 {
 498     g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
 499
 500     return action->private_data->adj;
 501 }
 502
 503 void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget )
 504 {
 505     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
 506
 507     /* TODO unhook prior */
 508
 509     action->private_data->focusWidget = widget;
 510 }
 511
 512 GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action )
 513 {
 514     g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
 515
 516     return action->private_data->focusWidget;
 517 }
 518
 519 static void egeAct_free_description( gpointer data, gpointer user_data ) {
 520     (void)user_data;
 521     if ( data ) {
 522         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)data;
 523         if ( descr->descr ) {
 524             g_free( descr->descr );
 525             descr->descr = 0;
 526         }
 527         g_free( descr );
 528     }
 529 }
 530
 531 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action )
 532 {
 533     if ( action->private_data->descriptions ) {
 534         g_list_foreach( action->private_data->descriptions, egeAct_free_description, 0 );
 535         g_list_free( action->private_data->descriptions );
 536         action->private_data->descriptions = 0;
 537     }
 538 }
 539
 540 static gint egeAct_compare_descriptions( gconstpointer a, gconstpointer b )
 541 {
 542     gint val = 0;
 543
 544     EgeAdjustmentDescr const * aa = (EgeAdjustmentDescr const *)a;
 545     EgeAdjustmentDescr const * bb = (EgeAdjustmentDescr const *)b;
 546
 547     if ( aa && bb ) {
 548         if ( aa->value < bb->value ) {
 549             val = -1;
 550         } else if ( aa->value > bb->value ) {
 551             val = 1;
 552         }
 553     }
 554
 555     return val;
 556 }
 557
 558 void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count )
 559 {
 560     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
 561
 562     egeAct_free_all_descriptions( action );
 563
 564     if ( count && descriptions && values ) {
 565         guint i = 0;
 566         for ( i = 0; i < count; i++ ) {
 567             EgeAdjustmentDescr* descr = g_new0( EgeAdjustmentDescr, 1 );
 568             descr->descr = descriptions[i] ? g_strdup( descriptions[i] ) : 0;
 569             descr->value = values[i];
 570             action->private_data->descriptions = g_list_insert_sorted( action->private_data->descriptions, (gpointer)descr, egeAct_compare_descriptions );
 571         }
 572     }
 573 }
 574
 575 void ege_adjustment_action_set_appearance( EgeAdjustmentAction* action, gchar const* val )
 576 {
 577     g_object_set( G_OBJECT(action), "appearance", val, NULL );
 578 }
 579
 580 static void process_menu_action( GtkWidget* obj, gpointer data )
 581 {
 582     GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(obj);
 583     if ( item->active ) {
 584         EgeAdjustmentAction* act = (EgeAdjustmentAction*)g_object_get_qdata( G_OBJECT(obj), gDataName );
 585         gint what = GPOINTER_TO_INT(data);
 586
 587
 588         gdouble base = gtk_adjustment_get_value( act->private_data->adj );
 589         gdouble lower = 0.0;
 590         gdouble upper = 0.0;
 591         gdouble step = 0.0;
 592         gdouble page = 0.0;
 593         g_object_get( G_OBJECT(act->private_data->adj),
 594                       "lower", &lower,
 595                       "upper", &upper,
 596                       "step-increment", &step,
 597                       "page-increment", &page,
 598                       NULL );
 599
 600         switch ( what ) {
 601             case BUMP_TOP:
 602                 gtk_adjustment_set_value( act->private_data->adj, upper );
 603                 break;
 604
 605             case BUMP_PAGE_UP:
 606                 gtk_adjustment_set_value( act->private_data->adj, base + page );
 607                 break;
 608
 609             case BUMP_UP:
 610                 gtk_adjustment_set_value( act->private_data->adj, base + step );
 611                 break;
 612
 613             case BUMP_DOWN:
 614                 gtk_adjustment_set_value( act->private_data->adj, base - step );
 615                 break;
 616
 617             case BUMP_PAGE_DOWN:
 618                 gtk_adjustment_set_value( act->private_data->adj, base - page );
 619                 break;
 620
 621             case BUMP_BOTTOM:
 622                 gtk_adjustment_set_value( act->private_data->adj, lower );
 623                 break;
 624
 625             default:
 626                 if ( what >= BUMP_CUSTOM ) {
 627                     guint index = what - BUMP_CUSTOM;
 628                     if ( index < g_list_length( act->private_data->descriptions ) ) {
 629                         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)g_list_nth_data( act->private_data->descriptions, index );
 630                         if ( descr ) {
 631                             gtk_adjustment_set_value( act->private_data->adj, descr->value );
 632                         }
 633                     }
 634                 }
 635         }
 636     }
 637 }
 638
 639 static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, GSList** group, gdouble num, gboolean active )
 640 {
 641     char* str = 0;
 642     EgeAdjustmentDescr* marker = 0;
 643     GList* cur = act->private_data->descriptions;
 644
 645     while ( cur ) {
 646         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
 647         gdouble delta = num - descr->value;
 648         if ( delta < 0.0 ) {
 649             delta = -delta;
 650         }
 651         if ( delta < act->private_data->epsilon ) {
 652             marker = descr;
 653             break;
 654         }
 655         cur = g_list_next( cur );
 656     }
 657
 658     str = g_strdup_printf( act->private_data->format, num,
 659                            ((marker && marker->descr) ? ": " : ""),
 660                            ((marker && marker->descr) ? marker->descr : ""));
 661
 662     *dst = gtk_radio_menu_item_new_with_label( *group, str );
 663     if ( !*group) {
 664         *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) );
 665     }
 666     if ( active ) {
 667         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
 668     }
 669     gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
 670     g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
 671
 672     g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
 673
 674     g_free(str);
 675 }
 676
 677 static GList* flush_explicit_items( GList* descriptions,
 678                                     GCallback toggleCb,
 679                                     int val,
 680                                     GtkWidget* menu,
 681                                     EgeAdjustmentAction* act,
 682                                     GtkWidget** dst,
 683                                     GSList** group,
 684                                     gdouble num )
 685 {
 686     GList* cur = descriptions;
 687
 688     if ( cur ) {
 689         gdouble valUpper = num + act->private_data->epsilon;
 690         gdouble valLower = num - act->private_data->epsilon;
 691
 692         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
 693
 694         while ( cur && descr && (descr->value >= valLower) ) {
 695             if ( descr->value > valUpper ) {
 696                 create_single_menu_item( toggleCb, val + g_list_position(act->private_data->descriptions, cur), menu, act, dst, group, descr->value, FALSE );
 697             }
 698
 699             cur = g_list_previous( cur );
 700             descr = cur ? (EgeAdjustmentDescr*)cur->data : 0;
 701         }
 702     }
 703
 704     return cur;
 705 }
 706
 707 static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
 708 {
 709     GtkWidget* menu = gtk_menu_new();
 710
 711     GSList* group = 0;
 712     GtkWidget* single = 0;
 713
 714     GList* addOns = g_list_last( act->private_data->descriptions );
 715
 716     gdouble base = gtk_adjustment_get_value( act->private_data->adj );
 717     gdouble lower = 0.0;
 718     gdouble upper = 0.0;
 719     gdouble step = 0.0;
 720     gdouble page = 0.0;
 721     g_object_get( G_OBJECT(act->private_data->adj),
 722                   "lower", &lower,
 723                   "upper", &upper,
 724                   "step-increment", &step,
 725                   "page-increment", &page,
 726                   NULL );
 727
 728
 729     if ( base < upper ) {
 730         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
 731         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
 732         if ( (base + page) < upper ) {
 733             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
 734             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
 735         }
 736         if ( (base + step) < upper ) {
 737             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
 738             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
 739         }
 740     }
 741
 742     addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
 743     create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
 744
 745     if ( base > lower ) {
 746         if ( (base - step) > lower ) {
 747             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
 748             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
 749         }
 750         if ( (base - page) > lower ) {
 751             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
 752             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
 753         }
 754         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
 755         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
 756     }
 757
 758     if ( act->private_data->descriptions ) {
 759         gdouble value = ((EgeAdjustmentDescr*)act->private_data->descriptions->data)->value;
 760         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
 761     }
 762
 763     return menu;
 764 }
 765
 766 static GtkWidget* create_menu_item( GtkAction* action )
 767 {
 768     GtkWidget* item = 0;
 769
 770     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 771         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 772         GValue value;
 773         const gchar*  sss = 0;
 774         GtkWidget*  subby = 0;
 775
 776         memset( &value, 0, sizeof(value) );
 777         g_value_init( &value, G_TYPE_STRING );
 778         g_object_get_property( G_OBJECT(action), "label", &value );
 779
 780         sss = g_value_get_string( &value );
 781
 782         item = gtk_menu_item_new_with_label( sss );
 783
 784         subby = create_popup_number_menu( act );
 785         gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
 786         gtk_widget_show_all( subby );
 787     } else {
 788         item = gParentClass->create_menu_item( action );
 789     }
 790
 791     return item;
 792 }
 793
 794 void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
 795 {
 796     if ( GTK_WIDGET_HAS_FOCUS( GTK_WIDGET(spin) ) ) {
 797         ege_adjustment_action_defocus( act );
 798     }
 799 }
 800
 801 static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
 802 {
 803     gboolean handled = FALSE;
 804     if ( evt->type == GDK_BUTTON_PRESS ) {
 805         if ( evt->button.button == 3 ) {
 806             if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
 807                 GdkEventButton* btnevt = (GdkEventButton*)evt;
 808                 GtkWidget* menu = create_popup_number_menu(act);
 809                 gtk_widget_show_all( menu );
 810                 gtk_menu_popup( GTK_MENU(menu), NULL, NULL, NULL, NULL, btnevt->button, btnevt->time );
 811             }
 812             handled = TRUE;
 813         }
 814     }
 815
 816     return handled;
 817 }
 818
 819 static gchar*
 820 slider_format_falue (GtkScale* scale, gdouble value, gchar *label)
 821 {
 822     (void)scale;
 823     return g_strdup_printf("%s %d", label, (int) round(value));
 824 }
 825
 826 static GtkWidget* create_tool_item( GtkAction* action )
 827 {
 828     GtkWidget* item = 0;
 829
 830     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 831         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 832         GtkWidget* spinbutton = 0;
 833         GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
 834
 835         GValue value;
 836         memset( &value, 0, sizeof(value) );
 837         g_value_init( &value, G_TYPE_STRING );
 838         g_object_get_property( G_OBJECT(action), "short_label", &value );
 839         const gchar* sss = g_value_get_string( &value );
 840
 841         if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
 842             // Slider
 843             spinbutton = gtk_hscale_new( act->private_data->adj);
 844             gtk_widget_set_size_request(spinbutton, 100, -1);
 845             gtk_scale_set_digits (GTK_SCALE(spinbutton), 0);
 846             gtk_signal_connect(GTK_OBJECT(spinbutton), "format-value", GTK_SIGNAL_FUNC(slider_format_falue), (void *) sss);
 847
 848 #if GTK_CHECK_VERSION(2,12,0)
 849         } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) {
 850             spinbutton = gtk_scale_button_new( GTK_ICON_SIZE_MENU, 0, 100, 2, 0 );
 851             gtk_scale_button_set_adjustment( GTK_SCALE_BUTTON(spinbutton), act->private_data->adj );
 852             gtk_scale_button_set_icons( GTK_SCALE_BUTTON(spinbutton), floogles );
 853 #endif /* GTK_CHECK_VERSION(2,12,0) */
 854         } else {
 855             spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits );
 856         }
 857
 858         item = GTK_WIDGET( gtk_tool_item_new() );
 859
 860         {
 861             GValue tooltip;
 862             memset( &tooltip, 0, sizeof(tooltip) );
 863             g_value_init( &tooltip, G_TYPE_STRING );
 864             g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
 865             const gchar* tipstr = g_value_get_string( &tooltip );
 866             if ( tipstr && *tipstr ) {
 867                 if ( !act->private_data->toolTips ) {
 868                     act->private_data->toolTips = gtk_tooltips_new();
 869                 }
 870                 gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 );
 871             }
 872         }
 873
 874         if ( act->private_data->appearanceMode != APPEARANCE_FULL ) {
 875             GtkWidget* filler1 = gtk_label_new(" ");
 876             gtk_box_pack_start( GTK_BOX(hb), filler1, FALSE, FALSE, 0 );
 877
 878             // Use an icon if available or use short-label
 879             if ( act->private_data->iconId && strcmp( act->private_data->iconId, "" ) != 0 ) {
 880                 GtkWidget* icon = sp_icon_new( act->private_data->iconSize, act->private_data->iconId );
 881                 gtk_box_pack_start( GTK_BOX(hb), icon, FALSE, FALSE, 0 );
 882             } else {
 883                 GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" );
 884                 gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 );
 885                 gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
 886             }
 887         }
 888
 889         if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
 890             gtk_box_pack_start( GTK_BOX(hb), spinbutton, TRUE, TRUE, 0 );
 891         }  else {
 892             gtk_box_pack_start( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
 893         }
 894
 895         gtk_container_add( GTK_CONTAINER(item), hb );
 896
 897         if ( act->private_data->selfId ) {
 898             g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton );
 899         }
 900
 901         g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
 902         g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
 903         g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
 904
 905         g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
 906
 907         g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
 908         if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
 909             /* */
 910 #if GTK_CHECK_VERSION(2,12,0)
 911         } else if ( act->private_data->appearanceMode == APPEARANCE_MINIMAL ) {
 912             /* */
 913 #endif /* GTK_CHECK_VERSION(2,12,0) */
 914         } else {
 915             gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), act->private_data->digits + 3 );
 916         }
 917
 918         gtk_widget_show_all( item );
 919
 920         /* Shrink or whatnot after shown */
 921         if ( act->private_data->toolPost ) {
 922             act->private_data->toolPost( item );
 923         }
 924     } else {
 925         item = gParentClass->create_tool_item( action );
 926     }
 927
 928     return item;
 929 }
 930
 931 static void connect_proxy( GtkAction *action, GtkWidget *proxy )
 932 {
 933     gParentClass->connect_proxy( action, proxy );
 934 }
 935
 936 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
 937 {
 938     gParentClass->disconnect_proxy( action, proxy );
 939 }
 940
 941 void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
 942 {
 943     if ( action->private_data->transferFocus ) {
 944         if ( action->private_data->focusWidget ) {
 945             gtk_widget_grab_focus( action->private_data->focusWidget );
 946         }
 947     }
 948 }
 949
 950 gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 951 {
 952     (void)event;
 953     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 954         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 955         if ( GTK_IS_SPIN_BUTTON(widget) ) {
 956             action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 957 #if GTK_CHECK_VERSION(2,12,0)
 958         } else if ( GTK_IS_SCALE_BUTTON(widget) ) {
 959             action->private_data->lastVal = gtk_scale_button_get_value( GTK_SCALE_BUTTON(widget) );
 960 #endif /* GTK_CHECK_VERSION(2,12,0) */
 961         } else if (GTK_IS_RANGE(widget) ) {
 962             action->private_data->lastVal = gtk_range_get_value( GTK_RANGE(widget) );
 963         }
 964         action->private_data->transferFocus = TRUE;
 965     }
 966
 967     return FALSE; /* report event not consumed */
 968 }
 969
 970 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 971 {
 972     (void)widget;
 973     (void)event;
 974     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 975         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 976         action->private_data->transferFocus = FALSE;
 977     }
 978
 979     return FALSE; /* report event not consumed */
 980 }
 981
 982
 983 static gboolean process_tab( GtkWidget* widget, int direction )
 984 {
 985     gboolean handled = FALSE;
 986     GtkWidget* parent = gtk_widget_get_parent(widget);
 987     GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0;
 988     GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0;
 989
 990     if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
 991         GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) );
 992         if ( kids ) {
 993             GtkWidget* curr = widget;
 994             while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
 995                 curr = gtk_widget_get_parent( curr );
 996             }
 997             if ( curr ) {
 998                 GList* mid = g_list_find( kids, curr );
 999                 while ( mid ) {
1000                     mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid);
1001                     if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) {
1002                         /* potential target */
1003                         GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) );
1004                         if ( child && GTK_IS_HBOX(child) ) { /* could be ours */
1005                             GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) );
1006                             if ( subChildren ) {
1007                                 GList* last = g_list_last(subChildren);
1008                                 if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) {
1009                                     gtk_widget_grab_focus( GTK_WIDGET(last->data) );
1010                                     handled = TRUE;
1011                                     mid = 0; /* to stop loop */
1012                                 }
1013
1014                                 g_list_free(subChildren);
1015                             }
1016                         }
1017                     }
1018                 }
1019             }
1020             g_list_free( kids );
1021         }
1022     }
1023
1024     return handled;
1025 }
1026
1027 gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
1028 {
1029     gboolean wasConsumed = FALSE; /* default to report event not consumed */
1030     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
1031     guint key = 0;
1032     gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
1033                                          event->hardware_keycode, (GdkModifierType)event->state,
1034                                          0, &key, 0, 0, 0 );
1035
1036     switch ( key ) {
1037         case GDK_Escape:
1038         {
1039             action->private_data->transferFocus = TRUE;
1040             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
1041             ege_adjustment_action_defocus( action );
1042             wasConsumed = TRUE;
1043         }
1044         break;
1045
1046         case GDK_Return:
1047         case GDK_KP_Enter:
1048         {
1049             action->private_data->transferFocus = TRUE;
1050             ege_adjustment_action_defocus( action );
1051             wasConsumed = TRUE;
1052         }
1053         break;
1054
1055         case GDK_Tab:
1056         {
1057             action->private_data->transferFocus = FALSE;
1058             wasConsumed = process_tab( widget, 1 );
1059         }
1060         break;
1061
1062         case GDK_ISO_Left_Tab:
1063         {
1064             action->private_data->transferFocus = FALSE;
1065             wasConsumed = process_tab( widget, -1 );
1066         }
1067         break;
1068
1069         case GDK_Up:
1070         case GDK_KP_Up:
1071         {
1072             action->private_data->transferFocus = FALSE;
1073             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1074             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
1075             wasConsumed = TRUE;
1076         }
1077         break;
1078
1079         case GDK_Down:
1080         case GDK_KP_Down:
1081         {
1082             action->private_data->transferFocus = FALSE;
1083             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1084             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
1085             wasConsumed = TRUE;
1086         }
1087         break;
1088
1089         case GDK_Page_Up:
1090         case GDK_KP_Page_Up:
1091         {
1092             action->private_data->transferFocus = FALSE;
1093             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1094             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
1095             wasConsumed = TRUE;
1096         }
1097         break;
1098
1099         case GDK_Page_Down:
1100         case GDK_KP_Page_Down:
1101         {
1102             action->private_data->transferFocus = FALSE;
1103             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
1104             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
1105             wasConsumed = TRUE;
1106         }
1107         break;
1108
1109         case GDK_z:
1110         case GDK_Z:
1111         {
1112             action->private_data->transferFocus = FALSE;
1113             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
1114             wasConsumed = TRUE;
1115         }
1116         break;
1117
1118     }
1119
1120     return wasConsumed;
1121 }