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 <string.h>
  45
  46 #include <gdk/gdkkeysyms.h>
  47 #include <gtk/gtktoolitem.h>
  48 #include <gtk/gtkspinbutton.h>
  49 #include <gtk/gtkhbox.h>
  50 #include <gtk/gtklabel.h>
  51 #include <gtk/gtkmisc.h>
  52 #include <gtk/gtktoolbar.h>
  53 #include <gtk/gtktooltips.h>
  54 #include <gtk/gtkradiomenuitem.h>
  55
  56 #include "ege-adjustment-action.h"
  57
  58
  59 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass );
  60 static void ege_adjustment_action_init( EgeAdjustmentAction* action );
  61 static void ege_adjustment_action_finalize( GObject* object );
  62 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec );
  63 static void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec );
  64
  65 static GtkWidget* create_menu_item( GtkAction* action );
  66 static GtkWidget* create_tool_item( GtkAction* action );
  67 static void connect_proxy( GtkAction *action, GtkWidget *proxy );
  68 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy );
  69
  70 static gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  71 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  72 static gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data );
  73
  74 static void ege_adjustment_action_defocus( EgeAdjustmentAction* action );
  75
  76 static void egeAct_free_description( gpointer data, gpointer user_data );
  77 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action );
  78
  79
  80 static GtkActionClass* gParentClass = 0;
  81 static GQuark gDataName = 0;
  82
  83 typedef struct _EgeAdjustmentDescr EgeAdjustmentDescr;
  84
  85 struct _EgeAdjustmentDescr
  86 {
  87     gchar* descr;
  88     gdouble value;
  89 };
  90
  91 struct _EgeAdjustmentActionPrivate
  92 {
  93     GtkAdjustment* adj;
  94     GtkTooltips* toolTips;
  95     GtkWidget* focusWidget;
  96     gdouble climbRate;
  97     guint digits;
  98     gdouble epsilon;
  99     gchar* format;
 100     gchar* selfId;
 101     EgeWidgetFixup toolPost;
 102     gdouble lastVal;
 103     gdouble step;
 104     gdouble page;
 105     gboolean transferFocus;
 106     GList* descriptions;
 107 };
 108
 109 #define EGE_ADJUSTMENT_ACTION_GET_PRIVATE( o ) ( G_TYPE_INSTANCE_GET_PRIVATE( (o), EGE_ADJUSTMENT_ACTION_TYPE, EgeAdjustmentActionPrivate ) )
 110
 111 enum {
 112     PROP_ADJUSTMENT = 1,
 113     PROP_FOCUS_WIDGET,
 114     PROP_CLIMB_RATE,
 115     PROP_DIGITS,
 116     PROP_SELFID,
 117     PROP_TOOL_POST
 118 };
 119
 120 enum {
 121     BUMP_TOP = 0,
 122     BUMP_PAGE_UP,
 123     BUMP_UP,
 124     BUMP_NONE,
 125     BUMP_DOWN,
 126     BUMP_PAGE_DOWN,
 127     BUMP_BOTTOM,
 128     BUMP_CUSTOM = 100
 129 };
 130
 131 GType ege_adjustment_action_get_type( void )
 132 {
 133     static GType myType = 0;
 134     if ( !myType ) {
 135         static const GTypeInfo myInfo = {
 136             sizeof( EgeAdjustmentActionClass ),
 137             NULL, /* base_init */
 138             NULL, /* base_finalize */
 139             (GClassInitFunc)ege_adjustment_action_class_init,
 140             NULL, /* class_finalize */
 141             NULL, /* class_data */
 142             sizeof( EgeAdjustmentAction ),
 143             0, /* n_preallocs */
 144             (GInstanceInitFunc)ege_adjustment_action_init,
 145             NULL
 146         };
 147
 148         myType = g_type_register_static( GTK_TYPE_ACTION, "EgeAdjustmentAction", &myInfo, (GTypeFlags)0 );
 149     }
 150
 151     return myType;
 152 }
 153
 154
 155 static void ege_adjustment_action_class_init( EgeAdjustmentActionClass* klass )
 156 {
 157     if ( klass ) {
 158         gParentClass = GTK_ACTION_CLASS( g_type_class_peek_parent( klass ) );
 159         GObjectClass * objClass = G_OBJECT_CLASS( klass );
 160
 161         gDataName = g_quark_from_string("ege-adj-action");
 162
 163         objClass->finalize = ege_adjustment_action_finalize;
 164
 165         objClass->get_property = ege_adjustment_action_get_property;
 166         objClass->set_property = ege_adjustment_action_set_property;
 167
 168         klass->parent_class.create_menu_item = create_menu_item;
 169         klass->parent_class.create_tool_item = create_tool_item;
 170         klass->parent_class.connect_proxy = connect_proxy;
 171         klass->parent_class.disconnect_proxy = disconnect_proxy;
 172
 173         g_object_class_install_property( objClass,
 174                                          PROP_ADJUSTMENT,
 175                                          g_param_spec_object( "adjustment",
 176                                                               "Adjustment",
 177                                                               "The adjustment to change",
 178                                                               GTK_TYPE_ADJUSTMENT,
 179                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 180
 181         g_object_class_install_property( objClass,
 182                                          PROP_FOCUS_WIDGET,
 183                                          g_param_spec_pointer( "focus-widget",
 184                                                                "Focus Widget",
 185                                                                "The widget to return focus to",
 186                                                                (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 187
 188         g_object_class_install_property( objClass,
 189                                          PROP_CLIMB_RATE,
 190                                          g_param_spec_double( "climb-rate",
 191                                                               "Climb Rate",
 192                                                               "The acelleraton rate",
 193                                                               0.0, G_MAXDOUBLE, 0.0,
 194                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 195
 196         g_object_class_install_property( objClass,
 197                                          PROP_DIGITS,
 198                                          g_param_spec_uint( "digits",
 199                                                             "Digits",
 200                                                             "The number of digits to show",
 201                                                             0, 20, 0,
 202                                                             (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 203
 204         g_object_class_install_property( objClass,
 205                                          PROP_SELFID,
 206                                          g_param_spec_string( "self-id",
 207                                                               "Self ID",
 208                                                               "Marker for self pointer",
 209                                                               0,
 210                                                               (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 211
 212         g_object_class_install_property( objClass,
 213                                          PROP_TOOL_POST,
 214                                          g_param_spec_pointer( "tool-post",
 215                                                                "Tool Widget post process",
 216                                                                "Function for final adjustments",
 217                                                                (GParamFlags)(G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT) ) );
 218
 219         g_type_class_add_private( klass, sizeof(EgeAdjustmentActionClass) );
 220     }
 221 }
 222
 223 static void ege_adjustment_action_init( EgeAdjustmentAction* action )
 224 {
 225     action->private_data = EGE_ADJUSTMENT_ACTION_GET_PRIVATE( action );
 226     action->private_data->adj = 0;
 227     action->private_data->toolTips = 0;
 228     action->private_data->focusWidget = 0;
 229     action->private_data->climbRate = 0.0;
 230     action->private_data->digits = 2;
 231     action->private_data->epsilon = 0.009;
 232     action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
 233     action->private_data->selfId = 0;
 234     action->private_data->toolPost = 0;
 235     action->private_data->lastVal = 0.0;
 236     action->private_data->step = 0.0;
 237     action->private_data->page = 0.0;
 238     action->private_data->transferFocus = FALSE;
 239     action->private_data->descriptions = 0;
 240 }
 241
 242 static void ege_adjustment_action_finalize( GObject* object )
 243 {
 244     EgeAdjustmentAction* action = 0;
 245     g_return_if_fail( object != NULL );
 246     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(object) );
 247
 248     action = EGE_ADJUSTMENT_ACTION( object );
 249
 250     if ( action->private_data->format ) {
 251         g_free( action->private_data->format );
 252         action->private_data->format = 0;
 253     }
 254
 255     egeAct_free_all_descriptions( action );
 256
 257     if ( G_OBJECT_CLASS(gParentClass)->finalize ) {
 258         (*G_OBJECT_CLASS(gParentClass)->finalize)(object);
 259     }
 260 }
 261
 262 EgeAdjustmentAction* ege_adjustment_action_new( GtkAdjustment* adjustment,
 263                                                 const gchar *name,
 264                                                 const gchar *label,
 265                                                 const gchar *tooltip,
 266                                                 const gchar *stock_id,
 267                                                 gdouble climb_rate,
 268                                                 guint digits )
 269 {
 270     GObject* obj = (GObject*)g_object_new( EGE_ADJUSTMENT_ACTION_TYPE,
 271                                            "name", name,
 272                                            "label", label,
 273                                            "tooltip", tooltip,
 274                                            "stock_id", stock_id,
 275                                            "adjustment", adjustment,
 276                                            "climb-rate", climb_rate,
 277                                            "digits", digits,
 278                                            NULL );
 279
 280     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 281
 282     return action;
 283 }
 284
 285 static void ege_adjustment_action_get_property( GObject* obj, guint propId, GValue* value, GParamSpec * pspec )
 286 {
 287     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 288     switch ( propId ) {
 289         case PROP_ADJUSTMENT:
 290             g_value_set_object( value, action->private_data->adj );
 291             break;
 292
 293         case PROP_FOCUS_WIDGET:
 294             g_value_set_pointer( value, action->private_data->focusWidget );
 295             break;
 296
 297         case PROP_CLIMB_RATE:
 298             g_value_set_double( value, action->private_data->climbRate );
 299             break;
 300
 301         case PROP_DIGITS:
 302             g_value_set_uint( value, action->private_data->digits );
 303             break;
 304
 305         case PROP_SELFID:
 306             g_value_set_string( value, action->private_data->selfId );
 307             break;
 308
 309         case PROP_TOOL_POST:
 310             g_value_set_pointer( value, (void*)action->private_data->toolPost );
 311             break;
 312
 313         default:
 314             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 315     }
 316 }
 317
 318 void ege_adjustment_action_set_property( GObject* obj, guint propId, const GValue *value, GParamSpec* pspec )
 319 {
 320     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( obj );
 321     switch ( propId ) {
 322         case PROP_ADJUSTMENT:
 323         {
 324             action->private_data->adj = GTK_ADJUSTMENT( g_value_get_object( value ) );
 325             g_object_get( G_OBJECT(action->private_data->adj),
 326                           "step-increment", &action->private_data->step,
 327                           "page-increment", &action->private_data->page,
 328                           NULL );
 329         }
 330         break;
 331
 332         case PROP_FOCUS_WIDGET:
 333         {
 334             /* TODO unhook prior */
 335             action->private_data->focusWidget = (GtkWidget*)g_value_get_pointer( value );
 336         }
 337         break;
 338
 339         case PROP_CLIMB_RATE:
 340         {
 341             /* TODO pass on */
 342             action->private_data->climbRate = g_value_get_double( value );
 343         }
 344         break;
 345
 346         case PROP_DIGITS:
 347         {
 348             /* TODO pass on */
 349             action->private_data->digits = g_value_get_uint( value );
 350             switch ( action->private_data->digits ) {
 351                 case 0: action->private_data->epsilon = 0.9; break;
 352                 case 1: action->private_data->epsilon = 0.09; break;
 353                 case 2: action->private_data->epsilon = 0.009; break;
 354                 case 3: action->private_data->epsilon = 0.0009; break;
 355                 case 4: action->private_data->epsilon = 0.00009; break;
 356             }
 357             if ( action->private_data->format ) {
 358                 g_free( action->private_data->format );
 359             }
 360             action->private_data->format = g_strdup_printf("%%0.%df%%s%%s", action->private_data->digits);
 361         }
 362         break;
 363
 364         case PROP_SELFID:
 365         {
 366             /* TODO pass on */
 367             gchar* prior = action->private_data->selfId;
 368             action->private_data->selfId = g_value_dup_string( value );
 369             g_free( prior );
 370         }
 371         break;
 372
 373         case PROP_TOOL_POST:
 374         {
 375             action->private_data->toolPost = (EgeWidgetFixup)g_value_get_pointer( value );
 376         }
 377         break;
 378
 379         default:
 380             G_OBJECT_WARN_INVALID_PROPERTY_ID( obj, propId, pspec );
 381     }
 382 }
 383
 384 GtkAdjustment* ege_adjustment_action_get_adjustment( EgeAdjustmentAction* action )
 385 {
 386     g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
 387
 388     return action->private_data->adj;
 389 }
 390
 391 void ege_adjustment_action_set_focuswidget( EgeAdjustmentAction* action, GtkWidget* widget )
 392 {
 393     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
 394
 395     /* TODO unhook prior */
 396
 397     action->private_data->focusWidget = widget;
 398 }
 399
 400 GtkWidget* ege_adjustment_action_get_focuswidget( EgeAdjustmentAction* action )
 401 {
 402     g_return_val_if_fail( IS_EGE_ADJUSTMENT_ACTION(action), NULL );
 403
 404     return action->private_data->focusWidget;
 405 }
 406
 407 static void egeAct_free_description( gpointer data, gpointer user_data ) {
 408     (void)user_data;
 409     if ( data ) {
 410         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)data;
 411         if ( descr->descr ) {
 412             g_free( descr->descr );
 413             descr->descr = 0;
 414         }
 415         g_free( descr );
 416     }
 417 }
 418
 419 static void egeAct_free_all_descriptions( EgeAdjustmentAction* action )
 420 {
 421     if ( action->private_data->descriptions ) {
 422         g_list_foreach( action->private_data->descriptions, egeAct_free_description, 0 );
 423         g_list_free( action->private_data->descriptions );
 424         action->private_data->descriptions = 0;
 425     }
 426 }
 427
 428 static gint egeAct_compare_descriptions( gconstpointer a, gconstpointer b )
 429 {
 430     gint val = 0;
 431
 432     EgeAdjustmentDescr const * aa = (EgeAdjustmentDescr const *)a;
 433     EgeAdjustmentDescr const * bb = (EgeAdjustmentDescr const *)b;
 434
 435     if ( aa && bb ) {
 436         if ( aa->value < bb->value ) {
 437             val = -1;
 438         } else if ( aa->value > bb->value ) {
 439             val = 1;
 440         }
 441     }
 442
 443     return val;
 444 }
 445
 446 void ege_adjustment_action_set_descriptions( EgeAdjustmentAction* action, gchar const** descriptions, gdouble const* values, guint count )
 447 {
 448     g_return_if_fail( IS_EGE_ADJUSTMENT_ACTION(action) );
 449
 450     egeAct_free_all_descriptions( action );
 451
 452     if ( count && descriptions && values ) {
 453         guint i = 0;
 454         for ( i = 0; i < count; i++ ) {
 455             EgeAdjustmentDescr* descr = g_new0( EgeAdjustmentDescr, 1 );
 456             descr->descr = descriptions[i] ? g_strdup( descriptions[i] ) : 0;
 457             descr->value = values[i];
 458             action->private_data->descriptions = g_list_insert_sorted( action->private_data->descriptions, (gpointer)descr, egeAct_compare_descriptions );
 459         }
 460     }
 461 }
 462
 463 static void process_menu_action( GtkWidget* obj, gpointer data )
 464 {
 465     GtkCheckMenuItem* item = GTK_CHECK_MENU_ITEM(obj);
 466     if ( item->active ) {
 467         EgeAdjustmentAction* act = (EgeAdjustmentAction*)g_object_get_qdata( G_OBJECT(obj), gDataName );
 468         gint what = GPOINTER_TO_INT(data);
 469
 470
 471         gdouble base = gtk_adjustment_get_value( act->private_data->adj );
 472         gdouble lower = 0.0;
 473         gdouble upper = 0.0;
 474         gdouble step = 0.0;
 475         gdouble page = 0.0;
 476         g_object_get( G_OBJECT(act->private_data->adj),
 477                       "lower", &lower,
 478                       "upper", &upper,
 479                       "step-increment", &step,
 480                       "page-increment", &page,
 481                       NULL );
 482
 483         switch ( what ) {
 484             case BUMP_TOP:
 485                 gtk_adjustment_set_value( act->private_data->adj, upper );
 486                 break;
 487
 488             case BUMP_PAGE_UP:
 489                 gtk_adjustment_set_value( act->private_data->adj, base + page );
 490                 break;
 491
 492             case BUMP_UP:
 493                 gtk_adjustment_set_value( act->private_data->adj, base + step );
 494                 break;
 495
 496             case BUMP_DOWN:
 497                 gtk_adjustment_set_value( act->private_data->adj, base - step );
 498                 break;
 499
 500             case BUMP_PAGE_DOWN:
 501                 gtk_adjustment_set_value( act->private_data->adj, base - page );
 502                 break;
 503
 504             case BUMP_BOTTOM:
 505                 gtk_adjustment_set_value( act->private_data->adj, lower );
 506                 break;
 507
 508             default:
 509                 if ( what >= BUMP_CUSTOM ) {
 510                     guint index = what - BUMP_CUSTOM;
 511                     if ( index < g_list_length( act->private_data->descriptions ) ) {
 512                         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)g_list_nth_data( act->private_data->descriptions, index );
 513                         if ( descr ) {
 514                             gtk_adjustment_set_value( act->private_data->adj, descr->value );
 515                         }
 516                     }
 517                 }
 518         }
 519     }
 520 }
 521
 522 static void create_single_menu_item( GCallback toggleCb, int val, GtkWidget* menu, EgeAdjustmentAction* act, GtkWidget** dst, GSList** group, gdouble num, gboolean active )
 523 {
 524     char* str = 0;
 525     EgeAdjustmentDescr* marker = 0;
 526     GList* cur = act->private_data->descriptions;
 527
 528     while ( cur ) {
 529         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
 530         gdouble delta = num - descr->value;
 531         if ( delta < 0.0 ) {
 532             delta = -delta;
 533         }
 534         if ( delta < act->private_data->epsilon ) {
 535             marker = descr;
 536             break;
 537         }
 538         cur = g_list_next( cur );
 539     }
 540
 541     str = g_strdup_printf( act->private_data->format, num, (marker?" ":""), ( (marker && marker->descr) ? marker->descr:"") );
 542
 543     *dst = gtk_radio_menu_item_new_with_label( *group, str );
 544     if ( !*group) {
 545         *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) );
 546     }
 547     if ( active ) {
 548         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
 549     }
 550     gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
 551     g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
 552
 553     g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
 554
 555     g_free(str);
 556 }
 557
 558 static GList* flush_explicit_items( GList* descriptions,
 559                                     GCallback toggleCb,
 560                                     int val,
 561                                     GtkWidget* menu,
 562                                     EgeAdjustmentAction* act,
 563                                     GtkWidget** dst,
 564                                     GSList** group,
 565                                     gdouble num )
 566 {
 567     GList* cur = descriptions;
 568
 569     if ( cur ) {
 570         gdouble valUpper = num + act->private_data->epsilon;
 571         gdouble valLower = num - act->private_data->epsilon;
 572
 573         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
 574
 575         while ( cur && descr && (descr->value >= valLower) ) {
 576             if ( descr->value > valUpper ) {
 577                 create_single_menu_item( toggleCb, val + g_list_position(act->private_data->descriptions, cur), menu, act, dst, group, descr->value, FALSE );
 578             }
 579
 580             cur = g_list_previous( cur );
 581             descr = cur ? (EgeAdjustmentDescr*)cur->data : 0;
 582         }
 583     }
 584
 585     return cur;
 586 }
 587
 588 static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
 589 {
 590     GtkWidget* menu = gtk_menu_new();
 591
 592     GSList* group = 0;
 593     GtkWidget* single = 0;
 594
 595     GList* addOns = g_list_last( act->private_data->descriptions );
 596
 597     gdouble base = gtk_adjustment_get_value( act->private_data->adj );
 598     gdouble lower = 0.0;
 599     gdouble upper = 0.0;
 600     gdouble step = 0.0;
 601     gdouble page = 0.0;
 602     g_object_get( G_OBJECT(act->private_data->adj),
 603                   "lower", &lower,
 604                   "upper", &upper,
 605                   "step-increment", &step,
 606                   "page-increment", &page,
 607                   NULL );
 608
 609
 610     if ( base < upper ) {
 611         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
 612         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
 613         if ( (base + page) < upper ) {
 614             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
 615             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
 616         }
 617         if ( (base + step) < upper ) {
 618             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
 619             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
 620         }
 621     }
 622
 623     addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
 624     create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
 625
 626     if ( base > lower ) {
 627         if ( (base - step) > lower ) {
 628             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
 629             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
 630         }
 631         if ( (base - page) > lower ) {
 632             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
 633             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
 634         }
 635         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
 636         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
 637     }
 638
 639     if ( act->private_data->descriptions ) {
 640         gdouble value = ((EgeAdjustmentDescr*)act->private_data->descriptions->data)->value;
 641         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
 642     }
 643
 644     return menu;
 645 }
 646
 647 static GtkWidget* create_menu_item( GtkAction* action )
 648 {
 649     GtkWidget* item = 0;
 650
 651     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 652         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 653         GValue value;
 654         const gchar*  sss = 0;
 655         GtkWidget*  subby = 0;
 656
 657         memset( &value, 0, sizeof(value) );
 658         g_value_init( &value, G_TYPE_STRING );
 659         g_object_get_property( G_OBJECT(action), "label", &value );
 660
 661         sss = g_value_get_string( &value );
 662
 663         item = gtk_menu_item_new_with_label( sss );
 664
 665         subby = create_popup_number_menu( act );
 666         gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
 667         gtk_widget_show_all( subby );
 668     } else {
 669         item = gParentClass->create_menu_item( action );
 670     }
 671
 672     return item;
 673 }
 674
 675 void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
 676 {
 677     if ( GTK_WIDGET_HAS_FOCUS( GTK_WIDGET(spin) ) ) {
 678         ege_adjustment_action_defocus( act );
 679     }
 680 }
 681
 682 static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
 683 {
 684     gboolean handled = FALSE;
 685     if ( evt->type == GDK_BUTTON_PRESS ) {
 686         if ( evt->button.button == 3 ) {
 687             if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
 688                 GdkEventButton* btnevt = (GdkEventButton*)evt;
 689                 GtkWidget* menu = create_popup_number_menu(act);
 690                 gtk_widget_show_all( menu );
 691                 gtk_menu_popup( GTK_MENU(menu), NULL, NULL, NULL, NULL, btnevt->button, btnevt->time );
 692             }
 693             handled = TRUE;
 694         }
 695     }
 696
 697     return handled;
 698 }
 699
 700 static GtkWidget* create_tool_item( GtkAction* action )
 701 {
 702     GtkWidget* item = 0;
 703
 704     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 705         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 706         GtkWidget* spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits );
 707         GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
 708         GValue value;
 709
 710         item = GTK_WIDGET( gtk_tool_item_new() );
 711
 712         memset( &value, 0, sizeof(value) );
 713         g_value_init( &value, G_TYPE_STRING );
 714         g_object_get_property( G_OBJECT(action), "label", &value );
 715         const gchar* sss = g_value_get_string( &value );
 716         GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" );
 717
 718         {
 719             GValue tooltip;
 720             memset( &tooltip, 0, sizeof(tooltip) );
 721             g_value_init( &tooltip, G_TYPE_STRING );
 722             g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
 723             const gchar* tipstr = g_value_get_string( &tooltip );
 724             if ( tipstr && *tipstr ) {
 725                 if ( !act->private_data->toolTips ) {
 726                     act->private_data->toolTips = gtk_tooltips_new();
 727                 }
 728                 gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 );
 729             }
 730         }
 731
 732         gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 );
 733
 734         gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
 735         gtk_box_pack_end( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
 736         gtk_container_add( GTK_CONTAINER(item), hb );
 737
 738         if ( act->private_data->selfId ) {
 739             g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton );
 740         }
 741
 742         g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
 743         g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
 744         g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
 745
 746         g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
 747
 748         g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
 749         gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), act->private_data->digits + 3 );
 750
 751         gtk_widget_show_all( item );
 752
 753         /* Shrink or whatnot after shown */
 754         if ( act->private_data->toolPost ) {
 755             act->private_data->toolPost( item );
 756         }
 757     } else {
 758         item = gParentClass->create_tool_item( action );
 759     }
 760
 761     return item;
 762 }
 763
 764 static void connect_proxy( GtkAction *action, GtkWidget *proxy )
 765 {
 766     gParentClass->connect_proxy( action, proxy );
 767 }
 768
 769 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
 770 {
 771     gParentClass->disconnect_proxy( action, proxy );
 772 }
 773
 774 void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
 775 {
 776     if ( action->private_data->transferFocus ) {
 777         if ( action->private_data->focusWidget ) {
 778             gtk_widget_grab_focus( action->private_data->focusWidget );
 779         }
 780     }
 781 }
 782
 783 gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 784 {
 785     (void)event;
 786     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 787         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 788         action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 789         action->private_data->transferFocus = TRUE;
 790     }
 791
 792     return FALSE; /* report event not consumed */
 793 }
 794
 795 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 796 {
 797     (void)widget;
 798     (void)event;
 799     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 800         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 801         action->private_data->transferFocus = FALSE;
 802     }
 803
 804     return FALSE; /* report event not consumed */
 805 }
 806
 807
 808 static gboolean process_tab( GtkWidget* widget, int direction )
 809 {
 810     gboolean handled = FALSE;
 811     GtkWidget* parent = gtk_widget_get_parent(widget);
 812     GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0;
 813     GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0;
 814
 815     if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
 816         GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) );
 817         if ( kids ) {
 818             GtkWidget* curr = widget;
 819             while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
 820                 curr = gtk_widget_get_parent( curr );
 821             }
 822             if ( curr ) {
 823                 GList* mid = g_list_find( kids, curr );
 824                 while ( mid ) {
 825                     mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid);
 826                     if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) {
 827                         /* potential target */
 828                         GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) );
 829                         if ( child && GTK_IS_HBOX(child) ) { /* could be ours */
 830                             GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) );
 831                             if ( subChildren ) {
 832                                 GList* last = g_list_last(subChildren);
 833                                 if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) {
 834                                     gtk_widget_grab_focus( GTK_WIDGET(last->data) );
 835                                     handled = TRUE;
 836                                     mid = 0; /* to stop loop */
 837                                 }
 838
 839                                 g_list_free(subChildren);
 840                             }
 841                         }
 842                     }
 843                 }
 844             }
 845             g_list_free( kids );
 846         }
 847     }
 848
 849     return handled;
 850 }
 851
 852 gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 853 {
 854     gboolean wasConsumed = FALSE; /* default to report event not consumed */
 855     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
 856     guint key = 0;
 857     gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
 858                                          event->hardware_keycode, (GdkModifierType)event->state,
 859                                          0, &key, 0, 0, 0 );
 860
 861     switch ( key ) {
 862         case GDK_Escape:
 863         {
 864             action->private_data->transferFocus = TRUE;
 865             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
 866             ege_adjustment_action_defocus( action );
 867             wasConsumed = TRUE;
 868         }
 869         break;
 870
 871         case GDK_Return:
 872         case GDK_KP_Enter:
 873         {
 874             action->private_data->transferFocus = TRUE;
 875             ege_adjustment_action_defocus( action );
 876             wasConsumed = TRUE;
 877         }
 878         break;
 879
 880         case GDK_Tab:
 881         {
 882             action->private_data->transferFocus = FALSE;
 883             wasConsumed = process_tab( widget, 1 );
 884         }
 885         break;
 886
 887         case GDK_ISO_Left_Tab:
 888         {
 889             action->private_data->transferFocus = FALSE;
 890             wasConsumed = process_tab( widget, -1 );
 891         }
 892         break;
 893
 894         case GDK_Up:
 895         case GDK_KP_Up:
 896         {
 897             action->private_data->transferFocus = FALSE;
 898             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 899             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
 900             wasConsumed = TRUE;
 901         }
 902         break;
 903
 904         case GDK_Down:
 905         case GDK_KP_Down:
 906         {
 907             action->private_data->transferFocus = FALSE;
 908             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 909             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
 910             wasConsumed = TRUE;
 911         }
 912         break;
 913
 914         case GDK_Page_Up:
 915         case GDK_KP_Page_Up:
 916         {
 917             action->private_data->transferFocus = FALSE;
 918             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 919             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
 920             wasConsumed = TRUE;
 921         }
 922         break;
 923
 924         case GDK_Page_Down:
 925         case GDK_KP_Page_Down:
 926         {
 927             action->private_data->transferFocus = FALSE;
 928             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 929             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
 930             wasConsumed = TRUE;
 931         }
 932         break;
 933
 934         case GDK_z:
 935         case GDK_Z:
 936         {
 937             action->private_data->transferFocus = FALSE;
 938             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
 939             wasConsumed = TRUE;
 940         }
 941         break;
 942
 943     }
 944
 945     return wasConsumed;
 946 }