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