freetype on macOS does not scale fonts, font-scale and ui_scale have to remain at 100% otherwise other UI elements change size while the font does not.
1087 lines
26 KiB
C++
1087 lines
26 KiB
C++
/*
|
|
* Copyright (C) 2005-2006 Taybin Rutkin <taybin@taybin.com>
|
|
* Copyright (C) 2005-2009 Nick Mainsbridge <mainsbridge@gmail.com>
|
|
* Copyright (C) 2005-2018 Paul Davis <paul@linuxaudiosystems.com>
|
|
* Copyright (C) 2005 Karsten Wiese <fzuuzf@googlemail.com>
|
|
* Copyright (C) 2006-2007 Doug McLain <doug@nostar.net>
|
|
* Copyright (C) 2006-2009 Sampo Savolainen <v2@iki.fi>
|
|
* Copyright (C) 2007-2015 David Robillard <d@drobilla.net>
|
|
* Copyright (C) 2007-2015 Tim Mayberry <mojofunk@gmail.com>
|
|
* Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
|
|
* Copyright (C) 2013-2019 Robin Gareus <robin@gareus.org>
|
|
* Copyright (C) 2013 John Emmas <john@creativepost.co.uk>
|
|
* Copyright (C) 2015 André Nusser <andre.nusser@googlemail.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#ifdef WAF_BUILD
|
|
#include "gtk2ardour-config.h"
|
|
#endif
|
|
|
|
#include <cctype>
|
|
#include <clocale>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <list>
|
|
#include <sys/stat.h>
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
#include <gtk/gtkpaned.h>
|
|
#include <gtkmm/combo.h>
|
|
#include <gtkmm/label.h>
|
|
#include <gtkmm/paned.h>
|
|
#include <gtkmm/rc.h>
|
|
#include <gtkmm/stock.h>
|
|
#include <gtkmm/window.h>
|
|
|
|
#include "pbd/basename.h"
|
|
#include "pbd/file_utils.h"
|
|
|
|
#include "ardour/audioengine.h"
|
|
#include "ardour/auditioner.h"
|
|
#include "ardour/filesystem_paths.h"
|
|
#include "ardour/search_paths.h"
|
|
#include "ardour/session.h"
|
|
#include "ardour/triggerbox.h"
|
|
|
|
#include "gtkmm2ext/colors.h"
|
|
#include "gtkmm2ext/utils.h"
|
|
|
|
#include "canvas/item.h"
|
|
|
|
#include "actions.h"
|
|
#include "ardour_dialog.h"
|
|
#include "ardour_ui.h"
|
|
#include "context_menu_helper.h"
|
|
#include "debug.h"
|
|
#include "gui_thread.h"
|
|
#include "keyboard.h"
|
|
#include "main_clock.h"
|
|
#include "public_editor.h"
|
|
#include "ui_config.h"
|
|
#include "utils.h"
|
|
|
|
#include "pbd/i18n.h"
|
|
|
|
using namespace std;
|
|
using namespace Gtk;
|
|
using namespace Glib;
|
|
using namespace PBD;
|
|
using Gtkmm2ext::Keyboard;
|
|
|
|
namespace ARDOUR_UI_UTILS
|
|
{
|
|
sigc::signal<void> DPIReset;
|
|
}
|
|
|
|
#ifdef PLATFORM_WINDOWS
|
|
#define random() rand ()
|
|
#endif
|
|
|
|
/** 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
|
|
ARDOUR_UI_UTILS::add_item_with_sensitivity (Menu_Helpers::MenuList& m, Menu_Helpers::MenuElem e, bool s)
|
|
{
|
|
m.push_back (e);
|
|
if (!s) {
|
|
m.back ().set_sensitive (false);
|
|
}
|
|
}
|
|
|
|
gint
|
|
ARDOUR_UI_UTILS::just_hide_it (GdkEventAny* /*ev*/, Gtk::Window* win)
|
|
{
|
|
win->hide ();
|
|
return 0;
|
|
}
|
|
|
|
static bool
|
|
idle_notify_engine_stopped ()
|
|
{
|
|
Glib::RefPtr<ToggleAction> tact = ActionManager::get_toggle_action ("Window", "toggle-audio-midi-setup");
|
|
|
|
MessageDialog msg (
|
|
_("The current operation is not possible because of an error communicating with the audio hardware."),
|
|
false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE, true);
|
|
|
|
msg.add_button (_("Cancel"), Gtk::RESPONSE_CANCEL);
|
|
|
|
if (tact && !tact->get_active ()) {
|
|
msg.add_button (_("Configure Hardware"), Gtk::RESPONSE_OK);
|
|
}
|
|
|
|
if (msg.run () == Gtk::RESPONSE_OK) {
|
|
tact->set_active ();
|
|
}
|
|
return false; /* do not call again */
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::engine_is_running ()
|
|
{
|
|
if (ARDOUR::AudioEngine::instance ()->running ()) {
|
|
return true;
|
|
}
|
|
Glib::signal_idle ().connect (sigc::ptr_fun (&idle_notify_engine_stopped));
|
|
return false;
|
|
}
|
|
|
|
/* xpm2rgb copied from nixieclock, which bore the legend:
|
|
|
|
nixieclock - a nixie desktop timepiece
|
|
Copyright (C) 2000 Greg Ercolano, erco@3dsite.com
|
|
|
|
and was released under the GPL.
|
|
*/
|
|
|
|
unsigned char*
|
|
ARDOUR_UI_UTILS::xpm2rgb (const char** xpm, uint32_t& w, uint32_t& h)
|
|
{
|
|
static long vals[256], val;
|
|
uint32_t t, x, y, colors, cpp;
|
|
unsigned char c;
|
|
unsigned char *savergb, *rgb;
|
|
|
|
// 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;
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// COLORMAP -> RGB CONVERSION
|
|
// Get low 3 bytes from vals[]
|
|
//
|
|
|
|
const char* p;
|
|
for (y = h - 1; y > 0; --y) {
|
|
for (p = xpm[1 + colors + (h - y - 1)], x = 0; x < w; x++, rgb += 3) {
|
|
val = vals[(int)*p++];
|
|
*(rgb + 2) = val & 0xff;
|
|
val >>= 8; // 2:B
|
|
*(rgb + 1) = val & 0xff;
|
|
val >>= 8; // 1:G
|
|
*(rgb + 0) = val & 0xff; // 0:R
|
|
}
|
|
}
|
|
|
|
return (savergb);
|
|
}
|
|
|
|
unsigned char*
|
|
ARDOUR_UI_UTILS::xpm2rgba (const char** xpm, uint32_t& w, uint32_t& h)
|
|
{
|
|
static long vals[256], val;
|
|
uint32_t t, x, y, colors, cpp;
|
|
unsigned char c;
|
|
unsigned char *savergb, *rgb;
|
|
char transparent;
|
|
|
|
// 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;
|
|
return 0;
|
|
}
|
|
|
|
savergb = rgb = (unsigned char*)malloc (h * w * 4);
|
|
|
|
// LOAD XPM COLORMAP LONG ENOUGH TO DO CONVERSION
|
|
|
|
if (strstr (xpm[1], "None")) {
|
|
sscanf (xpm[1], "%c", &transparent);
|
|
t = 1;
|
|
} else {
|
|
transparent = 0;
|
|
t = 0;
|
|
}
|
|
|
|
for (; t < colors; ++t) {
|
|
sscanf (xpm[t + 1], "%c c #%lx", &c, &val);
|
|
vals[c] = val;
|
|
}
|
|
|
|
// COLORMAP -> RGB CONVERSION
|
|
// Get low 3 bytes from vals[]
|
|
//
|
|
|
|
const char* p;
|
|
for (y = h - 1; y > 0; --y) {
|
|
char alpha;
|
|
|
|
for (p = xpm[1 + colors + (h - y - 1)], x = 0; x < w; x++, rgb += 4) {
|
|
if (transparent && (*p++ == transparent)) {
|
|
alpha = 0;
|
|
val = 0;
|
|
} else {
|
|
alpha = 0xff;
|
|
val = vals[(int)*p];
|
|
}
|
|
|
|
*(rgb + 3) = alpha; // 3: alpha
|
|
*(rgb + 2) = val & 0xff;
|
|
val >>= 8; // 2:B
|
|
*(rgb + 1) = val & 0xff;
|
|
val >>= 8; // 1:G
|
|
*(rgb + 0) = val & 0xff; // 0:R
|
|
}
|
|
}
|
|
|
|
return (savergb);
|
|
}
|
|
|
|
/** Returns a Pango::FontDescription given a string describing the font.
|
|
*
|
|
* If the returned FontDescription does not specify a family, then
|
|
* the family is set to "Sans". This mirrors GTK's behaviour in
|
|
* gtkstyle.c.
|
|
*
|
|
* Some environments will force Pango to specify the family
|
|
* even if it was not specified in the string describing the font.
|
|
* Such environments should be left unaffected by this function,
|
|
* since the font family will be left alone.
|
|
*
|
|
* There may be other similar font specification enforcement
|
|
* that we might add here later.
|
|
*/
|
|
Pango::FontDescription
|
|
ARDOUR_UI_UTILS::sanitized_font (std::string const& name)
|
|
{
|
|
Pango::FontDescription fd (name);
|
|
|
|
if (fd.get_family ().empty ()) {
|
|
/* default: "Sans" or "ArdourSans" */
|
|
fd.set_family (UIConfiguration::instance ().get_ui_font_family ());
|
|
}
|
|
|
|
return fd;
|
|
}
|
|
|
|
Pango::FontDescription
|
|
ARDOUR_UI_UTILS::ardour_font (std::string const& name)
|
|
{
|
|
Pango::FontDescription fd (name);
|
|
if (!fd.get_family ().empty () && fd.get_family ().find ("Mon") != std::string::npos) {
|
|
/* matches "ArdourMono", "Monaco" */
|
|
fd.set_family ("ArdourMono");
|
|
} else {
|
|
fd.set_family ("ArdourSans");
|
|
}
|
|
|
|
return fd;
|
|
}
|
|
|
|
Pango::FontDescription
|
|
ARDOUR_UI_UTILS::get_font_for_style (string widgetname)
|
|
{
|
|
Gtk::Window window (WINDOW_TOPLEVEL);
|
|
Gtk::Label foobar;
|
|
Glib::RefPtr<Gtk::Style> style;
|
|
|
|
window.add (foobar);
|
|
foobar.set_name (widgetname);
|
|
foobar.ensure_style ();
|
|
|
|
style = foobar.get_style ();
|
|
|
|
Glib::RefPtr<const Pango::Layout> layout = foobar.get_layout ();
|
|
|
|
PangoFontDescription* pfd = const_cast<PangoFontDescription*> (pango_layout_get_font_description (const_cast<PangoLayout*> (layout->gobj ())));
|
|
|
|
if (!pfd) {
|
|
/* layout inherited its font description from a PangoContext */
|
|
|
|
PangoContext* ctxt = (PangoContext*)pango_layout_get_context (const_cast<PangoLayout*> (layout->gobj ()));
|
|
pfd = pango_context_get_font_description (ctxt);
|
|
return Pango::FontDescription (pfd); /* make a copy */
|
|
}
|
|
|
|
return Pango::FontDescription (pfd); /* make a copy */
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::relay_key_press (GdkEventKey* ev, Gtk::Window* win)
|
|
{
|
|
return ARDOUR_UI::instance ()->key_event_handler (ev, win);
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::emulate_key_event (unsigned int keyval)
|
|
{
|
|
GdkDisplay* display = gtk_widget_get_display (GTK_WIDGET (ARDOUR_UI::instance ()->main_window ().gobj ()));
|
|
GdkKeymap* keymap = gdk_keymap_get_for_display (display);
|
|
GdkKeymapKey* keymapkey = NULL;
|
|
gint n_keys;
|
|
|
|
if (!gdk_keymap_get_entries_for_keyval (keymap, keyval, &keymapkey, &n_keys))
|
|
return false;
|
|
if (n_keys != 1) {
|
|
g_free (keymapkey);
|
|
return false;
|
|
}
|
|
|
|
Gtk::Window& main_window (ARDOUR_UI::instance ()->main_window ());
|
|
|
|
GdkEventKey ev;
|
|
ev.type = GDK_KEY_PRESS;
|
|
ev.window = main_window.get_window ()->gobj ();
|
|
ev.send_event = FALSE;
|
|
ev.time = 0;
|
|
ev.state = 0;
|
|
ev.keyval = keyval;
|
|
ev.length = 0;
|
|
ev.string = const_cast<gchar*> ("");
|
|
ev.hardware_keycode = keymapkey[0].keycode;
|
|
ev.group = keymapkey[0].group;
|
|
g_free (keymapkey);
|
|
|
|
relay_key_press (&ev, &main_window);
|
|
ev.type = GDK_KEY_RELEASE;
|
|
return relay_key_press (&ev, &main_window);
|
|
}
|
|
|
|
Glib::RefPtr<Gdk::Pixbuf>
|
|
ARDOUR_UI_UTILS::get_xpm (std::string name)
|
|
{
|
|
if (!xpm_map[name]) {
|
|
Searchpath spath (ARDOUR::ardour_data_search_path ());
|
|
|
|
spath.add_subdirectory_to_paths ("pixmaps");
|
|
|
|
std::string data_file_path;
|
|
|
|
if (!find_file (spath, name, data_file_path)) {
|
|
fatal << string_compose (_("cannot find XPM file for %1"), name) << endmsg;
|
|
}
|
|
|
|
try {
|
|
xpm_map[name] = Gdk::Pixbuf::create_from_file (data_file_path);
|
|
} catch (const Glib::Error& e) {
|
|
warning << "Caught Glib::Error: " << e.what () << endmsg;
|
|
}
|
|
}
|
|
|
|
return xpm_map[name];
|
|
}
|
|
|
|
void
|
|
ARDOUR_UI_UTILS::get_color_themes (map<std::string, std::string>& themes)
|
|
{
|
|
Searchpath spath (ARDOUR::theme_search_path ());
|
|
|
|
for (vector<string>::iterator s = spath.begin (); s != spath.end (); ++s) {
|
|
vector<string> entries;
|
|
|
|
find_files_matching_pattern (entries, *s, string ("*") + UIConfiguration::color_file_suffix);
|
|
|
|
for (vector<string>::iterator e = entries.begin (); e != entries.end (); ++e) {
|
|
XMLTree tree;
|
|
|
|
tree.read ((*e).c_str ());
|
|
XMLNode* root = tree.root ();
|
|
|
|
if (!root || root->name () != X_("Ardour")) {
|
|
continue;
|
|
}
|
|
|
|
XMLProperty const* prop = root->property (X_("theme-name"));
|
|
|
|
if (!prop) {
|
|
continue;
|
|
}
|
|
|
|
std::string color_name = basename_nosuffix (*e);
|
|
size_t sep = color_name.find_first_of ("-");
|
|
if (sep != string::npos) {
|
|
color_name = color_name.substr (0, sep);
|
|
}
|
|
themes.insert (make_pair (prop->value (), color_name));
|
|
}
|
|
}
|
|
}
|
|
|
|
vector<string>
|
|
ARDOUR_UI_UTILS::get_icon_sets ()
|
|
{
|
|
Searchpath spath (ARDOUR::ardour_data_search_path ());
|
|
spath.add_subdirectory_to_paths ("icons");
|
|
vector<string> r;
|
|
|
|
r.push_back (_("default"));
|
|
|
|
for (vector<string>::iterator s = spath.begin (); s != spath.end (); ++s) {
|
|
vector<string> entries;
|
|
|
|
get_paths (entries, *s, false, false);
|
|
|
|
for (vector<string>::iterator e = entries.begin (); e != entries.end (); ++e) {
|
|
if (Glib::file_test (*e, Glib::FILE_TEST_IS_DIR)) {
|
|
r.push_back (Glib::filename_to_utf8 (Glib::path_get_basename (*e)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
std::string
|
|
ARDOUR_UI_UTILS::get_icon_path (const char* cname, string icon_set, bool is_image)
|
|
{
|
|
std::string data_file_path;
|
|
string name = cname;
|
|
|
|
if (is_image) {
|
|
name += X_(".png");
|
|
}
|
|
|
|
Searchpath spath (ARDOUR::ardour_data_search_path ());
|
|
|
|
if (!icon_set.empty () && icon_set != _("default")) {
|
|
/* add "icons/icon_set" but .. not allowed to add both of these at once */
|
|
spath.add_subdirectory_to_paths ("icons");
|
|
spath.add_subdirectory_to_paths (icon_set);
|
|
|
|
find_file (spath, name, data_file_path);
|
|
} else {
|
|
spath.add_subdirectory_to_paths ("icons");
|
|
find_file (spath, name, data_file_path);
|
|
}
|
|
|
|
if (data_file_path.empty ()) {
|
|
Searchpath rc (ARDOUR::ardour_data_search_path ());
|
|
rc.add_subdirectory_to_paths ("resources");
|
|
find_file (rc, name, data_file_path);
|
|
}
|
|
|
|
if (is_image && data_file_path.empty ()) {
|
|
if (!icon_set.empty () && icon_set != _("default")) {
|
|
warning << string_compose (_("icon \"%1\" not found for icon set \"%2\", fallback to default"), cname, icon_set) << endmsg;
|
|
}
|
|
|
|
Searchpath def (ARDOUR::ardour_data_search_path ());
|
|
def.add_subdirectory_to_paths ("icons");
|
|
|
|
if (!find_file (def, name, data_file_path)) {
|
|
fatal << string_compose (_("cannot find icon image for %1 using %2"), name, spath.to_string ()) << endmsg;
|
|
abort (); /*NOTREACHED*/
|
|
}
|
|
}
|
|
|
|
return data_file_path;
|
|
}
|
|
|
|
Glib::RefPtr<Gdk::Pixbuf>
|
|
ARDOUR_UI_UTILS::get_icon (const char* cname, string icon_set)
|
|
{
|
|
Glib::RefPtr<Gdk::Pixbuf> img;
|
|
try {
|
|
img = Gdk::Pixbuf::create_from_file (get_icon_path (cname, icon_set));
|
|
} catch (const Gdk::PixbufError& e) {
|
|
cerr << "Caught PixbufError: " << e.what () << endl;
|
|
} catch (...) {
|
|
error << string_compose (_("Caught exception while loading icon named %1"), cname) << endmsg;
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
namespace ARDOUR_UI_UTILS
|
|
{
|
|
Glib::RefPtr<Gdk::Pixbuf>
|
|
get_icon (const char* cname)
|
|
{
|
|
Glib::RefPtr<Gdk::Pixbuf> img;
|
|
try {
|
|
img = Gdk::Pixbuf::create_from_file (get_icon_path (cname));
|
|
} catch (const Gdk::PixbufError& e) {
|
|
cerr << "Caught PixbufError: " << e.what () << endl;
|
|
} catch (...) {
|
|
error << string_compose (_("Caught exception while loading icon named %1"), cname) << endmsg;
|
|
}
|
|
|
|
return img;
|
|
}
|
|
} // namespace ARDOUR_UI_UTILS
|
|
|
|
string
|
|
ARDOUR_UI_UTILS::longest (vector<string>& strings)
|
|
{
|
|
if (strings.empty ()) {
|
|
return string ("");
|
|
}
|
|
|
|
vector<string>::iterator longest = strings.begin ();
|
|
string::size_type longest_length = (*longest).length ();
|
|
|
|
vector<string>::iterator i = longest;
|
|
++i;
|
|
|
|
while (i != strings.end ()) {
|
|
string::size_type len = (*i).length ();
|
|
|
|
if (len > longest_length) {
|
|
longest = i;
|
|
longest_length = len;
|
|
}
|
|
|
|
++i;
|
|
}
|
|
|
|
return *longest;
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::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) {
|
|
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_3:
|
|
case GDK_4:
|
|
case GDK_5:
|
|
case GDK_6:
|
|
case GDK_7:
|
|
case GDK_8:
|
|
case GDK_9:
|
|
case GDK_KP_Add:
|
|
case GDK_KP_Subtract:
|
|
case GDK_KP_Decimal:
|
|
case GDK_KP_0:
|
|
case GDK_KP_1:
|
|
case GDK_KP_2:
|
|
case GDK_KP_3:
|
|
case GDK_KP_4:
|
|
case GDK_KP_5:
|
|
case GDK_KP_6:
|
|
case GDK_KP_7:
|
|
case GDK_KP_8:
|
|
case GDK_KP_9:
|
|
case GDK_Return:
|
|
case GDK_BackSpace:
|
|
case GDK_Delete:
|
|
case GDK_KP_Enter:
|
|
case GDK_Home:
|
|
case GDK_End:
|
|
case GDK_Left:
|
|
case GDK_Right:
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int
|
|
ARDOUR_UI_UTILS::guess_default_ui_scale ()
|
|
{
|
|
#ifdef __APPLE__
|
|
return 100;
|
|
#else
|
|
gint width = 0;
|
|
gint height = 0;
|
|
GdkScreen* screen = gdk_display_get_screen (gdk_display_get_default (), 0);
|
|
gint n_monitors = gdk_screen_get_n_monitors (screen);
|
|
|
|
if (!screen) {
|
|
return 100;
|
|
}
|
|
|
|
for (gint i = 0; i < n_monitors; ++i) {
|
|
GdkRectangle rect;
|
|
gdk_screen_get_monitor_geometry (screen, i, &rect);
|
|
width = std::max (width, rect.width);
|
|
height = std::max (height, rect.height);
|
|
}
|
|
|
|
float wx = width / 1920.f;
|
|
float hx = height / 1080.f;
|
|
float sx = std::min (wx, hx);
|
|
|
|
if (sx < 1.25) {
|
|
return 100;
|
|
} else if (sx < 1.6) {
|
|
return 150;
|
|
} else if (sx < 2.1) {
|
|
return 200;
|
|
} else {
|
|
return 250;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void
|
|
ARDOUR_UI_UTILS::resize_window_to_proportion_of_monitor (Gtk::Window* window, int max_width, int max_height)
|
|
{
|
|
Glib::RefPtr<Gdk::Screen> screen = window->get_screen ();
|
|
Gdk::Rectangle monitor_rect;
|
|
screen->get_monitor_geometry (0, monitor_rect);
|
|
|
|
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
|
|
ARDOUR_UI_UTILS::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];
|
|
}
|
|
}
|
|
|
|
return o;
|
|
}
|
|
|
|
Gdk::Color
|
|
ARDOUR_UI_UTILS::round_robin_palette_color ()
|
|
{
|
|
Gdk::Color newcolor;
|
|
string cp = UIConfiguration::instance ().get_stripable_color_palette ();
|
|
Gdk::ArrayHandle_Color gc = ColorSelection::palette_from_string (cp);
|
|
std::vector<Gdk::Color> c (gc);
|
|
static std::vector<Gdk::Color>::size_type index = 0;
|
|
|
|
if (index >= c.size ()) {
|
|
index = 0;
|
|
}
|
|
|
|
return c[index++];
|
|
}
|
|
|
|
Gdk::Color
|
|
ARDOUR_UI_UTILS::unique_random_color (list<Gdk::Color>& used_colors)
|
|
{
|
|
Gdk::Color newcolor;
|
|
|
|
while (1) {
|
|
double h, s, v;
|
|
|
|
h = fmod (random (), 360.0);
|
|
s = (random () % 65535) / 65535.0;
|
|
v = (random () % 65535) / 65535.0;
|
|
|
|
s = min (0.5, s); /* not too saturated */
|
|
v = max (0.9, v); /* not too bright */
|
|
newcolor.set_hsv (h, s, v);
|
|
|
|
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) {
|
|
/* different enough */
|
|
used_colors.push_back (newcolor);
|
|
return newcolor;
|
|
}
|
|
}
|
|
|
|
/* XXX need throttle here to make sure we don't spin for ever */
|
|
}
|
|
}
|
|
|
|
string
|
|
ARDOUR_UI_UTILS::rate_as_string (float r)
|
|
{
|
|
char buf[32];
|
|
if (fmod (r, 1000.0f)) {
|
|
snprintf (buf, sizeof (buf), "%.1f kHz", r / 1000.0);
|
|
} else {
|
|
snprintf (buf, sizeof (buf), "%.0f kHz", r / 1000.0);
|
|
}
|
|
return buf;
|
|
}
|
|
|
|
string
|
|
ARDOUR_UI_UTILS::samples_as_time_string (samplecnt_t s, float rate, bool show_samples)
|
|
{
|
|
char buf[32];
|
|
if (rate <= 0) {
|
|
snprintf (buf, sizeof (buf), "--");
|
|
} else if (s == 0) {
|
|
snprintf (buf, sizeof (buf), "0");
|
|
} else if (s < 1000 && show_samples) {
|
|
/* 0 .. 999 spl */
|
|
snprintf (buf, sizeof (buf), "%" PRId64 " spl", s);
|
|
} else if (s < (rate / 1000.f)) {
|
|
/* 0 .. 999 usec */
|
|
snprintf (buf, sizeof (buf), u8"%.0f \u00B5s", s * 1e+6f / rate);
|
|
} else if (s < (rate / 100.f)) {
|
|
/* 1.000 .. 9.999 ms */
|
|
snprintf (buf, sizeof (buf), "%.3f ms", s * 1e+3f / rate);
|
|
} else if (s < (rate / 10.f)) {
|
|
/* 1.00 .. 99.99 ms */
|
|
snprintf (buf, sizeof (buf), "%.2f ms", s * 1e+3f / rate);
|
|
} else if (s < rate) {
|
|
/* 100.0 .. 999.9 ms */
|
|
snprintf (buf, sizeof (buf), "%.1f ms", s * 1e+3f / rate);
|
|
} else if (s < rate * 10.f) {
|
|
/* 1.000 s .. 9.999 s */
|
|
snprintf (buf, sizeof (buf), "%.3f s", s / rate);
|
|
} else if (s < rate * 90.f) {
|
|
/* 10.00 s .. 89.99 s */
|
|
snprintf (buf, sizeof (buf), "%.2f s", s / rate);
|
|
} else {
|
|
/* 1m30.0 ... */
|
|
snprintf (buf, sizeof (buf), "'%.0fm%.1f", s / (60.f * rate), fmodf (s / rate, 60));
|
|
}
|
|
buf[31] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
string
|
|
ARDOUR_UI_UTILS::midi_channels_as_string (std::bitset<16> channels)
|
|
{
|
|
if (channels.none ()) {
|
|
return _("none");
|
|
}
|
|
|
|
string rv;
|
|
|
|
for (int i = 0; i < 16; i++) {
|
|
bool prior = i < 1 ? false : channels.test (i - 1);
|
|
bool current = channels.test (i);
|
|
bool next = i > 14 ? false : channels.test (i + 1);
|
|
bool nextnext = i > 13 ? false : channels.test (i + 2);
|
|
bool future = false;
|
|
for (int f = i + 1; f < 16; f++) {
|
|
if (channels.test (f)) {
|
|
future = true;
|
|
}
|
|
}
|
|
|
|
if (prior && current && next) {
|
|
/* I'm in the middle of a consecutive chain, maybe just add a dash */
|
|
if (!rv.empty () && (rv.rfind ("-") != rv.length () - 1)) {
|
|
rv += "-";
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (current) {
|
|
/* here I am! */
|
|
rv += to_string<int> (i + 1);
|
|
}
|
|
|
|
if (current && future && !(next && nextnext)) {
|
|
/* there are channels after me but they are not 3 consecutive; add a comma */
|
|
rv += ",";
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::windows_overlap (Gtk::Window* a, Gtk::Window* b)
|
|
{
|
|
if (!a || !b) {
|
|
return false;
|
|
}
|
|
if (a->get_screen () == b->get_screen ()) {
|
|
gint ex, ey, ew, eh;
|
|
gint mx, my, mw, mh;
|
|
|
|
a->get_position (ex, ey);
|
|
a->get_size (ew, eh);
|
|
b->get_position (mx, my);
|
|
b->get_size (mw, mh);
|
|
|
|
GdkRectangle e;
|
|
GdkRectangle m;
|
|
GdkRectangle r;
|
|
|
|
e.x = ex;
|
|
e.y = ey;
|
|
e.width = ew;
|
|
e.height = eh;
|
|
|
|
m.x = mx;
|
|
m.y = my;
|
|
m.width = mw;
|
|
m.height = mh;
|
|
|
|
if (gdk_rectangle_intersect (&e, &m, &r)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::overwrite_file_dialog (Gtk::Window& parent, string title, string text)
|
|
{
|
|
ArdourDialog dialog (parent, title, true);
|
|
Label label (text);
|
|
|
|
dialog.get_vbox ()->pack_start (label, true, true);
|
|
dialog.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
|
|
dialog.add_button (_("Overwrite"), Gtk::RESPONSE_ACCEPT);
|
|
dialog.show_all ();
|
|
|
|
switch (dialog.run ()) {
|
|
case RESPONSE_ACCEPT:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::running_from_source_tree ()
|
|
{
|
|
gchar const* x = g_getenv ("ARDOUR_THEMES_PATH");
|
|
return x && (string (x).find ("gtk2_ardour") != string::npos);
|
|
}
|
|
|
|
Gtk::Menu*
|
|
ARDOUR_UI_UTILS::shared_popup_menu ()
|
|
{
|
|
return ARDOUR_UI::instance ()->shared_popup_menu ();
|
|
}
|
|
|
|
bool
|
|
ARDOUR_UI_UTILS::convert_drop_to_paths (vector<string>& paths, const SelectionData& data)
|
|
{
|
|
vector<string> uris = data.get_uris ();
|
|
|
|
if (uris.empty ()) {
|
|
/* This is seriously fucked up. Nautilus doesn't say that its URI lists
|
|
* are actually URI lists. So do it by hand.
|
|
*/
|
|
if (data.get_target () != "text/plain") {
|
|
return false;
|
|
}
|
|
|
|
/* Parse the "uri-list" format that Nautilus provides,
|
|
* where each pathname is delimited by \r\n.
|
|
*
|
|
* THERE MAY BE NO NULL TERMINATING CHAR!!!
|
|
*/
|
|
string txt = data.get_text ();
|
|
|
|
/* copy to char* for easy char-wise checks and modification */
|
|
char* tmp = (char*)malloc (txt.length () + 1);
|
|
char* p = tmp;
|
|
|
|
txt.copy (p, txt.length (), 0);
|
|
p[txt.length ()] = '\0';
|
|
|
|
while (p) {
|
|
if (*p != '#') {
|
|
while (g_ascii_isspace (*p)) {
|
|
p++;
|
|
}
|
|
|
|
const char* q = p;
|
|
while (*q && (*q != '\n') && (*q != '\r')) {
|
|
q++;
|
|
}
|
|
|
|
if (q > p) {
|
|
--q;
|
|
while (q > p && g_ascii_isspace (*q)) {
|
|
--q;
|
|
}
|
|
|
|
if (q > p) {
|
|
uris.push_back (string (p, q - p + 1));
|
|
}
|
|
}
|
|
}
|
|
p = strchr (p, '\n');
|
|
if (p) {
|
|
++p;
|
|
}
|
|
}
|
|
|
|
free ((void*)tmp);
|
|
|
|
if (uris.empty ()) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
for (vector<string>::iterator i = uris.begin (); i != uris.end (); ++i) {
|
|
if ((*i).substr (0, 7) == "file://") {
|
|
paths.push_back (Glib::filename_from_uri (*i));
|
|
}
|
|
}
|
|
|
|
return !paths.empty ();
|
|
}
|
|
|
|
void
|
|
ARDOUR_UI_UTILS::copy_patch_changes (std::shared_ptr<ARDOUR::Auditioner> a, std::shared_ptr<ARDOUR::Trigger> t)
|
|
{
|
|
std::shared_ptr<ARDOUR::MIDITrigger> mt = std::dynamic_pointer_cast<ARDOUR::MIDITrigger> (t);
|
|
|
|
if (!mt || !a) {
|
|
return;
|
|
}
|
|
for (uint8_t c = 0; c < 16; ++c) {
|
|
if (a->patch_change (c).is_set ()) {
|
|
mt->set_patch_change (a->patch_change (c));
|
|
} else {
|
|
mt->unset_patch_change (c);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
ARDOUR_UI_UTILS::format_position (ARDOUR::Session* s, Temporal::timepos_t const& p, char* buf, size_t bufsize, bool onoff)
|
|
{
|
|
Temporal::BBT_Time bbt;
|
|
Timecode::Time timecode;
|
|
samplepos_t pos (p.samples ());
|
|
|
|
if (pos < 0) {
|
|
error << string_compose (_("format_position: negative timecode position: %1"), pos) << endmsg;
|
|
snprintf (buf, bufsize, "invalid");
|
|
return;
|
|
}
|
|
|
|
switch (ARDOUR_UI::instance ()->primary_clock->mode ()) {
|
|
case AudioClock::BBT:
|
|
bbt = Temporal::TempoMap::use ()->bbt_at (p);
|
|
if (onoff) {
|
|
snprintf (buf, bufsize, "%03d|%02d|%04d", bbt.bars, bbt.beats, bbt.ticks);
|
|
} else {
|
|
snprintf (buf, bufsize, "(%03d|%02d|%04d)", bbt.bars, bbt.beats, bbt.ticks);
|
|
}
|
|
break;
|
|
|
|
case AudioClock::MinSec:
|
|
samplepos_t left;
|
|
int hrs;
|
|
int mins;
|
|
float secs;
|
|
|
|
left = pos;
|
|
hrs = (int)floor (left / (s->sample_rate () * 60.0f * 60.0f));
|
|
left -= (samplecnt_t)floor (hrs * s->sample_rate () * 60.0f * 60.0f);
|
|
mins = (int)floor (left / (s->sample_rate () * 60.0f));
|
|
left -= (samplecnt_t)floor (mins * s->sample_rate () * 60.0f);
|
|
secs = left / (float)s->sample_rate ();
|
|
if (onoff) {
|
|
snprintf (buf, bufsize, "%02d:%02d:%06.3f", hrs, mins, secs);
|
|
} else {
|
|
snprintf (buf, bufsize, "(%02d:%02d:%06.3f)", hrs, mins, secs);
|
|
}
|
|
break;
|
|
|
|
case AudioClock::Seconds:
|
|
if (onoff) {
|
|
snprintf (buf, bufsize, "%.1f", pos / (float)s->sample_rate ());
|
|
} else {
|
|
snprintf (buf, bufsize, "(%.1f)", pos / (float)s->sample_rate ());
|
|
}
|
|
break;
|
|
|
|
case AudioClock::Samples:
|
|
if (onoff) {
|
|
snprintf (buf, bufsize, "%" PRId64, pos);
|
|
} else {
|
|
snprintf (buf, bufsize, "(%" PRId64 ")", pos);
|
|
}
|
|
break;
|
|
|
|
case AudioClock::Timecode:
|
|
default:
|
|
s->timecode_time (pos, timecode);
|
|
if (onoff) {
|
|
snprintf (buf, bufsize, "%02d:%02d:%02d:%02d", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
|
|
} else {
|
|
snprintf (buf, bufsize, "(%02d:%02d:%02d:%02d)", timecode.hours, timecode.minutes, timecode.seconds, timecode.frames);
|
|
}
|
|
break;
|
|
}
|
|
}
|