projects / ardour.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
mark the step entry dialog as a dialog even though it is an ArdourWindow, to help...
[ardour.git] / gtk2_ardour / utils.cc
diff --git a/gtk2_ardour/utils.cc b/gtk2_ardour/utils.cc
index 85bb46c6c81ffa6db8e13a2e12957781c8d656af..19f93ad2e82b8005a08790ed341827c0e97ce945 100644 (file)
--- a/gtk2_ardour/utils.cc
+++ b/gtk2_ardour/utils.cc
@@ -1,5 +1,5 @@
 /*
 /*
-    Copyright (C) 2003 Paul Davis 
+    Copyright (C) 2003 Paul Davis
 
     This program is free software; you an redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
 
     This program is free software; you an redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -17,12 +17,19 @@
 
 */
 
 
 */
 
+#ifdef WAF_BUILD
+#include "gtk2ardour-config.h"
+#endif
+
 #include <pango/pangoft2.h> // for fontmap resolution control for GnomeCanvas
 #include <pango/pangocairo.h> // for fontmap resolution control for GnomeCanvas
 
 #include <cstdlib>
 #include <pango/pangoft2.h> // for fontmap resolution control for GnomeCanvas
 #include <pango/pangocairo.h> // for fontmap resolution control for GnomeCanvas
 
 #include <cstdlib>
+#include <clocale>
+#include <cstring>
 #include <cctype>
 #include <fstream>
 #include <cctype>
 #include <fstream>
+#include <list>
 #include <sys/stat.h>
 #include <libart_lgpl/art_misc.h>
 #include <gtkmm/rc.h>
 #include <sys/stat.h>
 #include <libart_lgpl/art_misc.h>
 #include <gtkmm/rc.h>
@@ -31,119 +38,51 @@
 #include <gtkmm/label.h>
 #include <gtkmm/paned.h>
 #include <gtk/gtkpaned.h>
 #include <gtkmm/label.h>
 #include <gtkmm/paned.h>
 #include <gtk/gtkpaned.h>
+#include <boost/algorithm/string.hpp>
 
 #include "pbd/file_utils.h"
 
 #include <gtkmm2ext/utils.h>
 
 #include "pbd/file_utils.h"
 
 #include <gtkmm2ext/utils.h>
-#include "ardour/configuration.h"
-#include "ardour/configuration.h"
+#include "ardour/rc_configuration.h"
 
 #include "ardour/filesystem_paths.h"
 
 #include "ardour_ui.h"
 
 #include "ardour/filesystem_paths.h"
 
 #include "ardour_ui.h"
+#include "debug.h"
+#include "public_editor.h"
 #include "keyboard.h"
 #include "utils.h"
 #include "i18n.h"
 #include "rgb_macros.h"
 #include "canvas_impl.h"
 #include "keyboard.h"
 #include "utils.h"
 #include "i18n.h"
 #include "rgb_macros.h"
 #include "canvas_impl.h"
+#include "gui_thread.h"
 
 using namespace std;
 using namespace Gtk;
 
 using namespace std;
 using namespace Gtk;
-using namespace sigc;
 using namespace Glib;
 using namespace PBD;
 using namespace Glib;
 using namespace PBD;
+using Gtkmm2ext::Keyboard;
 
 sigc::signal<void>  DPIReset;
 
 
 sigc::signal<void>  DPIReset;
 
-int
-pixel_width (const ustring& str, Pango::FontDescription& font)
-{
-       Label foo;
-       Glib::RefPtr<Pango::Layout> layout = foo.create_pango_layout ("");
-
-       layout->set_font_description (font);
-       layout->set_text (str);
 
 
-       int width, height;
-       Gtkmm2ext::get_ink_pixel_size (layout, width, height);
-       return width;
-}
-
-ustring
-fit_to_pixels (const ustring& str, int pixel_width, Pango::FontDescription& font, int& actual_width, bool with_ellipses)
+/** Add an element to a menu, settings its sensitivity.
+ * @param m Menu to add to.
+ * @param e Element to add.
+ * @param s true to make sensitive, false to make insensitive
+ */
+void
+add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s)
 {
 {
-       Label foo;
-       Glib::RefPtr<Pango::Layout> layout = foo.create_pango_layout ("");
-       ustring::size_type shorter_by = 0;
-       ustring txt;
-
-       layout->set_font_description (font);
-
-       actual_width = 0;
-
-       ustring ustr = str;
-       ustring::iterator last = ustr.end();
-       --last; /* now points at final entry */
-
-       txt = ustr;
-
-       while (!ustr.empty()) {
-
-               layout->set_text (txt);
-
-               int width, height;
-               Gtkmm2ext::get_ink_pixel_size (layout, width, height);
-
-               if (width < pixel_width) {
-                       actual_width = width;
-                       break;
-               }
-               
-               ustr.erase (last--);
-               shorter_by++;
-
-               if (with_ellipses && shorter_by > 3) {
-                       txt = ustr;
-                       txt += "...";
-               } else {
-                       txt = ustr;
-               }
+       m.push_back (e);
+       if (!s) {
+               m.back().set_sensitive (false);
        }
        }
-
-       return txt;
-}
-
-std::pair<std::string, double>
-fit_to_pixels (cairo_t* cr, std::string name, double avail)
-{
-       /* XXX hopefully there exists a more efficient way of doing this */
-
-       bool abbreviated = false;
-       uint32_t width = 0;
-               
-       while (1) {
-               cairo_text_extents_t ext;
-               cairo_text_extents (cr, name.c_str(), &ext);
-
-               if (ext.width < avail || name.length() <= 4) {
-                       width = ext.width;
-                       break;
-               }
-
-               if (abbreviated) {
-                       name = name.substr (0, name.length() - 4) + "...";
-               } else {
-                       name = name.substr (0, name.length() - 3) + "...";
-                       abbreviated = true;
-               }
-       }
-
-       return std::make_pair (name, width);
 }
 
 
 gint
 }
 
 
 gint
-just_hide_it (GdkEventAny *ev, Gtk::Window *win)
+just_hide_it (GdkEventAny */*ev*/, Gtk::Window *win)
 {
        win->hide ();
        return 0;
 {
        win->hide ();
        return 0;
@@ -164,9 +103,9 @@ xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h)
        uint32_t t, x, y, colors, cpp;
        unsigned char c;
        unsigned char *savergb, *rgb;
        uint32_t t, x, y, colors, cpp;
        unsigned char c;
        unsigned char *savergb, *rgb;
-       
+
        // PARSE HEADER
        // PARSE HEADER
-       
+
        if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
                error << string_compose (_("bad XPM header %1"), xpm[0])
                      << endmsg;
        if ( sscanf(xpm[0], "%u%u%u%u", &w, &h, &colors, &cpp) != 4 ) {
                error << string_compose (_("bad XPM header %1"), xpm[0])
                      << endmsg;
@@ -174,13 +113,13 @@ xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h)
        }
 
        savergb = rgb = (unsigned char*) malloc (h * w * 3);
        }
 
        savergb = rgb = (unsigned char*) malloc (h * w * 3);
-       
+
        // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
        for (t = 0; t < colors; ++t) {
                sscanf (xpm[t+1], "%c c #%lx", &c, &val);
                vals[c] = val;
        }
        // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
        for (t = 0; t < colors; ++t) {
                sscanf (xpm[t+1], "%c c #%lx", &c, &val);
                vals[c] = val;
        }
-       
+
        // COLORMAP -> RGB CONVERSION
        //    Get low 3 bytes from vals[]
        //
        // COLORMAP -> RGB CONVERSION
        //    Get low 3 bytes from vals[]
        //
@@ -217,7 +156,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
        }
 
        savergb = rgb = (unsigned char*) malloc (h * w * 4);
        }
 
        savergb = rgb = (unsigned char*) malloc (h * w * 4);
-       
+
        // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 
        if (strstr (xpm[1], "None")) {
        // LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
 
        if (strstr (xpm[1], "None")) {
@@ -232,7 +171,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
                sscanf (xpm[t+1], "%c c #%lx", &c, &val);
                vals[c] = val;
        }
                sscanf (xpm[t+1], "%c c #%lx", &c, &val);
                vals[c] = val;
        }
-       
+
        // COLORMAP -> RGB CONVERSION
        //    Get low 3 bytes from vals[]
        //
        // COLORMAP -> RGB CONVERSION
        //    Get low 3 bytes from vals[]
        //
@@ -263,7 +202,7 @@ xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
 }
 
 ArdourCanvas::Points*
 }
 
 ArdourCanvas::Points*
-get_canvas_points (string who, uint32_t npoints)
+get_canvas_points (string /*who*/, uint32_t npoints)
 {
        // cerr << who << ": wants " << npoints << " canvas points" << endl;
 #ifdef TRAP_EXCESSIVE_POINT_REQUESTS
 {
        // cerr << who << ": wants " << npoints << " canvas points" << endl;
 #ifdef TRAP_EXCESSIVE_POINT_REQUESTS
@@ -274,7 +213,7 @@ get_canvas_points (string who, uint32_t npoints)
        return new ArdourCanvas::Points (npoints);
 }
 
        return new ArdourCanvas::Points (npoints);
 }
 
-Pango::FontDescription*
+Pango::FontDescription
 get_font_for_style (string widgetname)
 {
        Gtk::Window window (WINDOW_TOPLEVEL);
 get_font_for_style (string widgetname)
 {
        Gtk::Window window (WINDOW_TOPLEVEL);
@@ -288,19 +227,19 @@ get_font_for_style (string widgetname)
        style = foobar.get_style ();
 
        Glib::RefPtr<const Pango::Layout> layout = foobar.get_layout();
        style = foobar.get_style ();
 
        Glib::RefPtr<const Pango::Layout> layout = foobar.get_layout();
-       
-       PangoFontDescription *pfd = (PangoFontDescription *)pango_layout_get_font_description((PangoLayout *)layout->gobj());
-       
+
+       PangoFontDescription *pfd = const_cast<PangoFontDescription *> (pango_layout_get_font_description(const_cast<PangoLayout *>(layout->gobj())));
+
        if (!pfd) {
        if (!pfd) {
-               
+
                /* layout inherited its font description from a PangoContext */
 
                /* layout inherited its font description from a PangoContext */
 
-               PangoContext* ctxt = (PangoContext*) pango_layout_get_context ((PangoLayout*) layout->gobj());
+               PangoContext* ctxt = (PangoContext*) pango_layout_get_context (const_cast<PangoLayout*>(layout->gobj()));
                pfd =  pango_context_get_font_description (ctxt);
                pfd =  pango_context_get_font_description (ctxt);
-               return new Pango::FontDescription (pfd, true); /* make a copy */
-       } 
+               return Pango::FontDescription (pfd); /* make a copy */
+       }
 
 
-       return new Pango::FontDescription (pfd, true); /* make a copy */
+       return Pango::FontDescription (pfd); /* make a copy */
 }
 
 uint32_t
 }
 
 uint32_t
@@ -317,44 +256,44 @@ rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, s
        }
 
        Gtk::Label foo;
        }
 
        Gtk::Label foo;
-       
+
        window->add (foo);
 
        foo.set_name (style);
        foo.ensure_style ();
        window->add (foo);
 
        foo.set_name (style);
        foo.ensure_style ();
-       
-       GtkRcStyle* waverc = foo.get_style()->gobj()->rc_style;
 
 
-       if (waverc) {
+       GtkRcStyle* rc = foo.get_style()->gobj()->rc_style;
+
+       if (rc) {
                if (attr == "fg") {
                if (attr == "fg") {
-                       r = waverc->fg[state].red / 257;
-                       g = waverc->fg[state].green / 257;
-                       b = waverc->fg[state].blue / 257;
- 
+                       r = rc->fg[state].red / 257;
+                       g = rc->fg[state].green / 257;
+                       b = rc->fg[state].blue / 257;
+
                        /* what a hack ... "a" is for "active" */
                        if (state == Gtk::STATE_NORMAL && rgba) {
                        /* what a hack ... "a" is for "active" */
                        if (state == Gtk::STATE_NORMAL && rgba) {
-                               a = waverc->fg[GTK_STATE_ACTIVE].red / 257;
+                               a = rc->fg[GTK_STATE_ACTIVE].red / 257;
                        }
                } else if (attr == "bg") {
                        r = g = b = 0;
                        }
                } else if (attr == "bg") {
                        r = g = b = 0;
-                       r = waverc->bg[state].red / 257;
-                       g = waverc->bg[state].green / 257;
-                       b = waverc->bg[state].blue / 257;
+                       r = rc->bg[state].red / 257;
+                       g = rc->bg[state].green / 257;
+                       b = rc->bg[state].blue / 257;
                } else if (attr == "base") {
                } else if (attr == "base") {
-                       r = waverc->base[state].red / 257;
-                       g = waverc->base[state].green / 257;
-                       b = waverc->base[state].blue / 257;
+                       r = rc->base[state].red / 257;
+                       g = rc->base[state].green / 257;
+                       b = rc->base[state].blue / 257;
                } else if (attr == "text") {
                } else if (attr == "text") {
-                       r = waverc->text[state].red / 257;
-                       g = waverc->text[state].green / 257;
-                       b = waverc->text[state].blue / 257;
+                       r = rc->text[state].red / 257;
+                       g = rc->text[state].green / 257;
+                       b = rc->text[state].blue / 257;
                }
        } else {
                warning << string_compose (_("missing RGBA style for \"%1\""), style) << endl;
        }
 
        window->remove ();
                }
        } else {
                warning << string_compose (_("missing RGBA style for \"%1\""), style) << endl;
        }
 
        window->remove ();
-       
+
        if (state == Gtk::STATE_NORMAL && rgba) {
                return (uint32_t) RGBA_TO_UINT(r,g,b,a);
        } else {
        if (state == Gtk::STATE_NORMAL && rgba) {
                return (uint32_t) RGBA_TO_UINT(r,g,b,a);
        } else {
@@ -362,113 +301,7 @@ rgba_from_style (string style, uint32_t r, uint32_t g, uint32_t b, uint32_t a, s
        }
 }
 
        }
 }
 
-
-Gdk::Color
-color_from_style (string widget_style_name, int state, string attr)
-{
-       GtkStyle* style;
-
-       style = gtk_rc_get_style_by_paths (gtk_settings_get_default(),
-                                          widget_style_name.c_str(),
-                                          0, G_TYPE_NONE);
-
-       if (!style) {
-               error << string_compose (_("no style found for %1, using red"), style) << endmsg;
-               return Gdk::Color ("red");
-       }
-
-       if (attr == "fg") {
-               return Gdk::Color (&style->fg[state]);
-       }
-
-       if (attr == "bg") {
-               return Gdk::Color (&style->bg[state]);
-       }
-
-       if (attr == "light") {
-               return Gdk::Color (&style->light[state]);
-       }
-
-       if (attr == "dark") {
-               return Gdk::Color (&style->dark[state]);
-       }
-
-       if (attr == "mid") {
-               return Gdk::Color (&style->mid[state]);
-       }
-
-       if (attr == "text") {
-               return Gdk::Color (&style->text[state]);
-       }
-
-       if (attr == "base") {
-               return Gdk::Color (&style->base[state]);
-       }
-
-       if (attr == "text_aa") {
-               return Gdk::Color (&style->text_aa[state]);
-       }
-
-       error << string_compose (_("unknown style attribute %1 requested for color; using \"red\""), attr) << endmsg;
-       return Gdk::Color ("red");
-}
-
-Glib::RefPtr<Gdk::GC>
-gc_from_style (string widget_style_name, int state, string attr)
-{
-        GtkStyle* style;
-
-        style = gtk_rc_get_style_by_paths (gtk_settings_get_default(),
-                                           widget_style_name.c_str(),
-                                           0, G_TYPE_NONE);
-
-        if (!style) {
-                error << string_compose (_("no style found for %1, using red"), style) << endmsg;
-               Glib::RefPtr<Gdk::GC> ret = Gdk::GC::create();
-               ret->set_rgb_fg_color(Gdk::Color("red"));
-                return ret;
-        }
-
-        if (attr == "fg") {
-                return Glib::wrap(style->fg_gc[state]);
-        }
-
-        if (attr == "bg") {
-                return Glib::wrap(style->bg_gc[state]);
-        }
-
-        if (attr == "light") {
-                return Glib::wrap(style->light_gc[state]);
-        }
-
-        if (attr == "dark") {
-                return Glib::wrap(style->dark_gc[state]);
-        }
-
-        if (attr == "mid") {
-                return Glib::wrap(style->mid_gc[state]);
-        }
-
-        if (attr == "text") {
-                return Glib::wrap(style->text_gc[state]);
-        }
-
-        if (attr == "base") {
-                return Glib::wrap(style->base_gc[state]);
-        }
-
-        if (attr == "text_aa") {
-                return Glib::wrap(style->text_aa_gc[state]);
-        }
-
-        error << string_compose (_("unknown style attribute %1 requested for color; using \"red\""), attr) << endmsg;
-       Glib::RefPtr<Gdk::GC> ret = Gdk::GC::create();
-       ret->set_rgb_fg_color(Gdk::Color("red"));
-        return ret;
-}
-
-
-bool 
+bool
 canvas_item_visible (ArdourCanvas::Item* item)
 {
        return (item->gobj()->object.flags & GNOME_CANVAS_ITEM_VISIBLE) ? true : false;
 canvas_item_visible (ArdourCanvas::Item* item)
 {
        return (item->gobj()->object.flags & GNOME_CANVAS_ITEM_VISIBLE) ? true : false;
@@ -480,11 +313,21 @@ set_color (Gdk::Color& c, int rgb)
        c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256);
 }
 
        c.set_rgb((rgb >> 16)*256, ((rgb & 0xff00) >> 8)*256, (rgb & 0xff)*256);
 }
 
-#ifdef GTKOSX
-extern "C" {
-       gboolean gdk_quartz_possibly_forward (GdkEvent*);
+bool
+relay_key_press (GdkEventKey* ev, Gtk::Window* win)
+{
+       if (!key_press_focus_accelerator_handler (*win, ev)) {
+               return PublicEditor::instance().on_key_press_event(ev);
+       } else {
+               return true;
+       }
+}
+
+bool
+forward_key_press (GdkEventKey* ev)
+{
+        return PublicEditor::instance().on_key_press_event(ev);
 }
 }
-#endif
 
 bool
 key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
 
 bool
 key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
@@ -493,37 +336,37 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
        GtkWidget* focus = gtk_window_get_focus (win);
        bool special_handling_of_unmodified_accelerators = false;
        bool allow_activating = true;
        GtkWidget* focus = gtk_window_get_focus (win);
        bool special_handling_of_unmodified_accelerators = false;
        bool allow_activating = true;
+       /* consider all relevant modifiers but not LOCK or SHIFT */
+       const guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
 
 
-#undef DEBUG_ACCELERATOR_HANDLING
-#ifdef  DEBUG_ACCELERATOR_HANDLING
-       //bool debug = (getenv ("ARDOUR_DEBUG_ACCELERATOR_HANDLING") != 0);
-       bool debug=true;
-#endif
        if (focus) {
                if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
                        special_handling_of_unmodified_accelerators = true;
        if (focus) {
                if (GTK_IS_ENTRY(focus) || Keyboard::some_magic_widget_has_focus()) {
                        special_handling_of_unmodified_accelerators = true;
-               } 
-       } 
+               }
+       }
 
 #ifdef GTKOSX
 
 #ifdef GTKOSX
-       /* should this be universally true? */
+        /* at one time this appeared to be necessary. As of July 2012, it does not
+           appear to be. if it ever is necessar, figure out if it should apply
+           to all platforms.
+        */
+#if 0 
        if (Keyboard::some_magic_widget_has_focus ()) {
        if (Keyboard::some_magic_widget_has_focus ()) {
-               allow_activating = false;
+                allow_activating = false;
        }
 #endif
        }
 #endif
-
-#ifdef DEBUG_ACCELERATOR_HANDLING
-       if (debug) {
-               cerr << "Win = " << win << " Key event: code = " << ev->keyval << " state = " << hex << ev->state << dec << " special handling ? " 
-                    << special_handling_of_unmodified_accelerators
-                    << " magic widget focus ? "
-                    << Keyboard::some_magic_widget_has_focus()
-                    << " allow_activation ? "
-                    << allow_activating
-                    << endl;
-       }
 #endif
 
 #endif
 
+
+        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",
+                                                          win,
+                                                          ev->keyval,
+                                                          ev->state,
+                                                          special_handling_of_unmodified_accelerators,
+                                                          Keyboard::some_magic_widget_has_focus(),
+                                                          allow_activating,
+                                                         focus));
+
        /* This exists to allow us to override the way GTK handles
           key events. The normal sequence is:
 
        /* This exists to allow us to override the way GTK handles
           key events. The normal sequence is:
 
@@ -533,18 +376,18 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
               the focus widget and/or focus chain
 
           The problem with this is that if the accelerators include
               the focus widget and/or focus chain
 
           The problem with this is that if the accelerators include
-          keys without modifiers, such as the space bar or the 
+          keys without modifiers, such as the space bar or the
           letter "e", then pressing the key while typing into
           a text entry widget results in the accelerator being
           activated, instead of the desired letter appearing
           in the text entry.
 
           There is no good way of fixing this, but this
           letter "e", then pressing the key while typing into
           a text entry widget results in the accelerator being
           activated, instead of the desired letter appearing
           in the text entry.
 
           There is no good way of fixing this, but this
-          represents a compromise. The idea is that 
+          represents a compromise. The idea is that
           key events involving modifiers (not Shift)
           get routed into the activation pathway first, then
           get propagated to the focus widget if necessary.
           key events involving modifiers (not Shift)
           get routed into the activation pathway first, then
           get propagated to the focus widget if necessary.
-          
+
           If the key event doesn't involve modifiers,
           we deliver to the focus widget first, thus allowing
           it to get "normal text" without interference
           If the key event doesn't involve modifiers,
           we deliver to the focus widget first, thus allowing
           it to get "normal text" without interference
@@ -555,126 +398,123 @@ key_press_focus_accelerator_handler (Gtk::Window& window, GdkEventKey* ev)
           all "normal text" accelerators.
        */
 
           all "normal text" accelerators.
        */
 
-
        if (!special_handling_of_unmodified_accelerators) {
 
        if (!special_handling_of_unmodified_accelerators) {
 
+               /* XXX note that for a brief moment, the conditional above
+                * included "|| (ev->state & mask)" so as to enforce the
+                * implication of special_handling_of_UNMODIFIED_accelerators.
+                * however, this forces any key that GTK doesn't allow and that
+                * we have an alternative (see next comment) for to be
+                * automatically sent through the accel groups activation
+                * pathway, which prevents individual widgets & canvas items
+                * from ever seeing it if is used by a key binding.
+                * 
+                * specifically, this hid Ctrl-down-arrow from MIDI region
+                * views because it is also bound to an action.
+                *
+                * until we have a robust, clean binding system, this
+                * quirk will have to remain in place.
+                */
+
                /* pretend that certain key events that GTK does not allow
                   to be used as accelerators are actually something that
                /* pretend that certain key events that GTK does not allow
                   to be used as accelerators are actually something that
-                  it does allow.
+                  it does allow. but only where there are no modifiers.
                */
 
                uint32_t fakekey = ev->keyval;
 
                */
 
                uint32_t fakekey = ev->keyval;
 
-               if (possibly_translate_keyval_to_make_legal_accelerator (fakekey)) {
-                       if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, GdkModifierType(ev->state))) {
-                               return true;
-                       }
+               if (Gtkmm2ext::possibly_translate_keyval_to_make_legal_accelerator (fakekey)) {
+                       DEBUG_TRACE (DEBUG::Accelerators, string_compose ("\tactivate (was %1 now %2) without special hanlding of unmodified accels\n",
+                                                                         ev->keyval, fakekey));
+
+                       GdkModifierType mod = GdkModifierType (ev->state);
 
 
+                       mod = GdkModifierType (mod & gtk_accelerator_get_default_mod_mask());
 #ifdef GTKOSX
 #ifdef GTKOSX
-                       if (allow_activating) {
-                               int oldval = ev->keyval;
-                               ev->keyval = fakekey;
-                               if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) {
-                                       return true;
-                               }
-                               ev->keyval = oldval;
+                       /* GTK on OS X is currently (February 2012) setting both
+                          the Meta and Mod2 bits in the event modifier state if 
+                          the Command key is down.
+
+                          gtk_accel_groups_activate() does not invoke any of the logic
+                          that gtk_window_activate_key() will that sorts out that stupid
+                          state of affairs, and as a result it fails to find a match
+                          for the key event and the current set of accelerators.
+
+                          to fix this, if the meta bit is set, remove the mod2 bit
+                          from the modifier. this assumes that our bindings use Primary
+                          which will have set the meta bit in the accelerator entry.
+                       */
+                       if (mod & GDK_META_MASK) {
+                               mod = GdkModifierType (mod & ~GDK_MOD2_MASK);
                        }
 #endif
                        }
 #endif
+
+                       if (allow_activating && gtk_accel_groups_activate(G_OBJECT(win), fakekey, mod)) {
+                               DEBUG_TRACE (DEBUG::Accelerators, "\taccel group activated by fakekey\n");
+                               return true;
+                       }
                }
        }
 
                }
        }
 
-       /* consider all relevant modifiers but not LOCK or SHIFT */
-
-       guint mask = (Keyboard::RelevantModifierKeyMask & ~(Gdk::SHIFT_MASK|Gdk::LOCK_MASK));
-
        if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
 
                /* no special handling or there are modifiers in effect: accelerate first */
 
        if (!special_handling_of_unmodified_accelerators || (ev->state & mask)) {
 
                /* no special handling or there are modifiers in effect: accelerate first */
 
-#ifdef DEBUG_ACCELERATOR_HANDLING
-               if (debug) {
-                       cerr << "\tactivate, then propagate\n";
-               }
-#endif
+                DEBUG_TRACE (DEBUG::Accelerators, "\tactivate, then propagate\n");
 
                if (allow_activating) {
 
                if (allow_activating) {
-#ifdef GTKOSX
-                       if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) {
-                               return true;
-                       }
-#endif
+                       DEBUG_TRACE (DEBUG::Accelerators, "\tsending to window\n");
                        if (gtk_window_activate_key (win, ev)) {
                        if (gtk_window_activate_key (win, ev)) {
+                               DEBUG_TRACE (DEBUG::Accelerators, "\t\thandled\n");
                                return true;
                        }
                                return true;
                        }
+               } else {
+                       DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
                }
 
                }
 
-#ifdef DEBUG_ACCELERATOR_HANDLING
-               if (debug) {
-                       cerr << "\tnot accelerated, now propagate\n";
-               }
-#endif
+                DEBUG_TRACE (DEBUG::Accelerators, "\tnot accelerated, now propagate\n");
+
                return gtk_window_propagate_key_event (win, ev);
        }
                return gtk_window_propagate_key_event (win, ev);
        }
-       
+
        /* no modifiers, propagate first */
        /* no modifiers, propagate first */
-       
-#ifdef DEBUG_ACCELERATOR_HANDLING
-       if (debug) {
-               cerr << "\tpropagate, then activate\n";
-       }
-#endif
-       if (!gtk_window_propagate_key_event (win, ev)) {
-#ifdef DEBUG_ACCELERATOR_HANDLING
-               if (debug) {
-                       cerr << "\tpropagation didn't handle, so activate\n";
-               }
-#endif
 
 
+        DEBUG_TRACE (DEBUG::Accelerators, "\tpropagate, then activate\n");
+
+       if (!gtk_window_propagate_key_event (win, ev)) {
+                DEBUG_TRACE (DEBUG::Accelerators, "\tpropagation didn't handle, so activate\n");
                if (allow_activating) {
                if (allow_activating) {
-                       
-#ifdef GTKOSX
-                       if (gdk_quartz_possibly_forward ((GdkEvent*) ev)) {
-                               return true;
-                       }
-#endif
                        return gtk_window_activate_key (win, ev);
                        return gtk_window_activate_key (win, ev);
-               } 
-                       
-       } else {
-#ifdef DEBUG_ACCELERATOR_HANDLING
-               if (debug) {
-                       cerr << "\thandled by propagate\n";
+               } else {
+                       DEBUG_TRACE (DEBUG::Accelerators, "\tactivation skipped\n");
                }
                }
-#endif
+
+       } else {
+                DEBUG_TRACE (DEBUG::Accelerators, "\thandled by propagate\n");
                return true;
        }
 
                return true;
        }
 
-#ifdef DEBUG_ACCELERATOR_HANDLING
-       if (debug) {
-               cerr << "\tnot handled\n";
-       }
-#endif
+        DEBUG_TRACE (DEBUG::Accelerators, "\tnot handled\n");
        return true;
 }
 
        return true;
 }
 
-Glib::RefPtr<Gdk::Pixbuf>      
+Glib::RefPtr<Gdk::Pixbuf>
 get_xpm (std::string name)
 {
        if (!xpm_map[name]) {
 
 get_xpm (std::string name)
 {
        if (!xpm_map[name]) {
 
-               SearchPath spath(ARDOUR::ardour_search_path());
-               spath += ARDOUR::system_data_search_path();
-               
+               SearchPath spath(ARDOUR::ardour_data_search_path());
+
                spath.add_subdirectory_to_paths("pixmaps");
                spath.add_subdirectory_to_paths("pixmaps");
-               
-               sys::path data_file_path;
-               
+
+               std::string data_file_path;
+
                if(!find_file_in_search_path (spath, name, data_file_path)) {
                        fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg;
                }
                if(!find_file_in_search_path (spath, name, data_file_path)) {
                        fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg;
                }
-               
+
                try {
                try {
-                       xpm_map[name] =  Gdk::Pixbuf::create_from_file (data_file_path.to_string());
+                       xpm_map[name] =  Gdk::Pixbuf::create_from_file (data_file_path);
                } catch(const Glib::Error& e)   {
                        warning << "Caught Glib::Error: " << e.what() << endmsg;
                }
                } catch(const Glib::Error& e)   {
                        warning << "Caught Glib::Error: " << e.what() << endmsg;
                }
@@ -683,31 +523,35 @@ get_xpm (std::string name)
        return xpm_map[name];
 }
 
        return xpm_map[name];
 }
 
-
-Glib::RefPtr<Gdk::Pixbuf>      
-get_icon (const char* cname)
+std::string
+get_icon_path (const char* cname)
 {
        string name = cname;
        name += X_(".png");
 
 {
        string name = cname;
        name += X_(".png");
 
-       SearchPath spath(ARDOUR::ardour_search_path());
-       spath += ARDOUR::system_data_search_path();
+       SearchPath spath(ARDOUR::ardour_data_search_path());
 
        spath.add_subdirectory_to_paths("icons");
 
 
        spath.add_subdirectory_to_paths("icons");
 
-       sys::path data_file_path;
+       std::string data_file_path;
 
        if (!find_file_in_search_path (spath, name, data_file_path)) {
 
        if (!find_file_in_search_path (spath, name, data_file_path)) {
-               fatal << string_compose (_("cannot find icon image for %1"), name) << endmsg;
+               fatal << string_compose (_("cannot find icon image for %1 using %2"), name, spath.to_string()) << endmsg;
        }
 
        }
 
+       return data_file_path;
+}
+
+Glib::RefPtr<Gdk::Pixbuf>
+get_icon (const char* cname)
+{
        Glib::RefPtr<Gdk::Pixbuf> img;
        try {
        Glib::RefPtr<Gdk::Pixbuf> img;
        try {
-               img = Gdk::Pixbuf::create_from_file (data_file_path.to_string());
+               img = Gdk::Pixbuf::create_from_file (get_icon_path (cname));
        } catch (const Gdk::PixbufError &e) {
                cerr << "Caught PixbufError: " << e.what() << endl;
        } catch (...) {
        } catch (const Gdk::PixbufError &e) {
                cerr << "Caught PixbufError: " << e.what() << endl;
        } catch (...) {
-               g_message("Caught ... ");
+               error << string_compose (_("Caught exception while loading icon named %1"), cname) << endmsg;
        }
 
        return img;
        }
 
        return img;
@@ -722,33 +566,70 @@ longest (vector<string>& strings)
 
        vector<string>::iterator longest = strings.begin();
        string::size_type longest_length = (*longest).length();
 
        vector<string>::iterator longest = strings.begin();
        string::size_type longest_length = (*longest).length();
-       
+
        vector<string>::iterator i = longest;
        ++i;
 
        while (i != strings.end()) {
        vector<string>::iterator i = longest;
        ++i;
 
        while (i != strings.end()) {
-               
+
                string::size_type len = (*i).length();
                string::size_type len = (*i).length();
-               
+
                if (len > longest_length) {
                        longest = i;
                        longest_length = len;
                if (len > longest_length) {
                        longest = i;
                        longest_length = len;
-               } 
-               
+               }
+
                ++i;
        }
                ++i;
        }
-       
+
        return *longest;
 }
 
 bool
 key_is_legal_for_numeric_entry (guint keyval)
 {
        return *longest;
 }
 
 bool
 key_is_legal_for_numeric_entry (guint keyval)
 {
+       /* we assume that this does not change over the life of the process 
+        */
+
+       static int comma_decimal = -1;
+
        switch (keyval) {
        switch (keyval) {
-       case GDK_minus:
-       case GDK_plus:
        case GDK_period:
        case GDK_comma:
        case GDK_period:
        case GDK_comma:
+               if (comma_decimal < 0) {
+                       std::lconv* lc = std::localeconv();
+                       if (strchr (lc->decimal_point, ',') != 0) {
+                               comma_decimal = 1;
+                       } else {
+                               comma_decimal = 0;
+                       }
+               }
+               break;
+       default:
+               break;
+       }
+
+       switch (keyval) {
+       case GDK_decimalpoint:
+       case GDK_KP_Separator:
+               return true;
+
+       case GDK_period:
+               if (comma_decimal) {
+                       return false;
+               } else {
+                       return true;
+               }
+               break;
+       case GDK_comma:
+               if (comma_decimal) {
+                       return true;
+               } else {
+                       return false;
+               }
+               break;
+       case GDK_minus:
+       case GDK_plus:
        case GDK_0:
        case GDK_1:
        case GDK_2:
        case GDK_0:
        case GDK_1:
        case GDK_2:
@@ -781,7 +662,7 @@ key_is_legal_for_numeric_entry (guint keyval)
        case GDK_Left:
        case GDK_Right:
                return true;
        case GDK_Left:
        case GDK_Right:
                return true;
-               
+
        default:
                break;
        }
        default:
                break;
        }
@@ -795,10 +676,10 @@ set_pango_fontsize ()
 
        /* FT2 rendering - used by GnomeCanvas, sigh */
 
 
        /* FT2 rendering - used by GnomeCanvas, sigh */
 
-       pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_for_display(), val/1024, val/1024);
+       pango_ft2_font_map_set_resolution ((PangoFT2FontMap*) pango_ft2_font_map_new(), val/1024, val/1024);
 
        /* Cairo rendering, in case there is any */
 
        /* Cairo rendering, in case there is any */
-       
+
        pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) pango_cairo_font_map_get_default(), val/1024);
 }
 
        pango_cairo_font_map_set_resolution ((PangoCairoFontMap*) pango_cairo_font_map_get_default(), val/1024);
 }
 
@@ -814,74 +695,84 @@ reset_dpi ()
        DPIReset();//Emit Signal
 }
 
        DPIReset();//Emit Signal
 }
 
-bool
-possibly_translate_keyval_to_make_legal_accelerator (uint32_t& keyval)
+void
+resize_window_to_proportion_of_monitor (Gtk::Window* window, int max_width, int max_height)
 {
 {
-       int fakekey = GDK_VoidSymbol;
+       Glib::RefPtr<Gdk::Screen> screen = window->get_screen ();
+       Gdk::Rectangle monitor_rect;
+       screen->get_monitor_geometry (0, monitor_rect);
 
 
-       switch (keyval) {
-       case GDK_Tab:
-       case GDK_ISO_Left_Tab:
-               fakekey = GDK_nabla;
-               break;
-               
-       case GDK_Up:
-               fakekey = GDK_uparrow;
-               break;
-               
-       case GDK_Down:
-               fakekey = GDK_downarrow;
-               break;
-               
-       case GDK_Right:
-               fakekey = GDK_rightarrow;
-               break;
-               
-       case GDK_Left:
-               fakekey = GDK_leftarrow;
-               break;
-               
-       default:
-               break;
+       int const w = std::min (int (monitor_rect.get_width() * 0.8), max_width);
+       int const h = std::min (int (monitor_rect.get_height() * 0.8), max_height);
+
+       window->resize (w, h);
+}
+
+
+/** Replace _ with __ in a string; for use with menu item text to make underscores displayed correctly */
+string
+escape_underscores (string const & s)
+{
+       string o;
+       string::size_type const N = s.length ();
+
+       for (string::size_type i = 0; i < N; ++i) {
+               if (s[i] == '_') {
+                       o += "__";
+               } else {
+                       o += s[i];
+               }
        }
        }
-       
-       if (fakekey != GDK_VoidSymbol) {
-               keyval = fakekey;
-               return true;
-       } 
 
 
-       return false;
+       return o;
 }
 }
-               
 
 
-inline guint8
-convert_color_channel (guint8 src,
-                      guint8 alpha)
+/** Replace < and > with &lt; and &gt; respectively to make < > display correctly in markup strings */
+string
+escape_angled_brackets (string const & s)
 {
 {
-       return alpha ? ((guint (src) << 8) - src) / alpha : 0;
+       string o = s;
+       boost::replace_all (o, "<", "&lt;");
+       boost::replace_all (o, ">", "&gt;");
+       return o;
 }
 
 }
 
-void
-convert_bgra_to_rgba (guint8 const* src,
-                     guint8*       dst,
-                     int           width,
-                     int           height)
+Gdk::Color
+unique_random_color (list<Gdk::Color>& used_colors)
 {
 {
-       guint8 const* src_pixel = src;
-       guint8*       dst_pixel = dst;
-       
-       for (int y = 0; y < height; y++)
-               for (int x = 0; x < width; x++)
-               {
-                       dst_pixel[0] = convert_color_channel (src_pixel[2],
-                                                             src_pixel[3]);
-                       dst_pixel[1] = convert_color_channel (src_pixel[1],
-                                                             src_pixel[3]);
-                       dst_pixel[2] = convert_color_channel (src_pixel[0],
-                                                             src_pixel[3]);
-                       dst_pixel[3] = src_pixel[3];
-                       
-                       dst_pixel += 4;
-                       src_pixel += 4;
+       Gdk::Color newcolor;
+
+       while (1) {
+
+               /* avoid neon/glowing tones by limiting them to the
+                  "inner section" (paler) of a color wheel/circle.
+               */
+
+               const int32_t max_saturation = 48000; // 65535 would open up the whole color wheel
+
+               newcolor.set_red (random() % max_saturation);
+               newcolor.set_blue (random() % max_saturation);
+               newcolor.set_green (random() % max_saturation);
+
+               if (used_colors.size() == 0) {
+                       used_colors.push_back (newcolor);
+                       return newcolor;
                }
                }
+
+               for (list<Gdk::Color>::iterator i = used_colors.begin(); i != used_colors.end(); ++i) {
+                 Gdk::Color c = *i;
+                       float rdelta, bdelta, gdelta;
+
+                       rdelta = newcolor.get_red() - c.get_red();
+                       bdelta = newcolor.get_blue() - c.get_blue();
+                       gdelta = newcolor.get_green() - c.get_green();
+
+                       if (sqrt (rdelta*rdelta + bdelta*bdelta + gdelta*gdelta) > 25.0) {
+                               used_colors.push_back (newcolor);
+                               return newcolor;
+                       }
+               }
+
+               /* XXX need throttle here to make sure we don't spin for ever */
+       }
 }
 }
Unnamed repository; edit this file 'description' to name the repository.