src/widgets/sp-color-notebook.cpp

   1 #define __SP_COLOR_NOTEBOOK_C__
   2
   3 /*
   4  * A notebook with RGB, CMYK, CMS, HSL, and Wheel pages
   5  *
   6  * Author:
   7  *   Lauris Kaplinski <lauris@kaplinski.com>
   8  *   bulia byak <buliabyak@users.sf.net>
   9  *
  10  * Copyright (C) 2001-2002 Lauris Kaplinski
  11  *
  12  * This code is in public domain
  13  */
  14
  15 #undef SPCS_PREVIEW
  16 #define noDUMP_CHANGE_INFO
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include "config.h"
  20 #endif
  21
  22 #include <cstring>
  23 #include <string>
  24 #include <cstdlib>
  25 #include <gtk/gtk.h>
  26 #include <glibmm/i18n.h>
  27
  28 #include "../dialogs/dialog-events.h"
  29 #include "../preferences.h"
  30 #include "sp-color-notebook.h"
  31 #include "spw-utilities.h"
  32 #include "sp-color-scales.h"
  33 #include "sp-color-icc-selector.h"
  34 #include "sp-color-wheel-selector.h"
  35 #include "svg/svg-icc-color.h"
  36 #include "../inkscape.h"
  37 #include "../document.h"
  38 #include "../profile-manager.h"
  39
  40 struct SPColorNotebookTracker {
  41     const gchar* name;
  42     const gchar* className;
  43     GType type;
  44     guint submode;
  45     gboolean enabledFull;
  46     gboolean enabledBrief;
  47     SPColorNotebook *backPointer;
  48 };
  49
  50 static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
  51 static void sp_color_notebook_init (SPColorNotebook *colorbook);
  52 static void sp_color_notebook_destroy (GtkObject *object);
  53
  54 static void sp_color_notebook_show_all (GtkWidget *widget);
  55 static void sp_color_notebook_hide_all (GtkWidget *widget);
  56
  57 static SPColorSelectorClass *parent_class;
  58
  59 #define XPAD 4
  60 #define YPAD 1
  61
  62 GType sp_color_notebook_get_type(void)
  63 {
  64     static GtkType type = 0;
  65     if (!type) {
  66         GTypeInfo info = {
  67             sizeof(SPColorNotebookClass),
  68             0, // base_init
  69             0, // base_finalize
  70             (GClassInitFunc)sp_color_notebook_class_init,
  71             0, // class_finalize
  72             0, // class_data
  73             sizeof(SPColorNotebook),
  74             0, // n_preallocs
  75             (GInstanceInitFunc)sp_color_notebook_init,
  76             0 // value_table
  77         };
  78         type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast<GTypeFlags>(0));
  79     }
  80     return type;
  81 }
  82
  83 static void
  84 sp_color_notebook_class_init (SPColorNotebookClass *klass)
  85 {
  86     GtkObjectClass *object_class;
  87     GtkWidgetClass *widget_class;
  88     SPColorSelectorClass *selector_class;
  89
  90     object_class = (GtkObjectClass *) klass;
  91     widget_class = (GtkWidgetClass *) klass;
  92     selector_class = SP_COLOR_SELECTOR_CLASS (klass);
  93
  94     parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
  95
  96     object_class->destroy = sp_color_notebook_destroy;
  97
  98     widget_class->show_all = sp_color_notebook_show_all;
  99     widget_class->hide_all = sp_color_notebook_hide_all;
 100 }
 101
 102 static void
 103 sp_color_notebook_switch_page(GtkNotebook *notebook,
 104                               GtkNotebookPage *page,
 105                               guint page_num,
 106                               SPColorNotebook *colorbook)
 107 {
 108     if ( colorbook )
 109     {
 110         ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 111         nb->switchPage( notebook, page, page_num );
 112
 113         // remember the page we seitched to
 114         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 115         prefs->setInt("/colorselector/page", page_num);
 116     }
 117 }
 118
 119 void ColorNotebook::switchPage(GtkNotebook*,
 120                               GtkNotebookPage*,
 121                               guint page_num)
 122 {
 123     SPColorSelector* csel;
 124     GtkWidget* widget;
 125
 126     if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
 127     {
 128         csel = getCurrentSelector();
 129         csel->base->getColorAlpha(_color, _alpha);
 130     }
 131     widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
 132     if ( widget && SP_IS_COLOR_SELECTOR (widget) )
 133     {
 134         csel = SP_COLOR_SELECTOR (widget);
 135         csel->base->setColorAlpha( _color, _alpha );
 136
 137         // Temporary workaround to undo a spurious GRABBED
 138         _released();
 139     }
 140 }
 141
 142 static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
 143 {
 144     if (event->type == GDK_BUTTON_PRESS)
 145     {
 146         SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
 147         ((ColorNotebook*)(csel->base))->menuHandler( event );
 148
 149         /* Tell calling code that we have handled this event; the buck
 150          * stops here. */
 151         return TRUE;
 152     }
 153
 154     /* Tell calling code that we have not handled this event; pass it on. */
 155     return FALSE;
 156 }
 157
 158 gint ColorNotebook::menuHandler( GdkEvent* event )
 159 {
 160     GdkEventButton *bevent = (GdkEventButton *) event;
 161     gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
 162                     bevent->button, bevent->time);
 163     return TRUE;
 164 }
 165
 166 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
 167 {
 168     gboolean active = FALSE;
 169
 170     active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
 171     SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
 172     if ( entry )
 173     {
 174         if ( active )
 175         {
 176             ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
 177         }
 178         else
 179         {
 180             ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
 181         }
 182     }
 183 }
 184
 185 static void
 186 sp_color_notebook_init (SPColorNotebook *colorbook)
 187 {
 188     SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
 189
 190     if ( SP_COLOR_SELECTOR(colorbook)->base )
 191     {
 192         SP_COLOR_SELECTOR(colorbook)->base->init();
 193     }
 194 }
 195
 196 void ColorNotebook::init()
 197 {
 198     GtkWidget* table = 0;
 199     guint row = 0;
 200     guint i = 0;
 201     guint j = 0;
 202     GType *selector_types = 0;
 203     guint selector_type_count = 0;
 204
 205     GtkTooltips *tt = gtk_tooltips_new ();
 206
 207     /* tempory hardcoding to get types loaded */
 208     SP_TYPE_COLOR_SCALES;
 209     SP_TYPE_COLOR_WHEEL_SELECTOR;
 210 #if ENABLE_LCMS
 211     SP_TYPE_COLOR_ICC_SELECTOR;
 212 #endif // ENABLE_LCMS
 213
 214     /* REJON: Comment out the next line to not use the normal GTK Color
 215            wheel. */
 216
 217 //        SP_TYPE_COLOR_GTKSELECTOR;
 218
 219     _updating = FALSE;
 220     _updatingrgba = FALSE;
 221     _btn = 0;
 222     _popup = 0;
 223     _trackerList = g_ptr_array_new ();
 224
 225     _book = gtk_notebook_new ();
 226     gtk_widget_show (_book);
 227
 228     selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
 229
 230     for ( i = 0; i < selector_type_count; i++ )
 231     {
 232         if (!g_type_is_a (selector_types[i], SP_TYPE_COLOR_NOTEBOOK))
 233         {
 234             guint howmany = 1;
 235             gpointer klass = gtk_type_class (selector_types[i]);
 236             if ( klass && SP_IS_COLOR_SELECTOR_CLASS (klass) )
 237             {
 238                 SPColorSelectorClass *ck = SP_COLOR_SELECTOR_CLASS (klass);
 239                 howmany = MAX (1, ck->submode_count);
 240                 for ( j = 0; j < howmany; j++ )
 241                 {
 242                     SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (malloc(sizeof(SPColorNotebookTracker)));
 243                     if ( entry )
 244                     {
 245                         memset( entry, 0, sizeof(SPColorNotebookTracker) );
 246                         entry->name = ck->name[j];
 247                         entry->type = selector_types[i];
 248                         entry->submode = j;
 249                         entry->enabledFull = TRUE;
 250                         entry->enabledBrief = TRUE;
 251                         entry->backPointer = SP_COLOR_NOTEBOOK(_csel);
 252
 253                         g_ptr_array_add (_trackerList, entry);
 254                     }
 255                 }
 256             }
 257         }
 258     }
 259
 260     for ( i = 0; i < _trackerList->len; i++ )
 261     {
 262         SPColorNotebookTracker *entry =
 263             reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
 264         if ( entry )
 265         {
 266             addPage(entry->type, entry->submode);
 267         }
 268     }
 269
 270     table = gtk_table_new (2, 3, FALSE);
 271     gtk_widget_show (table);
 272
 273     gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
 274
 275     gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
 276                       static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
 277                       static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
 278                       XPAD, YPAD);
 279
 280     // restore the last active page
 281     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 282     gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
 283
 284     {
 285         gboolean found = FALSE;
 286
 287         _popup = gtk_menu_new();
 288         GtkMenu *menu = GTK_MENU (_popup);
 289
 290         for ( i = 0; i < _trackerList->len; i++ )
 291         {
 292             SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
 293             if ( entry )
 294             {
 295                 GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
 296                 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
 297                 gtk_widget_show (item);
 298                 gtk_menu_append (menu, item);
 299
 300                 g_signal_connect (G_OBJECT (item), "activate",
 301                                   G_CALLBACK (sp_color_notebook_menuitem_response),
 302                                   reinterpret_cast< gpointer > (entry) );
 303                 found = TRUE;
 304             }
 305         }
 306
 307         GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
 308         gtk_widget_show (arrow);
 309
 310         _btn = gtk_button_new ();
 311         gtk_widget_show (_btn);
 312         gtk_container_add (GTK_CONTAINER (_btn), arrow);
 313
 314         GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
 315         gtk_widget_show (align);
 316         gtk_container_add (GTK_CONTAINER (align), _btn);
 317
 318         // uncomment to reenable the "show/hide modes" menu,
 319         // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
 320         //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 321
 322         gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
 323         if ( !found )
 324         {
 325             gtk_widget_set_sensitive (_btn, FALSE);
 326         }
 327     }
 328
 329     row++;
 330
 331     GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
 332
 333 #if ENABLE_LCMS
 334     /* Create color management icons */
 335     _box_colormanaged = gtk_event_box_new ();
 336     GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 337     gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
 338     GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
 339     gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
 340     gtk_widget_set_sensitive (_box_colormanaged, false);
 341     gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, FALSE, FALSE, 2);
 342
 343     _box_outofgamut = gtk_event_box_new ();
 344     GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 345     gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
 346     GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
 347     gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
 348     gtk_widget_set_sensitive (_box_outofgamut, false);
 349     gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, FALSE, FALSE, 2);
 350
 351     _box_toomuchink = gtk_event_box_new ();
 352     GtkWidget *toomuchink = gtk_image_new_from_icon_name ("too-much-ink-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
 353     gtk_container_add (GTK_CONTAINER (_box_toomuchink), toomuchink);
 354     GtkTooltips *tooltips_toomuchink = gtk_tooltips_new ();
 355     gtk_tooltips_set_tip (tooltips_toomuchink, _box_toomuchink, _("Too much ink!"), "");
 356     gtk_widget_set_sensitive (_box_toomuchink, false);
 357     gtk_box_pack_start(GTK_BOX(rgbabox), _box_toomuchink, FALSE, FALSE, 2);
 358
 359 #endif //ENABLE_LCMS
 360
 361     /* Create RGBA entry and color preview */
 362     _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
 363     gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
 364     gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
 365
 366     _rgbae = gtk_entry_new ();
 367     sp_dialog_defocus_on_enter (_rgbae);
 368     gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
 369     gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
 370     gtk_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
 371     gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
 372     gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
 373
 374     sp_set_font_size_smaller (rgbabox);
 375     gtk_widget_show_all (rgbabox);
 376
 377 #if ENABLE_LCMS
 378     //the "too much ink" icon is initially hidden
 379     gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
 380 #endif //ENABLE_LCMS
 381
 382     gtk_table_attach (GTK_TABLE (table), rgbabox, 0, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
 383
 384 #ifdef SPCS_PREVIEW
 385     _p = sp_color_preview_new (0xffffffff);
 386     gtk_widget_show (_p);
 387     gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
 388 #endif
 389
 390     _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
 391                                  GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
 392
 393     _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
 394 }
 395
 396 static void
 397 sp_color_notebook_destroy (GtkObject *object)
 398 {
 399     if (((GtkObjectClass *) (parent_class))->destroy)
 400         (* ((GtkObjectClass *) (parent_class))->destroy) (object);
 401 }
 402
 403 ColorNotebook::~ColorNotebook()
 404 {
 405     if ( _trackerList )
 406     {
 407         g_ptr_array_free (_trackerList, TRUE);
 408         _trackerList = 0;
 409     }
 410
 411     if ( _switchId )
 412     {
 413         if ( _book )
 414         {
 415             g_signal_handler_disconnect (_book, _switchId);
 416             _switchId = 0;
 417         }
 418     }
 419 }
 420
 421 static void
 422 sp_color_notebook_show_all (GtkWidget *widget)
 423 {
 424     gtk_widget_show (widget);
 425 }
 426
 427 static void
 428 sp_color_notebook_hide_all (GtkWidget *widget)
 429 {
 430     gtk_widget_hide (widget);
 431 }
 432
 433 GtkWidget *
 434 sp_color_notebook_new (void)
 435 {
 436     SPColorNotebook *colorbook;
 437
 438     colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
 439
 440     return GTK_WIDGET (colorbook);
 441 }
 442
 443 ColorNotebook::ColorNotebook( SPColorSelector* csel )
 444     : ColorSelector( csel )
 445 {
 446 }
 447
 448 SPColorSelector* ColorNotebook::getCurrentSelector()
 449 {
 450     SPColorSelector* csel = NULL;
 451     gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
 452
 453     if ( current_page >= 0 )
 454     {
 455         GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
 456         if ( SP_IS_COLOR_SELECTOR (widget) )
 457         {
 458             csel = SP_COLOR_SELECTOR (widget);
 459         }
 460     }
 461
 462     return csel;
 463 }
 464
 465 void ColorNotebook::_colorChanged()
 466 {
 467     SPColorSelector* cselPage = getCurrentSelector();
 468     if ( cselPage )
 469     {
 470         cselPage->base->setColorAlpha( _color, _alpha );
 471     }
 472
 473     _updateRgbaEntry( _color, _alpha );
 474 }
 475
 476 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
 477 {
 478     ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
 479 }
 480
 481 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
 482 {
 483     if (_updating) return;
 484     if (_updatingrgba) return;
 485
 486     const gchar *t = gtk_entry_get_text( entry );
 487
 488     if (t) {
 489         Glib::ustring text = t;
 490         bool changed = false;
 491         if (!text.empty() && text[0] == '#') {
 492             changed = true;
 493             text.erase(0,1);
 494             if (text.size() == 6) {
 495                 // it was a standard RGB hex
 496                 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
 497                 gchar* tmp = g_strdup_printf("%02x", alph);
 498                 text += tmp;
 499                 g_free(tmp);
 500             }
 501         }
 502         gchar* str = g_strdup(text.c_str());
 503         gchar* end = 0;
 504         guint64 rgba = g_ascii_strtoull( str, &end, 16 );
 505         if ( end != str ) {
 506             ptrdiff_t len = end - str;
 507             if ( len < 8 ) {
 508                 rgba = rgba << ( 4 * ( 8 - len ) );
 509             }
 510             _updatingrgba = TRUE;
 511             if ( changed ) {
 512                 gtk_entry_set_text( entry, str );
 513             }
 514             SPColor color( rgba );
 515             setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
 516             _updatingrgba = FALSE;
 517         }
 518         g_free(str);
 519     }
 520 }
 521
 522 // TODO pass in param so as to avoid the need for SP_ACTIVE_DOCUMENT
 523 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
 524 {
 525     g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
 526
 527 #if ENABLE_LCMS
 528     /* update color management icon*/
 529     gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
 530
 531     /* update out-of-gamut icon */
 532     gtk_widget_set_sensitive (_box_outofgamut, false);
 533     if (color.icc){
 534         Inkscape::ColorProfile* target_profile = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
 535         if ( target_profile )
 536             gtk_widget_set_sensitive (_box_outofgamut, target_profile->GamutCheck(color));
 537     }
 538
 539     /* update too-much-ink icon */
 540     gtk_widget_set_sensitive (_box_toomuchink, false);
 541     if (color.icc){
 542         Inkscape::ColorProfile* prof = SP_ACTIVE_DOCUMENT->profileManager->find(color.icc->colorProfile.c_str());
 543         if ( prof && ( (prof->getColorSpace() == icSigCmykData) || (prof->getColorSpace() == icSigCmyData) ) ) {
 544             gtk_widget_show(GTK_WIDGET(_box_toomuchink));
 545             double ink_sum = 0;
 546             for (unsigned int i=0; i<color.icc->colors.size(); i++){
 547                 ink_sum += color.icc->colors[i];
 548             }
 549
 550             /* Some literature states that when the sum of paint values exceed 320%, it is considered to be a satured color,
 551                 which means the paper can get too wet due to an excessive ammount of ink. This may lead to several issues
 552                 such as misalignment and poor quality of printing in general.*/
 553             if ( ink_sum > 3.2 )
 554                 gtk_widget_set_sensitive (_box_toomuchink, true);
 555         } else {
 556             gtk_widget_hide(GTK_WIDGET(_box_toomuchink));
 557         }
 558     }
 559 #endif //ENABLE_LCMS
 560
 561     if ( !_updatingrgba )
 562     {
 563         gchar s[32];
 564         guint32 rgba;
 565
 566         /* Update RGBA entry */
 567         rgba = color.toRGBA32( alpha );
 568
 569         g_snprintf (s, 32, "%08x", rgba);
 570         const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
 571         if ( strcmp( oldText, s ) != 0 )
 572         {
 573             g_signal_handler_block( _rgbae, _entryId );
 574             gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
 575             g_signal_handler_unblock( _rgbae, _entryId );
 576         }
 577     }
 578 }
 579
 580 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
 581 {
 582     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 583     nb->_grabbed();
 584 }
 585
 586 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
 587 {
 588     gboolean oldState;
 589     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 590
 591     oldState = nb->_dragging;
 592
 593     nb->_dragging = TRUE;
 594     nb->_entryModified( csel, colorbook );
 595
 596     nb->_dragging = oldState;
 597 }
 598
 599 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
 600 {
 601     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 602     nb->_released();
 603 }
 604
 605 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
 606 {
 607     gboolean oldState;
 608     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 609
 610     oldState = nb->_dragging;
 611
 612     nb->_dragging = FALSE;
 613     nb->_entryModified( csel, colorbook );
 614
 615     nb->_dragging = oldState;
 616 }
 617
 618 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
 619 {
 620     g_return_if_fail (colorbook != NULL);
 621     g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
 622     g_return_if_fail (csel != NULL);
 623     g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
 624
 625     ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
 626     SPColor color;
 627     gfloat alpha = 1.0;
 628
 629     csel->base->getColorAlpha( color, alpha );
 630     nb->_updateRgbaEntry( color, alpha );
 631     nb->_updateInternals( color, alpha, nb->_dragging );
 632 }
 633
 634 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
 635 {
 636     GtkWidget *page;
 637
 638     page = sp_color_selector_new( page_type );
 639     if ( page )
 640     {
 641         GtkWidget* tab_label = 0;
 642         SPColorSelector* csel;
 643
 644         csel = SP_COLOR_SELECTOR (page);
 645         if ( submode > 0 )
 646         {
 647             csel->base->setSubmode( submode );
 648         }
 649         gtk_widget_show (page);
 650         int index = csel->base ? csel->base->getSubmode() : 0;
 651         const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
 652 //         g_message( "Hitting up for tab for '%s'", str );
 653         tab_label = gtk_label_new(_(str));
 654         gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
 655         gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
 656         gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
 657         gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
 658         gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
 659     }
 660
 661     return page;
 662 }
 663
 664 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
 665 {
 666     gint count = 0;
 667     gint i = 0;
 668     GtkWidget* page = 0;
 669
 670 //     count = gtk_notebook_get_n_pages (_book);
 671     count = 200;
 672     for ( i = 0; i < count && !page; i++ )
 673     {
 674         page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
 675         if ( page )
 676         {
 677             SPColorSelector* csel;
 678             guint pagemode;
 679             csel = SP_COLOR_SELECTOR (page);
 680             pagemode = csel->base->getSubmode();
 681             if ( G_TYPE_FROM_INSTANCE (page) == page_type
 682                  && pagemode == submode )
 683             {
 684                 // found it.
 685                 break;
 686             }
 687             else
 688             {
 689                 page = 0;
 690             }
 691         }
 692         else
 693         {
 694             break;
 695         }
 696     }
 697     return page;
 698 }
 699
 700 void ColorNotebook::removePage( GType page_type, guint submode )
 701 {
 702     GtkWidget *page = 0;
 703
 704     page = getPage(page_type, submode);
 705     if ( page )
 706     {
 707         gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
 708         if ( where >= 0 )
 709         {
 710             if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
 711             {
 712 //                 getColorAlpha(_color, &_alpha);
 713             }
 714             gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
 715         }
 716     }
 717 }
 718
 719 /*
 720   Local Variables:
 721   mode:c++
 722   c-file-style:"stroustrup"
 723   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 724   indent-tabs-mode:nil
 725   fill-column:99
 726   End:
 727 */
 728 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :