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