gtk2_ardour/utils.cc

   1 /*
   2     Copyright (C) 2003 Paul Davis
   3
   4     This program is free software; you an redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WAF_BUILD
  21 #include "gtk2ardour-config.h"
  22 #endif
  23
  24 #include <pango/pangoft2.h> // for fontmap resolution control for GnomeCanvas
  25 #include <pango/pangocairo.h> // for fontmap resolution control for GnomeCanvas
  26
  27 #include <cstdlib>
  28 #include <cctype>
  29 #include <fstream>
  30 #include <list>
  31 #include <sys/stat.h>
  32 #include <libart_lgpl/art_misc.h>
  33 #include <gtkmm/rc.h>
  34 #include <gtkmm/window.h>
  35 #include <gtkmm/combo.h>
  36 #include <gtkmm/label.h>
  37 #include <gtkmm/paned.h>
  38 #include <gtk/gtkpaned.h>
  39 #include <boost/algorithm/string.hpp>
  40
  41 #include "pbd/file_utils.h"
  42
  43 #include <gtkmm2ext/utils.h>
  44 #include "ardour/rc_configuration.h"
  45
  46 #include "ardour/filesystem_paths.h"
  47
  48 #include "ardour_ui.h"
  49 #include "debug.h"
  50 #include "public_editor.h"
  51 #include "keyboard.h"
  52 #include "utils.h"
  53 #include "i18n.h"
  54 #include "rgb_macros.h"
  55 #include "canvas_impl.h"
  56 #include "gui_thread.h"
  57
  58 using namespace std;
  59 using namespace Gtk;
  60 using namespace Glib;
  61 using namespace PBD;
  62 using Gtkmm2ext::Keyboard;
  63
  64 sigc::signal<void>  DPIReset;
  65
  66
  67 /** Add an element to a menu, settings its sensitivity.
  68  * @param m Menu to add to.
  69  * @param e Element to add.
  70  * @param s true to make sensitive, false to make insensitive
  71  */
  72 void
  73 add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s)
  74 {
  75         m.push_back (e);
  76         if (!s) {
  77                 m.back().set_sensitive (false);
  78         }
  79 }
  80
  81
  82 gint
  83 just_hide_it (GdkEventAny */*ev*/, Gtk::Window *win)
  84 {
  85         win->hide ();
  86         return 0;
  87 }
  88
  89 /* xpm2rgb copied from nixieclock, which bore the legend:
  90
  91     nixieclock - a nixie desktop timepiece
  92     Copyright (C) 2000 Greg Ercolano, erco@3dsite.com
  93
  94     and was released under the GPL.
  95 */
  96
  97 unsigned char*
  98 xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h)
  99 {
 100         static long vals[256], val;
 101         uint32_t t, x, y, colors, cpp;
 102         unsigned char c;
 103         unsigned char *savergb, *rgb;
 104
 105         // PARSE HEADER
 106
 107         if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
 108                 error << string_compose (_("bad XPM header %1"), xpm[0])
 109                       << endmsg;
 110                 return 0;
 111         }
 112
 113         savergb = rgb = (unsigned char*) malloc (h * w * 3);
 114
 115         // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 116         for (t = 0; t < colors; ++t) {
 117                 sscanf (xpm[t+1], "%c c #%lx", &c, &val);
 118                 vals[c] = val;
 119         }
 120
 121         // COLORMAP -> RGB CONVERSION
 122         //    Get low 3 bytes from vals[]
 123         //
 124
 125         const char *p;
 126         for (y = h-1; y > 0; --y) {
 127
 128                 for (p = xpm[1+colors+(h-y-1)], x = 0; x < w; x++, rgb += 3) {
 129                         val = vals[(int)*p++];
 130                         *(rgb+2) = val & 0xff; val >>= 8;  // 2:B
 131                         *(rgb+1) = val & 0xff; val >>= 8;  // 1:G
 132                         *(rgb+0) = val & 0xff;             // 0:R
 133                 }
 134         }
 135
 136         return (savergb);
 137 }
 138
 139 unsigned char*
 140 xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
 141 {
 142         static long vals[256], val;
 143         uint32_t t, x, y, colors, cpp;
 144         unsigned char c;
 145         unsigned char *savergb, *rgb;
 146         char transparent;
 147
 148         // PARSE HEADER
 149
 150         if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
 151                 error << string_compose (_("bad XPM header %1"), xpm[0])
 152                       << endmsg;
 153                 return 0;
 154         }
 155
 156         savergb = rgb = (unsigned char*) malloc (h * w * 4);
 157
 158         // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 159
 160         if (strstr (xpm[1], "None")) {
 161                 sscanf (xpm[1], "%c", &transparent);
 162                 t = 1;
 163         } else {
 164                 transparent = 0;
 165                 t = 0;
 166         }
 167
 168         for (; t < colors; ++t) {
 169                 sscanf (xpm[t+1], "%c c #%lx", &c, &val);
 170                 vals[c] = val;
 171         }
 172
 173         // COLORMAP -> RGB CONVERSION
 174         //    Get low 3 bytes from vals[]
 175         //
 176
 177         const char *p;
 178         for (y = h-1; y > 0; --y) {
 179
 180                 char alpha;
 181
 182                 for (p = xpm[1+colors+(h-y-1)], x = 0; x < w; x++, rgb += 4) {
 183
 184                         if (transparent && (*p++ == transparent)) {
 185                                 alpha = 0;
 186                                 val = 0;
 187                         } else {
 188                                 alpha = 255;
 189                                 val = vals[(int)*p];
 190                         }
 191
 192                         *(rgb+3) = alpha;                  // 3: alpha
 193                         *(rgb+2) = val & 0xff; val >>= 8;  // 2:B
 194                         *(rgb+1) = val & 0xff; val >>= 8;  // 1:G
 195                         *(rgb+0) = val & 0xff;             // 0:R
 196                 }
 197         }
 198
 199         return (savergb);
 200 }
 201
 202 ArdourCanvas::Points*
 203 get_canvas_points (string /*who*/, uint32_t npoints)
 204 {
 205         // cerr << who << ": wants " << npoints << " canvas points" << endl;
 206 #ifdef TRAP_EXCESSIVE_POINT_REQUESTS
 207         if (npoints > (uint32_t) gdk_screen_width() + 4) {
 208                 abort ();
 209         }
 210 #endif
 211         return new ArdourCanvas::Points (npoints);
 212 }
 213
 214 Pango::FontDescription
 215 get_font_for_style (string widgetname)
 216 {
 217         Gtk::Window window (WINDOW_TOPLEVEL);
 218         Gtk::Label foobar;
 219         Glib::RefPtr<Gtk::Style> style;
 220
 221         window.add (foobar);
 222         foobar.set_name (widgetname);
 223         foobar.ensure_style();
 224
 225         style = foobar.get_style ();
 226
 227         Glib::RefPtr<const Pango::Layout> layout = foobar.get_layout();
 228
 229         PangoFontDescription *pfd = (PangoFontDescription *)pango_layout_get_font_description((PangoLayout *)layout->gobj());
 230
 231         if (!pfd) {
 232
 233                 /* layout inherited its font description from a PangoContext */
 234
 235                 PangoContext* ctxt = (PangoContext*) pango_layout_get_context ((PangoLayout*) layout->gobj());
 236                 pfd =  pango_context_get_font_description (ctxt);
 237                 return Pango::FontDescription (pfd); /* make a copy */
 238         }
 239
 240         return Pango::FontDescription (pfd); /* make a copy */
 241 }
 242
 243 uint32_t
 244 rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, string attr, int state, bool rgba)
 245 {
 246         /* In GTK+2, styles aren't set up correctly if the widget is not
 247            attached to a toplevel window that has a screen pointer.
 248         */
 249
 250         static Gtk::Window* window = 0;
 251
 252         if (window == 0) {
 253                 window = new Window (WINDOW_TOPLEVEL);
 254         }
 255
 256         Gtk::Label foo;
 257
 258         window->add (foo);
 259
 260         foo.set_name (style);
 261         foo.ensure_style ();
 262
 263         GtkRcStyle* rc = foo.get_style()->gobj()->rc_style;
 264
 265         if (rc) {
 266                 if (attr == "fg") {
 267                         r = rc->fg[state].red / 257;
 268                         g = rc->fg[state].green / 257;
 269                         b = rc->fg[state].blue / 257;
 270
 271                         /* what a hack ... "a" is for "active" */
 272                         if (state == Gtk::STATE_NORMAL && rgba) {
 273                                 a = rc->fg[GTK_STATE_ACTIVE].red / 257;
 274                         }
 275                 } else if (attr == "bg") {
 276                         r = g = b = 0;
 277                         r = rc->bg[state].red / 257;
 278                         g = rc->bg[state].green / 257;
 279                         b = rc->bg[state].blue / 257;
 280                 } else if (attr == "base") {
 281                         r = rc->base[state].red / 257;
 282                         g = rc->base[state].green / 257;
 283                         b = rc->base[state].blue / 257;
 284                 } else if (attr == "text") {
 285                         r = rc->text[state].red / 257;
 286                         g = rc->text[state].green / 257;
 287                         b = rc->text[state].blue / 257;
 288                 }
 289         } else {
 290                 warning << string_compose (_("missing RGBA style for \"%1\""), style) << endl;
 291         }
 292
 293         window->remove ();
 294
 295         if (state == Gtk::STATE_NORMAL && rgba) {
 296                 return (uint32_t) RGBA_TO_UINT(r,g,b,a);
 297         } else {
 298                 return (uint32_t) RGB_TO_UINT(r,g,b);
 299         }
 300 }
 301
 302 bool
 303 canvas_item_visible (ArdourCanvas::Item* item)
 304 {
 305         return (item->gobj()->object.flags & GNOME_CANVAS_ITEM_VISIBLE) ? true : false;
 306 }
 307
 308 void
 309 set_color (Gdk::Color& c, int rgb)
 310 {
 311         c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256);
 312 }
 313
 314 bool
 315 relay_key_press (GdkEventKey* ev, Gtk::Window* win)
 316 {
 317         if (!key_press_focus_accelerator_handler (*win, ev)) {
 318                 return PublicEditor::instance().on_key_press_event(ev);
 319         } else {
 320                 return true;
 321         }
 322 }
 323
 324 bool
 325 forward_key_press (GdkEventKey* ev)
 326 {
 327         return PublicEditor::instance().on_key_press_event(ev);
 328 }
 329
 330 bool
 331 key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
 332 {
 333         GtkWindow* win = window.gobj();
 334         GtkWidget* focus = gtk_window_get_focus (win);
 335         bool special_handling_of_unmodified_accelerators = false;
 336         bool allow_activating = true;
 337         /* consider all relevant modifiers but not LOCK or SHIFT */
 338         const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
 339
 340         if (focus) {
 341                 if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
 342                         special_handling_of_unmodified_accelerators = true;
 343                 }
 344         }
 345
 346 #ifdef GTKOSX
 347         /* should this be universally true? */
 348         if (Keyboard::some_magic_widget_has_focus ()) {
 349                 allow_activating = false;
 350         }
 351 #endif
 352
 353
 354         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("Win = %1 focus = %7 Key event: code = %2  state = %3 special handling ? %4 magic widget focus ? %5 allow_activation ? %6\n",
 355                                                           win,
 356                                                           ev->keyval,
 357                                                           ev->state,
 358                                                           special_handling_of_unmodified_accelerators,
 359                                                           Keyboard::some_magic_widget_has_focus(),
 360                                                           allow_activating,
 361                                                           focus));
 362
 363         /* This exists to allow us to override the way GTK handles
 364            key events. The normal sequence is:
 365
 366            a) event is delivered to a GtkWindow
 367            b) accelerators/mnemonics are activated
 368            c) if (b) didn't handle the event, propagate to
 369                the focus widget and/or focus chain
 370
 371            The problem with this is that if the accelerators include
 372            keys without modifiers, such as the space bar or the
 373            letter "e", then pressing the key while typing into
 374            a text entry widget results in the accelerator being
 375            activated, instead of the desired letter appearing
 376            in the text entry.
 377
 378            There is no good way of fixing this, but this
 379            represents a compromise. The idea is that
 380            key events involving modifiers (not Shift)
 381            get routed into the activation pathway first, then
 382            get propagated to the focus widget if necessary.
 383
 384            If the key event doesn't involve modifiers,
 385            we deliver to the focus widget first, thus allowing
 386            it to get "normal text" without interference
 387            from acceleration.
 388
 389            Of course, this can also be problematic: if there
 390            is a widget with focus, then it will swallow
 391            all "normal text" accelerators.
 392         */
 393
 394         if (!special_handling_of_unmodified_accelerators) {
 395
 396                 /* XXX note that for a brief moment, the conditional above
 397                  * included "|| (ev->state & mask)" so as to enforce the
 398                  * implication of special_handling_of_UNMODIFIED_accelerators.
 399                  * however, this forces any key that GTK doesn't allow and that
 400                  * we have an alternative (see next comment) for to be
 401                  * automatically sent through the accel groups activation
 402                  * pathway, which prevents individual widgets & canvas items
 403                  * from ever seeing it if is used by a key binding.
 404                  *
 405                  * specifically, this hid Ctrl-down-arrow from MIDI region
 406                  * views because it is also bound to an action.
 407                  *
 408                  * until we have a robust, clean binding system, this
 409                  * quirk will have to remain in place.
 410                  */
 411
 412                 /* pretend that certain key events that GTK does not allow
 413                    to be used as accelerators are actually something that
 414                    it does allow. but only where there are no modifiers.
 415                 */
 416
 417                 uint32_t fakekey = ev->keyval;
 418
 419                 if (Gtkmm2ext::possibly_translate_keyval_to_make_legal_accelerator (fakekey)) {
 420                         DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tactivate (was %1 now %2) without special hanlding of unmodified accels\n",
 421                                                                           ev->keyval, fakekey));
 422
 423                         GdkModifierType mod = GdkModifierType (ev->state);
 424
 425                         mod = GdkModifierType (mod & gtk_accelerator_get_default_mod_mask());
 426 #ifdef GTKOSX
 427                         /* GTK on OS X is currently (February 2012) setting both
 428                            the Meta and Mod2 bits in the event modifier state if
 429                            the Command key is down.
 430
 431                            gtk_accel_groups_activate() does not invoke any of the logic
 432                            that gtk_window_activate_key() will that sorts out that stupid
 433                            state of affairs, and as a result it fails to find a match
 434                            for the key event and the current set of accelerators.
 435
 436                            to fix this, if the meta bit is set, remove the mod2 bit
 437                            from the modifier. this assumes that our bindings use Primary
 438                            which will have set the meta bit in the accelerator entry.
 439                         */
 440                         if (mod & GDK_META_MASK) {
 441                                 mod = GdkModifierType (mod & ~GDK_MOD2_MASK);
 442                         }
 443 #endif
 444
 445                         if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, mod)) {
 446                                 DEBUG_TRACE (DEBUG::Accelerators, "\taccel group activated by fakekey\n");
 447                                 return true;
 448                         }
 449                 }
 450         }
 451
 452         if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
 453
 454                 /* no special handling or there are modifiers in effect: accelerate first */
 455
 456                 DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n");
 457
 458                 if (allow_activating) {
 459                         if (gtk_window_activate_key (win, ev)) {
 460                                 return true;
 461                         }
 462                 } else {
 463                         DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
 464                 }
 465
 466                 DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n");
 467
 468                 return gtk_window_propagate_key_event (win, ev);
 469         }
 470
 471         /* no modifiers, propagate first */
 472
 473         DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n");
 474
 475         if (!gtk_window_propagate_key_event (win, ev)) {
 476                 DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n");
 477                 if (allow_activating) {
 478                         return gtk_window_activate_key (win, ev);
 479                 } else {
 480                         DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
 481                 }
 482
 483         } else {
 484                 DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n");
 485                 return true;
 486         }
 487
 488         DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n");
 489         return true;
 490 }
 491
 492 Glib::RefPtr<Gdk::Pixbuf>
 493 get_xpm (std::string name)
 494 {
 495         if (!xpm_map[name]) {
 496
 497                 SearchPath spath(ARDOUR::ardour_data_search_path());
 498
 499                 spath.add_subdirectory_to_paths("pixmaps");
 500
 501                 sys::path data_file_path;
 502
 503                 if(!find_file_in_search_path (spath, name, data_file_path)) {
 504                         fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg;
 505                 }
 506
 507                 try {
 508                         xpm_map[name] =  Gdk::Pixbuf::create_from_file (data_file_path.to_string());
 509                 } catch(const Glib::Error& e)   {
 510                         warning << "Caught Glib::Error: " << e.what() << endmsg;
 511                 }
 512         }
 513
 514         return xpm_map[name];
 515 }
 516
 517 std::string
 518 get_icon_path (const char* cname)
 519 {
 520         string name = cname;
 521         name += X_(".png");
 522
 523         SearchPath spath(ARDOUR::ardour_data_search_path());
 524
 525         spath.add_subdirectory_to_paths("icons");
 526
 527         sys::path data_file_path;
 528
 529         if (!find_file_in_search_path (spath, name, data_file_path)) {
 530                 fatal << string_compose (_("cannot find icon image for %1 using %2"), name, spath.to_string()) << endmsg;
 531         }
 532
 533         return data_file_path.to_string();
 534 }
 535
 536 Glib::RefPtr<Gdk::Pixbuf>
 537 get_icon (const char* cname)
 538 {
 539         Glib::RefPtr<Gdk::Pixbuf> img;
 540         try {
 541                 img = Gdk::Pixbuf::create_from_file (get_icon_path (cname));
 542         } catch (const Gdk::PixbufError &e) {
 543                 cerr << "Caught PixbufError: " << e.what() << endl;
 544         } catch (...) {
 545                 g_message("Caught ... ");
 546         }
 547
 548         return img;
 549 }
 550
 551 string
 552 longest (vector<string>& strings)
 553 {
 554         if (strings.empty()) {
 555                 return string ("");
 556         }
 557
 558         vector<string>::iterator longest = strings.begin();
 559         string::size_type longest_length = (*longest).length();
 560
 561         vector<string>::iterator i = longest;
 562         ++i;
 563
 564         while (i != strings.end()) {
 565
 566                 string::size_type len = (*i).length();
 567
 568                 if (len > longest_length) {
 569                         longest = i;
 570                         longest_length = len;
 571                 }
 572
 573                 ++i;
 574         }
 575
 576         return *longest;
 577 }
 578
 579 bool
 580 key_is_legal_for_numeric_entry (guint keyval)
 581 {
 582         switch (keyval) {
 583         case GDK_minus:
 584         case GDK_plus:
 585         case GDK_period:
 586         case GDK_comma:
 587         case GDK_0:
 588         case GDK_1:
 589         case GDK_2:
 590         case GDK_3:
 591         case GDK_4:
 592         case GDK_5:
 593         case GDK_6:
 594         case GDK_7:
 595         case GDK_8:
 596         case GDK_9:
 597         case GDK_KP_Add:
 598         case GDK_KP_Subtract:
 599         case GDK_KP_Decimal:
 600         case GDK_KP_0:
 601         case GDK_KP_1:
 602         case GDK_KP_2:
 603         case GDK_KP_3:
 604         case GDK_KP_4:
 605         case GDK_KP_5:
 606         case GDK_KP_6:
 607         case GDK_KP_7:
 608         case GDK_KP_8:
 609         case GDK_KP_9:
 610         case GDK_Return:
 611         case GDK_BackSpace:
 612         case GDK_Delete:
 613         case GDK_KP_Enter:
 614         case GDK_Home:
 615         case GDK_End:
 616         case GDK_Left:
 617         case GDK_Right:
 618                 return true;
 619
 620         default:
 621                 break;
 622         }
 623
 624         return false;
 625 }
 626 void
 627 set_pango_fontsize ()
 628 {
 629         long val = ARDOUR::Config->get_font_scale();
 630
 631         /* FT2 rendering - used by GnomeCanvas, sigh */
 632
 633         pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_for_display(), val/1024, val/1024);
 634
 635         /* Cairo rendering, in case there is any */
 636
 637         pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) pango_cairo_font_map_get_default(), val/1024);
 638 }
 639
 640 void
 641 reset_dpi ()
 642 {
 643         long val = ARDOUR::Config->get_font_scale();
 644         set_pango_fontsize ();
 645         /* Xft rendering */
 646
 647         gtk_settings_set_long_property (gtk_settings_get_default(),
 648                                         "gtk-xft-dpi", val, "ardour");
 649         DPIReset();//Emit Signal
 650 }
 651
 652 void
 653 resize_window_to_proportion_of_monitor (Gtk::Window* window, int max_width, int max_height)
 654 {
 655         Glib::RefPtr<Gdk::Screen> screen = window->get_screen ();
 656         Gdk::Rectangle monitor_rect;
 657         screen->get_monitor_geometry (0, monitor_rect);
 658
 659         int const w = std::min (int (monitor_rect.get_width() * 0.8), max_width);
 660         int const h = std::min (int (monitor_rect.get_height() * 0.8), max_height);
 661
 662         window->resize (w, h);
 663 }
 664
 665
 666 /** Replace _ with __ in a string; for use with menu item text to make underscores displayed correctly */
 667 string
 668 escape_underscores (string const & s)
 669 {
 670         string o;
 671         string::size_type const N = s.length ();
 672
 673         for (string::size_type i = 0; i < N; ++i) {
 674                 if (s[i] == '_') {
 675                         o += "__";
 676                 } else {
 677                         o += s[i];
 678                 }
 679         }
 680
 681         return o;
 682 }
 683
 684 /** Replace < and > with &lt; and &gt; respectively to make < > display correctly in markup strings */
 685 string
 686 escape_angled_brackets (string const & s)
 687 {
 688         string o = s;
 689         boost::replace_all (o, "<", "&lt;");
 690         boost::replace_all (o, ">", "&gt;");
 691         return o;
 692 }
 693
 694 Gdk::Color
 695 unique_random_color (list<Gdk::Color>& used_colors)
 696 {
 697         Gdk::Color newcolor;
 698
 699         while (1) {
 700
 701                 /* avoid neon/glowing tones by limiting them to the
 702                    "inner section" (paler) of a color wheel/circle.
 703                 */
 704
 705                 const int32_t max_saturation = 48000; // 65535 would open up the whole color wheel
 706
 707                 newcolor.set_red (random() % max_saturation);
 708                 newcolor.set_blue (random() % max_saturation);
 709                 newcolor.set_green (random() % max_saturation);
 710
 711                 if (used_colors.size() == 0) {
 712                         used_colors.push_back (newcolor);
 713                         return newcolor;
 714                 }
 715
 716                 for (list<Gdk::Color>::iterator i = used_colors.begin(); i != used_colors.end(); ++i) {
 717                   Gdk::Color c = *i;
 718                         float rdelta, bdelta, gdelta;
 719
 720                         rdelta = newcolor.get_red() - c.get_red();
 721                         bdelta = newcolor.get_blue() - c.get_blue();
 722                         gdelta = newcolor.get_green() - c.get_green();
 723
 724                         if (sqrt (rdelta*rdelta + bdelta*bdelta + gdelta*gdelta) > 25.0) {
 725                                 used_colors.push_back (newcolor);
 726                                 return newcolor;
 727                         }
 728                 }
 729
 730                 /* XXX need throttle here to make sure we don't spin for ever */
 731         }
 732 }