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,
 542                            ((marker && marker->descr) ? ": " : ""),
 543                            ((marker && marker->descr) ? marker->descr : ""));
 544
 545     *dst = gtk_radio_menu_item_new_with_label( *group, str );
 546     if ( !*group) {
 547         *group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(*dst) );
 548     }
 549     if ( active ) {
 550         gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(*dst), TRUE );
 551     }
 552     gtk_menu_shell_append( GTK_MENU_SHELL(menu), *dst );
 553     g_object_set_qdata( G_OBJECT(*dst), gDataName, act );
 554
 555     g_signal_connect( G_OBJECT(*dst), "toggled", toggleCb, GINT_TO_POINTER(val) );
 556
 557     g_free(str);
 558 }
 559
 560 static GList* flush_explicit_items( GList* descriptions,
 561                                     GCallback toggleCb,
 562                                     int val,
 563                                     GtkWidget* menu,
 564                                     EgeAdjustmentAction* act,
 565                                     GtkWidget** dst,
 566                                     GSList** group,
 567                                     gdouble num )
 568 {
 569     GList* cur = descriptions;
 570
 571     if ( cur ) {
 572         gdouble valUpper = num + act->private_data->epsilon;
 573         gdouble valLower = num - act->private_data->epsilon;
 574
 575         EgeAdjustmentDescr* descr = (EgeAdjustmentDescr*)cur->data;
 576
 577         while ( cur && descr && (descr->value >= valLower) ) {
 578             if ( descr->value > valUpper ) {
 579                 create_single_menu_item( toggleCb, val + g_list_position(act->private_data->descriptions, cur), menu, act, dst, group, descr->value, FALSE );
 580             }
 581
 582             cur = g_list_previous( cur );
 583             descr = cur ? (EgeAdjustmentDescr*)cur->data : 0;
 584         }
 585     }
 586
 587     return cur;
 588 }
 589
 590 static GtkWidget* create_popup_number_menu( EgeAdjustmentAction* act )
 591 {
 592     GtkWidget* menu = gtk_menu_new();
 593
 594     GSList* group = 0;
 595     GtkWidget* single = 0;
 596
 597     GList* addOns = g_list_last( act->private_data->descriptions );
 598
 599     gdouble base = gtk_adjustment_get_value( act->private_data->adj );
 600     gdouble lower = 0.0;
 601     gdouble upper = 0.0;
 602     gdouble step = 0.0;
 603     gdouble page = 0.0;
 604     g_object_get( G_OBJECT(act->private_data->adj),
 605                   "lower", &lower,
 606                   "upper", &upper,
 607                   "step-increment", &step,
 608                   "page-increment", &page,
 609                   NULL );
 610
 611
 612     if ( base < upper ) {
 613         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, upper );
 614         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_TOP, menu, act, &single, &group, upper, FALSE );
 615         if ( (base + page) < upper ) {
 616             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + page );
 617             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_UP, menu, act, &single, &group, base + page, FALSE );
 618         }
 619         if ( (base + step) < upper ) {
 620             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base + step );
 621             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_UP, menu, act, &single, &group, base + step, FALSE );
 622         }
 623     }
 624
 625     addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base );
 626     create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_NONE, menu, act, &single, &group, base, TRUE );
 627
 628     if ( base > lower ) {
 629         if ( (base - step) > lower ) {
 630             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - step );
 631             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_DOWN, menu, act, &single, &group, base - step, FALSE );
 632         }
 633         if ( (base - page) > lower ) {
 634             addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, base - page );
 635             create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_PAGE_DOWN, menu, act, &single, &group, base - page, FALSE );
 636         }
 637         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, lower );
 638         create_single_menu_item( G_CALLBACK(process_menu_action), BUMP_BOTTOM, menu, act, &single, &group, lower, FALSE );
 639     }
 640
 641     if ( act->private_data->descriptions ) {
 642         gdouble value = ((EgeAdjustmentDescr*)act->private_data->descriptions->data)->value;
 643         addOns = flush_explicit_items( addOns, G_CALLBACK(process_menu_action), BUMP_CUSTOM, menu, act, &single, &group, value );
 644     }
 645
 646     return menu;
 647 }
 648
 649 static GtkWidget* create_menu_item( GtkAction* action )
 650 {
 651     GtkWidget* item = 0;
 652
 653     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 654         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 655         GValue value;
 656         const gchar*  sss = 0;
 657         GtkWidget*  subby = 0;
 658
 659         memset( &value, 0, sizeof(value) );
 660         g_value_init( &value, G_TYPE_STRING );
 661         g_object_get_property( G_OBJECT(action), "label", &value );
 662
 663         sss = g_value_get_string( &value );
 664
 665         item = gtk_menu_item_new_with_label( sss );
 666
 667         subby = create_popup_number_menu( act );
 668         gtk_menu_item_set_submenu( GTK_MENU_ITEM(item), subby );
 669         gtk_widget_show_all( subby );
 670     } else {
 671         item = gParentClass->create_menu_item( action );
 672     }
 673
 674     return item;
 675 }
 676
 677 void value_changed_cb( GtkSpinButton* spin, EgeAdjustmentAction* act )
 678 {
 679     if ( GTK_WIDGET_HAS_FOCUS( GTK_WIDGET(spin) ) ) {
 680         ege_adjustment_action_defocus( act );
 681     }
 682 }
 683
 684 static gboolean event_cb( EgeAdjustmentAction* act, GdkEvent* evt )
 685 {
 686     gboolean handled = FALSE;
 687     if ( evt->type == GDK_BUTTON_PRESS ) {
 688         if ( evt->button.button == 3 ) {
 689             if ( IS_EGE_ADJUSTMENT_ACTION(act) ) {
 690                 GdkEventButton* btnevt = (GdkEventButton*)evt;
 691                 GtkWidget* menu = create_popup_number_menu(act);
 692                 gtk_widget_show_all( menu );
 693                 gtk_menu_popup( GTK_MENU(menu), NULL, NULL, NULL, NULL, btnevt->button, btnevt->time );
 694             }
 695             handled = TRUE;
 696         }
 697     }
 698
 699     return handled;
 700 }
 701
 702 static GtkWidget* create_tool_item( GtkAction* action )
 703 {
 704     GtkWidget* item = 0;
 705
 706     if ( IS_EGE_ADJUSTMENT_ACTION(action) ) {
 707         EgeAdjustmentAction* act = EGE_ADJUSTMENT_ACTION( action );
 708         GtkWidget* spinbutton = gtk_spin_button_new( act->private_data->adj, act->private_data->climbRate, act->private_data->digits );
 709         GtkWidget* hb = gtk_hbox_new( FALSE, 5 );
 710         GValue value;
 711
 712         item = GTK_WIDGET( gtk_tool_item_new() );
 713
 714         memset( &value, 0, sizeof(value) );
 715         g_value_init( &value, G_TYPE_STRING );
 716         g_object_get_property( G_OBJECT(action), "label", &value );
 717         const gchar* sss = g_value_get_string( &value );
 718         GtkWidget* lbl = gtk_label_new( sss ? sss : "wwww" );
 719         GtkWidget* filler1 = gtk_label_new(" ");
 720
 721         {
 722             GValue tooltip;
 723             memset( &tooltip, 0, sizeof(tooltip) );
 724             g_value_init( &tooltip, G_TYPE_STRING );
 725             g_object_get_property( G_OBJECT(action), "tooltip", &tooltip );
 726             const gchar* tipstr = g_value_get_string( &tooltip );
 727             if ( tipstr && *tipstr ) {
 728                 if ( !act->private_data->toolTips ) {
 729                     act->private_data->toolTips = gtk_tooltips_new();
 730                 }
 731                 gtk_tooltips_set_tip( act->private_data->toolTips, spinbutton, tipstr, 0 );
 732             }
 733         }
 734
 735         gtk_misc_set_alignment( GTK_MISC(lbl), 1.0, 0.5 );
 736
 737         gtk_box_pack_start( GTK_BOX(hb), filler1, FALSE, FALSE, 0 );
 738         gtk_box_pack_start( GTK_BOX(hb), lbl, FALSE, FALSE, 0 );
 739         gtk_box_pack_start( GTK_BOX(hb), spinbutton, FALSE, FALSE, 0 );
 740
 741         gtk_container_add( GTK_CONTAINER(item), hb );
 742
 743         if ( act->private_data->selfId ) {
 744             g_object_set_data( G_OBJECT(spinbutton), act->private_data->selfId, spinbutton );
 745         }
 746
 747         g_signal_connect( G_OBJECT(spinbutton), "focus-in-event", G_CALLBACK(focus_in_cb), action );
 748         g_signal_connect( G_OBJECT(spinbutton), "focus-out-event", G_CALLBACK(focus_out_cb), action );
 749         g_signal_connect( G_OBJECT(spinbutton), "key-press-event", G_CALLBACK(keypress_cb), action );
 750
 751         g_signal_connect( G_OBJECT(spinbutton), "value-changed", G_CALLBACK(value_changed_cb), action );
 752
 753         g_signal_connect_swapped( G_OBJECT(spinbutton), "event", G_CALLBACK(event_cb), action );
 754         gtk_entry_set_width_chars( GTK_ENTRY(spinbutton), act->private_data->digits + 3 );
 755
 756         gtk_widget_show_all( item );
 757
 758         /* Shrink or whatnot after shown */
 759         if ( act->private_data->toolPost ) {
 760             act->private_data->toolPost( item );
 761         }
 762     } else {
 763         item = gParentClass->create_tool_item( action );
 764     }
 765
 766     return item;
 767 }
 768
 769 static void connect_proxy( GtkAction *action, GtkWidget *proxy )
 770 {
 771     gParentClass->connect_proxy( action, proxy );
 772 }
 773
 774 static void disconnect_proxy( GtkAction *action, GtkWidget *proxy )
 775 {
 776     gParentClass->disconnect_proxy( action, proxy );
 777 }
 778
 779 void ege_adjustment_action_defocus( EgeAdjustmentAction* action )
 780 {
 781     if ( action->private_data->transferFocus ) {
 782         if ( action->private_data->focusWidget ) {
 783             gtk_widget_grab_focus( action->private_data->focusWidget );
 784         }
 785     }
 786 }
 787
 788 gboolean focus_in_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 789 {
 790     (void)event;
 791     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 792         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 793         action->private_data->lastVal = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 794         action->private_data->transferFocus = TRUE;
 795     }
 796
 797     return FALSE; /* report event not consumed */
 798 }
 799
 800 static gboolean focus_out_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 801 {
 802     (void)widget;
 803     (void)event;
 804     if ( IS_EGE_ADJUSTMENT_ACTION(data) ) {
 805         EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION( data );
 806         action->private_data->transferFocus = FALSE;
 807     }
 808
 809     return FALSE; /* report event not consumed */
 810 }
 811
 812
 813 static gboolean process_tab( GtkWidget* widget, int direction )
 814 {
 815     gboolean handled = FALSE;
 816     GtkWidget* parent = gtk_widget_get_parent(widget);
 817     GtkWidget* gp = parent ? gtk_widget_get_parent(parent) : 0;
 818     GtkWidget* ggp = gp ? gtk_widget_get_parent(gp) : 0;
 819
 820     if ( ggp && GTK_IS_TOOLBAR(ggp) ) {
 821         GList* kids = gtk_container_get_children( GTK_CONTAINER(ggp) );
 822         if ( kids ) {
 823             GtkWidget* curr = widget;
 824             while ( curr && (gtk_widget_get_parent(curr) != ggp) ) {
 825                 curr = gtk_widget_get_parent( curr );
 826             }
 827             if ( curr ) {
 828                 GList* mid = g_list_find( kids, curr );
 829                 while ( mid ) {
 830                     mid = ( direction < 0 ) ? g_list_previous(mid) : g_list_next(mid);
 831                     if ( mid && GTK_IS_TOOL_ITEM(mid->data) ) {
 832                         /* potential target */
 833                         GtkWidget* child = gtk_bin_get_child( GTK_BIN(mid->data) );
 834                         if ( child && GTK_IS_HBOX(child) ) { /* could be ours */
 835                             GList* subChildren = gtk_container_get_children( GTK_CONTAINER(child) );
 836                             if ( subChildren ) {
 837                                 GList* last = g_list_last(subChildren);
 838                                 if ( last && GTK_IS_SPIN_BUTTON(last->data) && GTK_WIDGET_IS_SENSITIVE( GTK_WIDGET(last->data) ) ) {
 839                                     gtk_widget_grab_focus( GTK_WIDGET(last->data) );
 840                                     handled = TRUE;
 841                                     mid = 0; /* to stop loop */
 842                                 }
 843
 844                                 g_list_free(subChildren);
 845                             }
 846                         }
 847                     }
 848                 }
 849             }
 850             g_list_free( kids );
 851         }
 852     }
 853
 854     return handled;
 855 }
 856
 857 gboolean keypress_cb( GtkWidget *widget, GdkEventKey *event, gpointer data )
 858 {
 859     gboolean wasConsumed = FALSE; /* default to report event not consumed */
 860     EgeAdjustmentAction* action = EGE_ADJUSTMENT_ACTION(data);
 861     guint key = 0;
 862     gdk_keymap_translate_keyboard_state( gdk_keymap_get_for_display( gdk_display_get_default() ),
 863                                          event->hardware_keycode, (GdkModifierType)event->state,
 864                                          0, &key, 0, 0, 0 );
 865
 866     switch ( key ) {
 867         case GDK_Escape:
 868         {
 869             action->private_data->transferFocus = TRUE;
 870             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
 871             ege_adjustment_action_defocus( action );
 872             wasConsumed = TRUE;
 873         }
 874         break;
 875
 876         case GDK_Return:
 877         case GDK_KP_Enter:
 878         {
 879             action->private_data->transferFocus = TRUE;
 880             ege_adjustment_action_defocus( action );
 881             wasConsumed = TRUE;
 882         }
 883         break;
 884
 885         case GDK_Tab:
 886         {
 887             action->private_data->transferFocus = FALSE;
 888             wasConsumed = process_tab( widget, 1 );
 889         }
 890         break;
 891
 892         case GDK_ISO_Left_Tab:
 893         {
 894             action->private_data->transferFocus = FALSE;
 895             wasConsumed = process_tab( widget, -1 );
 896         }
 897         break;
 898
 899         case GDK_Up:
 900         case GDK_KP_Up:
 901         {
 902             action->private_data->transferFocus = FALSE;
 903             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 904             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->step );
 905             wasConsumed = TRUE;
 906         }
 907         break;
 908
 909         case GDK_Down:
 910         case GDK_KP_Down:
 911         {
 912             action->private_data->transferFocus = FALSE;
 913             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 914             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->step );
 915             wasConsumed = TRUE;
 916         }
 917         break;
 918
 919         case GDK_Page_Up:
 920         case GDK_KP_Page_Up:
 921         {
 922             action->private_data->transferFocus = FALSE;
 923             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 924             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val + action->private_data->page );
 925             wasConsumed = TRUE;
 926         }
 927         break;
 928
 929         case GDK_Page_Down:
 930         case GDK_KP_Page_Down:
 931         {
 932             action->private_data->transferFocus = FALSE;
 933             gdouble val = gtk_spin_button_get_value( GTK_SPIN_BUTTON(widget) );
 934             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), val - action->private_data->page );
 935             wasConsumed = TRUE;
 936         }
 937         break;
 938
 939         case GDK_z:
 940         case GDK_Z:
 941         {
 942             action->private_data->transferFocus = FALSE;
 943             gtk_spin_button_set_value( GTK_SPIN_BUTTON(widget), action->private_data->lastVal );
 944             wasConsumed = TRUE;
 945         }
 946         break;
 947
 948     }
 949
 950     return wasConsumed;
 951 }