1 #define __SP_COLOR_NOTEBOOK_C__
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 */
15 #undef SPCS_PREVIEW
16 #define noDUMP_CHANGE_INFO
18 #ifdef HAVE_CONFIG_H
19 # include "config.h"
20 #endif
22 #include <cstring>
23 #include <string>
24 #include <cstdlib>
25 #include <gtk/gtk.h>
26 #include <glibmm/i18n.h>
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"
36 struct SPColorNotebookTracker {
37 const gchar* name;
38 const gchar* className;
39 GType type;
40 guint submode;
41 gboolean enabledFull;
42 gboolean enabledBrief;
43 SPColorNotebook *backPointer;
44 };
46 static void sp_color_notebook_class_init (SPColorNotebookClass *klass);
47 static void sp_color_notebook_init (SPColorNotebook *colorbook);
48 static void sp_color_notebook_destroy (GtkObject *object);
50 static void sp_color_notebook_show_all (GtkWidget *widget);
51 static void sp_color_notebook_hide_all (GtkWidget *widget);
53 static SPColorSelectorClass *parent_class;
55 #define XPAD 4
56 #define YPAD 1
58 GType sp_color_notebook_get_type(void)
59 {
60 static GtkType type = 0;
61 if (!type) {
62 GTypeInfo info = {
63 sizeof(SPColorNotebookClass),
64 0, // base_init
65 0, // base_finalize
66 (GClassInitFunc)sp_color_notebook_class_init,
67 0, // class_finalize
68 0, // class_data
69 sizeof(SPColorNotebook),
70 0, // n_preallocs
71 (GInstanceInitFunc)sp_color_notebook_init,
72 0 // value_table
73 };
74 type = g_type_register_static(SP_TYPE_COLOR_SELECTOR, "SPColorNotebook", &info, static_cast<GTypeFlags>(0));
75 }
76 return type;
77 }
79 static void
80 sp_color_notebook_class_init (SPColorNotebookClass *klass)
81 {
82 GtkObjectClass *object_class;
83 GtkWidgetClass *widget_class;
84 SPColorSelectorClass *selector_class;
86 object_class = (GtkObjectClass *) klass;
87 widget_class = (GtkWidgetClass *) klass;
88 selector_class = SP_COLOR_SELECTOR_CLASS (klass);
90 parent_class = SP_COLOR_SELECTOR_CLASS (g_type_class_peek_parent (klass));
92 object_class->destroy = sp_color_notebook_destroy;
94 widget_class->show_all = sp_color_notebook_show_all;
95 widget_class->hide_all = sp_color_notebook_hide_all;
96 }
98 static void
99 sp_color_notebook_switch_page(GtkNotebook *notebook,
100 GtkNotebookPage *page,
101 guint page_num,
102 SPColorNotebook *colorbook)
103 {
104 if ( colorbook )
105 {
106 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
107 nb->switchPage( notebook, page, page_num );
109 // remember the page we seitched to
110 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
111 prefs->setInt("/colorselector/page", page_num);
112 }
113 }
115 void ColorNotebook::switchPage(GtkNotebook*,
116 GtkNotebookPage*,
117 guint page_num)
118 {
119 SPColorSelector* csel;
120 GtkWidget* widget;
122 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) >= 0 )
123 {
124 csel = getCurrentSelector();
125 csel->base->getColorAlpha(_color, &_alpha);
126 }
127 widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), page_num);
128 if ( widget && SP_IS_COLOR_SELECTOR (widget) )
129 {
130 csel = SP_COLOR_SELECTOR (widget);
131 csel->base->setColorAlpha( _color, _alpha );
133 // Temporary workaround to undo a spurious GRABBED
134 _released();
135 }
136 }
138 static gint sp_color_notebook_menu_handler( GtkWidget *widget, GdkEvent *event )
139 {
140 if (event->type == GDK_BUTTON_PRESS)
141 {
142 SPColorSelector* csel = SP_COLOR_SELECTOR(widget);
143 ((ColorNotebook*)(csel->base))->menuHandler( event );
145 /* Tell calling code that we have handled this event; the buck
146 * stops here. */
147 return TRUE;
148 }
150 /* Tell calling code that we have not handled this event; pass it on. */
151 return FALSE;
152 }
154 gint ColorNotebook::menuHandler( GdkEvent* event )
155 {
156 GdkEventButton *bevent = (GdkEventButton *) event;
157 gtk_menu_popup (GTK_MENU( _popup ), NULL, NULL, NULL, NULL,
158 bevent->button, bevent->time);
159 return TRUE;
160 }
162 static void sp_color_notebook_menuitem_response (GtkMenuItem *menuitem, gpointer user_data)
163 {
164 gboolean active = FALSE;
166 active = gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menuitem));
167 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (user_data);
168 if ( entry )
169 {
170 if ( active )
171 {
172 ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->addPage(entry->type, entry->submode);
173 }
174 else
175 {
176 ((ColorNotebook*)(SP_COLOR_SELECTOR(entry->backPointer)->base))->removePage(entry->type, entry->submode);
177 }
178 }
179 }
181 static void
182 sp_color_notebook_init (SPColorNotebook *colorbook)
183 {
184 SP_COLOR_SELECTOR(colorbook)->base = new ColorNotebook( SP_COLOR_SELECTOR(colorbook) );
186 if ( SP_COLOR_SELECTOR(colorbook)->base )
187 {
188 SP_COLOR_SELECTOR(colorbook)->base->init();
189 }
190 }
192 void ColorNotebook::init()
193 {
194 GtkWidget* table = 0;
195 guint row = 0;
196 guint i = 0;
197 guint j = 0;
198 GType *selector_types = 0;
199 guint selector_type_count = 0;
201 GtkTooltips *tt = gtk_tooltips_new ();
203 /* tempory hardcoding to get types loaded */
204 SP_TYPE_COLOR_SCALES;
205 SP_TYPE_COLOR_WHEEL_SELECTOR;
206 #if ENABLE_LCMS
207 SP_TYPE_COLOR_ICC_SELECTOR;
208 #endif // ENABLE_LCMS
210 /* REJON: Comment out the next line to not use the normal GTK Color
211 wheel. */
213 // SP_TYPE_COLOR_GTKSELECTOR;
215 _updating = FALSE;
216 _updatingrgba = FALSE;
217 _btn = 0;
218 _popup = 0;
219 _trackerList = g_ptr_array_new ();
221 _book = gtk_notebook_new ();
222 gtk_widget_show (_book);
224 selector_types = g_type_children (SP_TYPE_COLOR_SELECTOR, &selector_type_count);
226 for ( i = 0; i < selector_type_count; i++ )
227 {
228 if (!g_type_is_a (selector_types[i], SP_TYPE_COLOR_NOTEBOOK))
229 {
230 guint howmany = 1;
231 gpointer klass = gtk_type_class (selector_types[i]);
232 if ( klass && SP_IS_COLOR_SELECTOR_CLASS (klass) )
233 {
234 SPColorSelectorClass *ck = SP_COLOR_SELECTOR_CLASS (klass);
235 howmany = MAX (1, ck->submode_count);
236 for ( j = 0; j < howmany; j++ )
237 {
238 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (malloc(sizeof(SPColorNotebookTracker)));
239 if ( entry )
240 {
241 memset( entry, 0, sizeof(SPColorNotebookTracker) );
242 entry->name = ck->name[j];
243 entry->type = selector_types[i];
244 entry->submode = j;
245 entry->enabledFull = TRUE;
246 entry->enabledBrief = TRUE;
247 entry->backPointer = SP_COLOR_NOTEBOOK(_csel);
249 g_ptr_array_add (_trackerList, entry);
250 }
251 }
252 }
253 }
254 }
256 for ( i = 0; i < _trackerList->len; i++ )
257 {
258 SPColorNotebookTracker *entry =
259 reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
260 if ( entry )
261 {
262 addPage(entry->type, entry->submode);
263 }
264 }
266 table = gtk_table_new (2, 3, FALSE);
267 gtk_widget_show (table);
269 gtk_box_pack_start (GTK_BOX (_csel), table, TRUE, TRUE, 0);
271 gtk_table_attach (GTK_TABLE (table), _book, 0, 2, row, row + 1,
272 static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
273 static_cast<GtkAttachOptions>(GTK_EXPAND|GTK_FILL),
274 XPAD, YPAD);
276 // restore the last active page
277 Inkscape::Preferences *prefs = Inkscape::Preferences::get();
278 gtk_notebook_set_current_page (GTK_NOTEBOOK (_book), prefs->getInt("/colorselector/page", 0));
280 {
281 gboolean found = FALSE;
283 _popup = gtk_menu_new();
284 GtkMenu *menu = GTK_MENU (_popup);
286 for ( i = 0; i < _trackerList->len; i++ )
287 {
288 SPColorNotebookTracker *entry = reinterpret_cast< SPColorNotebookTracker* > (g_ptr_array_index (_trackerList, i));
289 if ( entry )
290 {
291 GtkWidget *item = gtk_check_menu_item_new_with_label (_(entry->name));
292 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), entry->enabledFull);
293 gtk_widget_show (item);
294 gtk_menu_append (menu, item);
296 g_signal_connect (G_OBJECT (item), "activate",
297 G_CALLBACK (sp_color_notebook_menuitem_response),
298 reinterpret_cast< gpointer > (entry) );
299 found = TRUE;
300 }
301 }
303 GtkWidget *arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
304 gtk_widget_show (arrow);
306 _btn = gtk_button_new ();
307 gtk_widget_show (_btn);
308 gtk_container_add (GTK_CONTAINER (_btn), arrow);
310 GtkWidget *align = gtk_alignment_new (1.0, 0.0, 0.0, 0.0);
311 gtk_widget_show (align);
312 gtk_container_add (GTK_CONTAINER (align), _btn);
314 // uncomment to reenable the "show/hide modes" menu,
315 // but first fix it so it remembers its settings in prefs and does not take that much space (entire vertical column!)
316 //gtk_table_attach (GTK_TABLE (table), align, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
318 gtk_signal_connect_object(GTK_OBJECT(_btn), "event", GTK_SIGNAL_FUNC (sp_color_notebook_menu_handler), GTK_OBJECT(_csel));
319 if ( !found )
320 {
321 gtk_widget_set_sensitive (_btn, FALSE);
322 }
323 }
325 row++;
327 GtkWidget *rgbabox = gtk_hbox_new (FALSE, 0);
328 /* Create color management icons */
329 _box_colormanaged = gtk_event_box_new ();
330 GtkWidget *colormanaged = gtk_image_new_from_icon_name ("color-management-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
331 gtk_container_add (GTK_CONTAINER (_box_colormanaged), colormanaged);
332 GtkTooltips *tooltips_colormanaged = gtk_tooltips_new ();
333 gtk_tooltips_set_tip (tooltips_colormanaged, _box_colormanaged, _("Color Managed"), "");
334 gtk_widget_set_sensitive (_box_colormanaged, false);
335 gtk_box_pack_start(GTK_BOX(rgbabox), _box_colormanaged, TRUE, FALSE, 2);
337 _box_outofgamut = gtk_event_box_new ();
338 GtkWidget *outofgamut = gtk_image_new_from_icon_name ("out-of-gamut-icon", GTK_ICON_SIZE_SMALL_TOOLBAR);
339 gtk_container_add (GTK_CONTAINER (_box_outofgamut), outofgamut);
340 GtkTooltips *tooltips_outofgamut = gtk_tooltips_new ();
341 gtk_tooltips_set_tip (tooltips_outofgamut, _box_outofgamut, _("Out of gamut!"), "");
342 gtk_widget_set_sensitive (_box_outofgamut, false);
343 gtk_box_pack_start(GTK_BOX(rgbabox), _box_outofgamut, TRUE, FALSE, 2);
345 /* Create RGBA entry and color preview */
346 _rgbal = gtk_label_new_with_mnemonic (_("RGBA_:"));
347 gtk_misc_set_alignment (GTK_MISC (_rgbal), 1.0, 0.5);
348 gtk_box_pack_start(GTK_BOX(rgbabox), _rgbal, TRUE, TRUE, 2);
350 _rgbae = gtk_entry_new ();
351 sp_dialog_defocus_on_enter (_rgbae);
352 gtk_entry_set_max_length (GTK_ENTRY (_rgbae), 8);
353 gtk_entry_set_width_chars (GTK_ENTRY (_rgbae), 8);
354 gtk_tooltips_set_tip (tt, _rgbae, _("Hexadecimal RGBA value of the color"), NULL);
355 gtk_box_pack_start(GTK_BOX(rgbabox), _rgbae, FALSE, FALSE, 0);
356 gtk_label_set_mnemonic_widget (GTK_LABEL(_rgbal), _rgbae);
358 sp_set_font_size_smaller (rgbabox);
359 gtk_widget_show_all (rgbabox);
360 gtk_table_attach (GTK_TABLE (table), rgbabox, 1, 2, row, row + 1, GTK_FILL, GTK_SHRINK, XPAD, YPAD);
362 #ifdef SPCS_PREVIEW
363 _p = sp_color_preview_new (0xffffffff);
364 gtk_widget_show (_p);
365 gtk_table_attach (GTK_TABLE (table), _p, 2, 3, row, row + 1, GTK_FILL, GTK_FILL, XPAD, YPAD);
366 #endif
368 _switchId = g_signal_connect(GTK_OBJECT (_book), "switch-page",
369 GTK_SIGNAL_FUNC (sp_color_notebook_switch_page), SP_COLOR_NOTEBOOK(_csel));
371 _entryId = gtk_signal_connect (GTK_OBJECT (_rgbae), "changed", GTK_SIGNAL_FUNC (ColorNotebook::_rgbaEntryChangedHook), _csel);
372 }
374 static void
375 sp_color_notebook_destroy (GtkObject *object)
376 {
377 if (((GtkObjectClass *) (parent_class))->destroy)
378 (* ((GtkObjectClass *) (parent_class))->destroy) (object);
379 }
381 ColorNotebook::~ColorNotebook()
382 {
383 if ( _trackerList )
384 {
385 g_ptr_array_free (_trackerList, TRUE);
386 _trackerList = 0;
387 }
389 if ( _switchId )
390 {
391 if ( _book )
392 {
393 g_signal_handler_disconnect (_book, _switchId);
394 _switchId = 0;
395 }
396 }
397 }
399 static void
400 sp_color_notebook_show_all (GtkWidget *widget)
401 {
402 gtk_widget_show (widget);
403 }
405 static void
406 sp_color_notebook_hide_all (GtkWidget *widget)
407 {
408 gtk_widget_hide (widget);
409 }
411 GtkWidget *
412 sp_color_notebook_new (void)
413 {
414 SPColorNotebook *colorbook;
416 colorbook = (SPColorNotebook*)gtk_type_new (SP_TYPE_COLOR_NOTEBOOK);
418 return GTK_WIDGET (colorbook);
419 }
421 ColorNotebook::ColorNotebook( SPColorSelector* csel )
422 : ColorSelector( csel )
423 {
424 }
426 SPColorSelector* ColorNotebook::getCurrentSelector()
427 {
428 SPColorSelector* csel = NULL;
429 gint current_page = gtk_notebook_get_current_page (GTK_NOTEBOOK (_book));
431 if ( current_page >= 0 )
432 {
433 GtkWidget* widget = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), current_page);
434 if ( SP_IS_COLOR_SELECTOR (widget) )
435 {
436 csel = SP_COLOR_SELECTOR (widget);
437 }
438 }
440 return csel;
441 }
443 void ColorNotebook::_colorChanged()
444 {
445 SPColorSelector* cselPage = getCurrentSelector();
446 if ( cselPage )
447 {
448 cselPage->base->setColorAlpha( _color, _alpha );
449 }
451 _updateRgbaEntry( _color, _alpha );
452 }
454 void ColorNotebook::_rgbaEntryChangedHook(GtkEntry *entry, SPColorNotebook *colorbook)
455 {
456 ((ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base))->_rgbaEntryChanged( entry );
457 }
459 void ColorNotebook::_rgbaEntryChanged(GtkEntry* entry)
460 {
461 if (_updating) return;
462 if (_updatingrgba) return;
464 const gchar *t = gtk_entry_get_text( entry );
466 if (t) {
467 Glib::ustring text = t;
468 bool changed = false;
469 if (!text.empty() && text[0] == '#') {
470 changed = true;
471 text.erase(0,1);
472 if (text.size() == 6) {
473 // it was a standard RGB hex
474 unsigned int alph = SP_COLOR_F_TO_U(_alpha);
475 gchar* tmp = g_strdup_printf("%02x", alph);
476 text += tmp;
477 g_free(tmp);
478 }
479 }
480 gchar* str = g_strdup(text.c_str());
481 gchar* end = 0;
482 guint64 rgba = g_ascii_strtoull( str, &end, 16 );
483 if ( end != str ) {
484 ptrdiff_t len = end - str;
485 if ( len < 8 ) {
486 rgba = rgba << ( 4 * ( 8 - len ) );
487 }
488 _updatingrgba = TRUE;
489 if ( changed ) {
490 gtk_entry_set_text( entry, str );
491 }
492 SPColor color( rgba );
493 setColorAlpha( color, SP_RGBA32_A_F(rgba), true );
494 _updatingrgba = FALSE;
495 }
496 g_free(str);
497 }
498 }
500 void ColorNotebook::_updateRgbaEntry( const SPColor& color, gfloat alpha )
501 {
502 g_return_if_fail( ( 0.0 <= alpha ) && ( alpha <= 1.0 ) );
504 /* update color management icon*/
505 gtk_widget_set_sensitive (_box_colormanaged, color.icc != NULL);
507 if ( !_updatingrgba )
508 {
509 gchar s[32];
510 guint32 rgba;
512 /* Update RGBA entry */
513 rgba = color.toRGBA32( alpha );
515 g_snprintf (s, 32, "%08x", rgba);
516 const gchar* oldText = gtk_entry_get_text( GTK_ENTRY( _rgbae ) );
517 if ( strcmp( oldText, s ) != 0 )
518 {
519 g_signal_handler_block( _rgbae, _entryId );
520 gtk_entry_set_text( GTK_ENTRY(_rgbae), s );
521 g_signal_handler_unblock( _rgbae, _entryId );
522 }
523 }
524 }
526 void ColorNotebook::_entryGrabbed (SPColorSelector *, SPColorNotebook *colorbook)
527 {
528 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
529 nb->_grabbed();
530 }
532 void ColorNotebook::_entryDragged (SPColorSelector *csel, SPColorNotebook *colorbook)
533 {
534 gboolean oldState;
535 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
537 oldState = nb->_dragging;
539 nb->_dragging = TRUE;
540 nb->_entryModified( csel, colorbook );
542 nb->_dragging = oldState;
543 }
545 void ColorNotebook::_entryReleased (SPColorSelector *, SPColorNotebook *colorbook)
546 {
547 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
548 nb->_released();
549 }
551 void ColorNotebook::_entryChanged (SPColorSelector *csel, SPColorNotebook *colorbook)
552 {
553 gboolean oldState;
554 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
556 oldState = nb->_dragging;
558 nb->_dragging = FALSE;
559 nb->_entryModified( csel, colorbook );
561 nb->_dragging = oldState;
562 }
564 void ColorNotebook::_entryModified (SPColorSelector *csel, SPColorNotebook *colorbook)
565 {
566 g_return_if_fail (colorbook != NULL);
567 g_return_if_fail (SP_IS_COLOR_NOTEBOOK (colorbook));
568 g_return_if_fail (csel != NULL);
569 g_return_if_fail (SP_IS_COLOR_SELECTOR (csel));
571 ColorNotebook* nb = (ColorNotebook*)(SP_COLOR_SELECTOR(colorbook)->base);
572 SPColor color;
573 gfloat alpha = 1.0;
575 csel->base->getColorAlpha( color, &alpha );
576 nb->_updateRgbaEntry( color, alpha );
577 nb->_updateInternals( color, alpha, nb->_dragging );
578 }
580 GtkWidget* ColorNotebook::addPage(GType page_type, guint submode)
581 {
582 GtkWidget *page;
584 page = sp_color_selector_new( page_type );
585 if ( page )
586 {
587 GtkWidget* tab_label = 0;
588 SPColorSelector* csel;
590 csel = SP_COLOR_SELECTOR (page);
591 if ( submode > 0 )
592 {
593 csel->base->setSubmode( submode );
594 }
595 gtk_widget_show (page);
596 int index = csel->base ? csel->base->getSubmode() : 0;
597 const gchar* str = _(SP_COLOR_SELECTOR_GET_CLASS (csel)->name[index]);
598 // g_message( "Hitting up for tab for '%s'", str );
599 tab_label = gtk_label_new(_(str));
600 gtk_notebook_append_page( GTK_NOTEBOOK (_book), page, tab_label );
601 gtk_signal_connect (GTK_OBJECT (page), "grabbed", GTK_SIGNAL_FUNC (_entryGrabbed), _csel);
602 gtk_signal_connect (GTK_OBJECT (page), "dragged", GTK_SIGNAL_FUNC (_entryDragged), _csel);
603 gtk_signal_connect (GTK_OBJECT (page), "released", GTK_SIGNAL_FUNC (_entryReleased), _csel);
604 gtk_signal_connect (GTK_OBJECT (page), "changed", GTK_SIGNAL_FUNC (_entryChanged), _csel);
605 }
607 return page;
608 }
610 GtkWidget* ColorNotebook::getPage(GType page_type, guint submode)
611 {
612 gint count = 0;
613 gint i = 0;
614 GtkWidget* page = 0;
616 // count = gtk_notebook_get_n_pages (_book);
617 count = 200;
618 for ( i = 0; i < count && !page; i++ )
619 {
620 page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (_book), i);
621 if ( page )
622 {
623 SPColorSelector* csel;
624 guint pagemode;
625 csel = SP_COLOR_SELECTOR (page);
626 pagemode = csel->base->getSubmode();
627 if ( G_TYPE_FROM_INSTANCE (page) == page_type
628 && pagemode == submode )
629 {
630 // found it.
631 break;
632 }
633 else
634 {
635 page = 0;
636 }
637 }
638 else
639 {
640 break;
641 }
642 }
643 return page;
644 }
646 void ColorNotebook::removePage( GType page_type, guint submode )
647 {
648 GtkWidget *page = 0;
650 page = getPage(page_type, submode);
651 if ( page )
652 {
653 gint where = gtk_notebook_page_num (GTK_NOTEBOOK (_book), page);
654 if ( where >= 0 )
655 {
656 if ( gtk_notebook_get_current_page (GTK_NOTEBOOK (_book)) == where )
657 {
658 // getColorAlpha(_color, &_alpha);
659 }
660 gtk_notebook_remove_page (GTK_NOTEBOOK (_book), where);
661 }
662 }
663 }
665 /*
666 Local Variables:
667 mode:c++
668 c-file-style:"stroustrup"
669 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
670 indent-tabs-mode:nil
671 fill-column:99
672 End:
673 */
674 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :