allanger/ardour
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Activity

remove base color concept from UIConfiguration and ThemeManager.

Browse Source 
What used to be "relative colors" (defined relative to base colors) are now defined
in absolute terms.
This commit is contained in:
Paul Davis
2014-12-14 16:14:18 -05:00
parent 48a7a11974
commit 59f32dc80f
4 changed files with 72 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

202
gtk2_ardour/theme_manager.cc
View File

@@ -82,41 +82,15 @@ ThemeManager::ThemeManager()
{
set_title (_("Theme Manager"));
/* Basic color list */
basic_color_list = TreeStore::create (basic_color_columns);
basic_color_display.set_model (basic_color_list);
basic_color_display.append_column (_("Object"), basic_color_columns.name);
Gtkmm2ext::CellRendererColorSelector* color_renderer = manage (new Gtkmm2ext::CellRendererColorSelector);
TreeViewColumn* color_column = manage (new TreeViewColumn (_("Color"), *color_renderer));
color_column->add_attribute (color_renderer->property_color(), basic_color_columns.gdkcolor);
basic_color_display.append_column (*color_column);
basic_color_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
basic_color_display.get_column (0)->set_expand (true);
basic_color_display.get_column (1)->set_data (X_("colnum"), GUINT_TO_POINTER(1));
basic_color_display.get_column (1)->set_expand (false);
basic_color_display.set_reorderable (false);
basic_color_display.get_selection()->set_mode (SELECTION_NONE);
basic_color_display.set_headers_visible (true);
basic_color_display.signal_button_press_event().connect (sigc::mem_fun (*this, &ThemeManager::basic_color_button_press_event), false);
scroller.add (basic_color_display);
scroller.set_policy (POLICY_NEVER, POLICY_AUTOMATIC);
/* Now the alias list */
alias_list = TreeStore::create (alias_columns);
alias_display.set_model (alias_list);
alias_display.append_column (_("Object"), basic_color_columns.name);
color_renderer = manage (new Gtkmm2ext::CellRendererColorSelector);
color_column = manage (new TreeViewColumn (_("Color"), *color_renderer));
alias_display.append_column (_("Object"), alias_columns.name);
Gtkmm2ext::CellRendererColorSelector* color_renderer = manage (new Gtkmm2ext::CellRendererColorSelector);
TreeViewColumn* color_column = manage (new TreeViewColumn (_("Color"), *color_renderer));
color_column->add_attribute (color_renderer->property_color(), alias_columns.color);
alias_display.append_column (*color_column);
alias_display.get_column (0)->set_data (X_("colnum"), GUINT_TO_POINTER(0));
@@ -186,7 +160,6 @@ ThemeManager::ThemeManager()
notebook.append_page (alias_scroller, _("Items"));
notebook.append_page (palette_scroller, _("Palette"));
notebook.append_page (scroller, _("Colors"));
vbox->pack_start (notebook);
@@ -225,7 +198,6 @@ ThemeManager::ThemeManager()
PROGRAM_NAME));
set_size_request (-1, 400);
setup_basic_color_display ();
/* no need to call setup_palette() here, it will be done when its size is allocated */
setup_aliases ();
@@ -243,7 +215,6 @@ ThemeManager::~ThemeManager()
void
ThemeManager::colors_changed ()
{
setup_basic_color_display ();
setup_palette ();
setup_aliases ();
}
@@ -254,77 +225,6 @@ ThemeManager::save (string /*path*/)
return 0;
}
bool
ThemeManager::basic_color_button_press_event (GdkEventButton* ev)
{
TreeIter iter;
TreeModel::Path path;
TreeViewColumn* column;
int cellx;
int celly;
if (!basic_color_display.get_path_at_pos ((int)ev->x, (int)ev->y, path, column, cellx, celly)) {
return false;
}
switch (GPOINTER_TO_UINT (column->get_data (X_("colnum")))) {
case 0:
/* allow normal processing to occur */
return false;
case 1: /* color */
if ((iter = basic_color_list->get_iter (path))) {
string color_name = (*iter)[basic_color_columns.name];
Gdk::Color color;
double r, g, b, a;
ArdourCanvas::color_to_rgba (ARDOUR_UI::config()->base_color_by_name (color_name), r, g, b, a);
color.set_rgb_p (r, g, b);
color_dialog.get_colorsel()->set_previous_color (color);
color_dialog.get_colorsel()->set_current_color (color);
color_dialog.get_colorsel()->set_previous_alpha ((guint16) (a * 65535.0));
color_dialog.get_colorsel()->set_current_alpha ((guint16) (a * 65535.0));
color_dialog_connection.disconnect ();
color_dialog_connection = color_dialog.signal_response().connect (sigc::bind (sigc::mem_fun (*this, &ThemeManager::basic_color_response), color_name));
color_dialog.present ();
}
}
return true;
}
void
ThemeManager::basic_color_response (int result, string name)
{
Gdk::Color color;
double a;
color_dialog_connection.disconnect ();
switch (result) {
case RESPONSE_CANCEL:
break;
case RESPONSE_ACCEPT:
case RESPONSE_OK:
color = color_dialog.get_colorsel()->get_current_color();
a = color_dialog.get_colorsel()->get_current_alpha() / 65535.0;
ARDOUR_UI::config()->set_base (name, ArdourCanvas::rgba_to_color (color.get_red_p(),
color.get_green_p(),
color.get_blue_p(),
a));
break;
default:
break;
}
color_dialog.hide ();
}
void
ThemeManager::on_flat_buttons_toggled ()
{
@@ -403,66 +303,13 @@ ThemeManager::on_light_theme_button_toggled()
uic->set_color_file("light");
}
void
ThemeManager::setup_basic_color_display ()
{
basic_color_list->clear();
for (UIConfiguration::BaseColors::const_iterator i = ARDOUR_UI::config()->base_colors.begin(); i != ARDOUR_UI::config()->base_colors.end(); i++) {
TreeModel::Row row;
row = *(basic_color_list->append());
row[basic_color_columns.name] = i->first;
ArdourCanvas::Color c = i->second;
/* Gdk colors don't support alpha */
double r, g, b, a;
ArdourCanvas::color_to_rgba (c, r, g, b, a);
Gdk::Color gcolor;
gcolor.set_rgb_p (r, g, b);
row[basic_color_columns.gdkcolor] = gcolor;
}
UIConfiguration* uic (ARDOUR_UI::config());
flat_buttons.set_active (uic->get_flat_buttons());
blink_rec_button.set_active (uic->get_blink_rec_arm());
waveform_gradient_depth.set_value (uic->get_waveform_gradient_depth());
timeline_item_gradient_depth.set_value (uic->get_timeline_item_gradient_depth());
all_dialogs.set_active (uic->get_all_floating_windows_are_dialogs());
}
void
ThemeManager::reset_canvas_colors()
{
ARDOUR_UI::config()->load_defaults();
setup_basic_color_display ();
ARDOUR_UI::config()->save_state ();
}
struct NamedColor {
string name;
ArdourCanvas::HSV color;
NamedColor (string s, ArdourCanvas::HSV c) : name (s), color (c) {}
};
struct SortByHue {
bool operator() (NamedColor const & a, NamedColor const & b) {
using namespace ArdourCanvas;
const HSV black (0, 0, 0);
if (a.color.is_gray() || b.color.is_gray()) {
return black.distance (a.color) < black.distance (b.color);
} else {
return a.color.h < b.color.h;
// const HSV red (rgba_to_color (1.0, 0.0, 0.0, 1.0));
// return red.distance (a.color) < red.distance (b.color);
}
}
};
ArdourCanvas::Container*
ThemeManager::initialize_palette_canvas (ArdourCanvas::Canvas& canvas)
{
@@ -487,6 +334,27 @@ ThemeManager::palette_canvas_allocated (Gtk::Allocation& alloc, ArdourCanvas::Co
build_palette_canvas (*canvas, *group, event_handler);
}
struct NamedColor {
string name;
ArdourCanvas::HSV color;
NamedColor (string s, ArdourCanvas::HSV c) : name (s), color (c) {}
};
struct SortByHue {
bool operator() (NamedColor const & a, NamedColor const & b) {
using namespace ArdourCanvas;
const HSV black (0, 0, 0);
if (a.color.is_gray() || b.color.is_gray()) {
return black.distance (a.color) < black.distance (b.color);
} else {
return a.color.h < b.color.h;
// const HSV red (rgba_to_color (1.0, 0.0, 0.0, 1.0));
// return red.distance (a.color) < red.distance (b.color);
}
}
};
void
ThemeManager::build_palette_canvas (ArdourCanvas::Canvas& canvas, ArdourCanvas::Container& group, sigc::slot<bool,GdkEvent*,std::string> event_handler)
{
@@ -494,10 +362,10 @@ ThemeManager::build_palette_canvas (ArdourCanvas::Canvas& canvas, ArdourCanvas::
/* we want the colors sorted by hue, with their name */
UIConfiguration::RelativeColors& relatives (ARDOUR_UI::instance()->config()->relative_colors);
UIConfiguration::Colors& colors (ARDOUR_UI::instance()->config()->colors);
vector<NamedColor> nc;
for (UIConfiguration::RelativeColors::const_iterator x = relatives.begin(); x != relatives.end(); ++x) {
nc.push_back (NamedColor (x->first, x->second.get()));
for (UIConfiguration::Colors::const_iterator x = colors.begin(); x != colors.end(); ++x) {
nc.push_back (NamedColor (x->first, HSV (x->second)));
}
SortByHue sorter;
sort (nc.begin(), nc.end(), sorter);
@@ -519,10 +387,10 @@ ThemeManager::build_palette_canvas (ArdourCanvas::Canvas& canvas, ArdourCanvas::
string name = nc[color_num++].name;
UIConfiguration::RelativeColors::iterator c = relatives.find (name);
UIConfiguration::Colors::iterator c = colors.find (name);
if (c != relatives.end()) {
Color color = c->second.get().color ();
if (c != colors.end()) {
Color color = c->second;
r->set_fill_color (color);
r->set_outline_color (rgba_to_color (0.0, 0.0, 0.0, 1.0));
r->set_tooltip (name);
@@ -535,7 +403,7 @@ ThemeManager::build_palette_canvas (ArdourCanvas::Canvas& canvas, ArdourCanvas::
void
ThemeManager::palette_size_request (Gtk::Requisition* req)
{
uint32_t ncolors = ARDOUR_UI::instance()->config()->relative_colors.size();
uint32_t ncolors = ARDOUR_UI::instance()->config()->colors.size();
const int box_size = 20;
double c = sqrt ((double)ncolors);
@@ -598,7 +466,6 @@ ThemeManager::palette_color_response (int result, std::string name)
color_dialog_connection.disconnect ();
UIConfiguration* uic (ARDOUR_UI::instance()->config());
UIConfiguration::RelativeHSV rhsv ("", HSV());
Gdk::Color gdkcolor;
double r,g, b, a;
@@ -610,9 +477,8 @@ ThemeManager::palette_color_response (int result, std::string name)
r = gdkcolor.get_red_p();
g = gdkcolor.get_green_p();
b = gdkcolor.get_blue_p();
rhsv = uic->color_as_relative_hsv (rgba_to_color (r, g, b, a));
uic->set_relative (name, rhsv);
uic->set_color (name, rgba_to_color (r, g, b, a));
break;
default:

13
gtk2_ardour/theme_manager.h
View File

@@ -50,7 +50,6 @@ class ThemeManager : public ArdourWindow
~ThemeManager();
int save (std::string path);
void setup_basic_color_display ();
void reset_canvas_colors();
void on_dark_theme_button_toggled ();
@@ -77,16 +76,9 @@ class ThemeManager : public ArdourWindow
Gtk::TreeModelColumn<Gdk::Color> gdkcolor;
};
BasicColorDisplayModelColumns basic_color_columns;
Gtk::TreeView basic_color_display;
Glib::RefPtr<Gtk::TreeStore> basic_color_list;
bool basic_color_button_press_event (GdkEventButton*);
Gtk::ColorSelectionDialog color_dialog;
sigc::connection color_dialog_connection;
Gtk::ScrolledWindow scroller;
Gtk::HBox theme_selection_hbox;
Gtk::RadioButton dark_button;
Gtk::RadioButton light_button;
@@ -104,11 +96,6 @@ class ThemeManager : public ArdourWindow
Gtk::Label icon_set_label;
Gtk::ComboBoxText icon_set_dropdown;
/* handles response from color dialog when it used to
edit a basic color
*/
void basic_color_response (int, std::string);
/* handls response from color dialog when it is used to
edit a derived color.
*/

241
gtk2_ardour/ui_config.cc
View File

@@ -26,6 +26,7 @@
#include <glibmm/miscutils.h>
#include <glib/gstdio.h>
#include "pbd/convert.h"
#include "pbd/failed_constructor.h"
#include "pbd/xml++.h"
#include "pbd/file_utils.h"
@@ -65,32 +66,12 @@ UIConfiguration::UIConfiguration ()
#undef CANVAS_FONT_VARIABLE
_dirty (false),
base_modified (false),
aliases_modified (false),
derived_modified (false),
colors_modified (false),
block_save (0)
{
_instance = this;
/* pack all base colors into the configurable color map so that
derived colors can use them.
*/
#undef CANVAS_BASE_COLOR
#define CANVAS_BASE_COLOR(var,name,color) base_colors.insert (make_pair (name,color));
#include "base_colors.h"
#undef CANVAS_BASE_COLOR
#undef CANVAS_COLOR
#define CANVAS_COLOR(var,name,base,modifier) relative_colors.insert (make_pair (name, RelativeHSV (base,modifier)));
#include "colors.h"
#undef CANVAS_COLOR
#undef COLOR_ALIAS
#define COLOR_ALIAS(var,name,alias) color_aliases.insert (make_pair (name,alias));
#include "color_aliases.h"
#undef CANVAS_COLOR
load_state();
ARDOUR_UI_UTILS::ColorsChanged.connect (boost::bind (&UIConfiguration::colors_changed, this));
@@ -132,9 +113,6 @@ UIConfiguration::parameter_changed (string param)
load_rc_file (true);
} else if (param == "color-file") {
load_color_theme ();
} else if (param == "base-color") { /* one of many */
base_modified = true;
ARDOUR_UI_UTILS::ColorsChanged (); /* EMIT SIGNAL */
}
save_state ();
@@ -163,89 +141,6 @@ UIConfiguration::reset_gtk_theme ()
Gtk::Settings::get_default()->property_gtk_color_scheme() = ss.str();
}
UIConfiguration::RelativeHSV
UIConfiguration::color_as_relative_hsv (Color c)
{
HSV variable (c);
HSV closest;
double shortest_distance = DBL_MAX;
string closest_name;
BaseColors::iterator f;
std::map<std::string,HSV> palette;
for (f = base_colors.begin(); f != base_colors.end(); ++f) {
/* Do not include any specialized base colors in the palette
we use to do comparisons (e.g. meter colors)
*/
if (f->first.find ("color") == 0) {
palette.insert (make_pair (f->first, HSV (f->second)));
}
}
for (map<string,HSV>::iterator f = palette.begin(); f != palette.end(); ++f) {
double d;
HSV fixed (f->second);
if (fixed.is_gray() || variable.is_gray()) {
/* at least one is achromatic; HSV::distance() will do
* the right thing
*/
d = fixed.distance (variable);
} else {
/* chromatic: compare ONLY hue because our task is
to pick the HUE closest and then compute
a modifier. We want to keep the number of
hues low, and by computing perceptual distance
we end up finding colors that are to each
other without necessarily be close in hue.
*/
d = fabs (variable.h - fixed.h);
}
if (d < shortest_distance) {
closest = fixed;
closest_name = f->first;
shortest_distance = d;
}
}
/* we now know the closest color of the fixed colors to
this variable color. Compute the HSV diff and
use it to redefine the variable color in terms of the
fixed one.
*/
HSV delta = variable.delta (closest);
/* quantize hue delta so we don't end up with many subtle hues caused
* by original color choices
*/
delta.h = hue_width * (round (delta.h/hue_width));
return RelativeHSV (closest_name, delta);
}
string
UIConfiguration::color_as_alias (Color c)
{
string closest;
double shortest_distance = DBL_MAX;
HSV target (c);
for (RelativeColors::const_iterator a = relative_colors.begin(); a != relative_colors.end(); ++a) {
HSV hsv (a->second.get());
double d = hsv.distance (target);
if (d < shortest_distance) {
shortest_distance = d;
closest = a->first;
}
}
return closest;
}
void
UIConfiguration::map_parameters (boost::function<void (std::string)>& functor)
{
@@ -348,17 +243,17 @@ UIConfiguration::store_color_theme ()
root = new XMLNode("Ardour");
XMLNode* parent = new XMLNode (X_("RelativeColors"));
for (RelativeColors::const_iterator i = relative_colors.begin(); i != relative_colors.end(); ++i) {
XMLNode* node = new XMLNode (X_("RelativeColor"));
XMLNode* parent = new XMLNode (X_("Colors"));
for (Colors::const_iterator i = colors.begin(); i != colors.end(); ++i) {
XMLNode* node = new XMLNode (X_("Color"));
node->add_property (X_("name"), i->first);
node->add_property (X_("base"), i->second.base_color);
node->add_property (X_("modifier"), i->second.modifier.to_string());
stringstream ss;
ss << "0x" << setw (8) << setfill ('0') << hex << i->second;
node->add_property (X_("value"), ss.str());
parent->add_child_nocopy (*node);
}
root->add_child_nocopy (*parent);
parent = new XMLNode (X_("ColorAliases"));
for (ColorAliases::const_iterator i = color_aliases.begin(); i != color_aliases.end(); ++i) {
XMLNode* node = new XMLNode (X_("ColorAlias"));
@@ -450,16 +345,15 @@ UIConfiguration::save_state()
_dirty = false;
}
if (base_modified || aliases_modified || derived_modified) {
if (aliases_modified || colors_modified) {
if (store_color_theme ()) {
error << string_compose (_("Color file %1 not saved"), color_file.get()) << endmsg;
return -1;
}
base_modified = false;
aliases_modified = false;
derived_modified = false;
colors_modified = false;
}
@@ -529,20 +423,12 @@ UIConfiguration::set_state (const XMLNode& root, int /*version*/)
}
}
XMLNode* base = find_named_node (root, X_("BaseColors"));
XMLNode* colors = find_named_node (root, X_("Colors"));
if (base) {
load_base_colors (*base);
if (colors) {
load_colors (*colors);
}
XMLNode* relative = find_named_node (root, X_("RelativeColors"));
if (relative) {
load_relative_colors (*relative);
}
XMLNode* aliases = find_named_node (root, X_("ColorAliases"));
if (aliases) {
@@ -552,12 +438,6 @@ UIConfiguration::set_state (const XMLNode& root, int /*version*/)
return 0;
}
void
UIConfiguration::load_base_colors (XMLNode const &)
{
}
void
UIConfiguration::load_color_aliases (XMLNode const & node)
{
@@ -579,35 +459,31 @@ UIConfiguration::load_color_aliases (XMLNode const & node)
color_aliases.insert (make_pair (name->value(), alias->value()));
}
}
cerr << "Color alias table contains " << color_aliases.size() << endl;
}
void
UIConfiguration::load_relative_colors (XMLNode const & node)
UIConfiguration::load_colors (XMLNode const & node)
{
XMLNodeList const nlist = node.children();
XMLNodeConstIterator niter;
XMLProperty const *name;
XMLProperty const *base;
XMLProperty const *modifier;
XMLProperty const *color;
relative_colors.clear ();
colors.clear ();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
if ((*niter)->name() != X_("RelativeColor")) {
if ((*niter)->name() != X_("Color")) {
continue;
}
name = (*niter)->property (X_("name"));
base = (*niter)->property (X_("base"));
modifier = (*niter)->property (X_("modifier"));
color = (*niter)->property (X_("value"));
if (name && base && modifier) {
RelativeHSV rhsv (base->value(), HSV (modifier->value()));
relative_colors.insert (make_pair (name->value(), rhsv));
if (name && color) {
ArdourCanvas::Color c;
c = strtol (color->value().c_str(), 0, 16);
colors.insert (make_pair (name->value(), c));
}
}
}
void
@@ -622,38 +498,25 @@ UIConfiguration::set_variables (const XMLNode& node)
#undef CANVAS_FONT_VARIABLE
}
ArdourCanvas::Color
UIConfiguration::base_color_by_name (const std::string& name) const
{
BaseColors::const_iterator i = base_colors.find (name);
if (i != base_colors.end()) {
return i->second;
}
cerr << string_compose (_("Base Color %1 not found"), name) << endl;
return RGBA_TO_UINT (g_random_int()%256,g_random_int()%256,g_random_int()%256,0xff);
}
ArdourCanvas::Color
UIConfiguration::color (const std::string& name, bool* failed) const
{
map<string,string>::const_iterator e = color_aliases.find (name);
ColorAliases::const_iterator e = color_aliases.find (name);
if (failed) {
*failed = false;
}
if (e != color_aliases.end ()) {
map<string,RelativeHSV>::const_iterator rc = relative_colors.find (e->second);
if (rc != relative_colors.end()) {
return rc->second.get();
Colors::const_iterator rc = colors.find (e->second);
if (rc != colors.end()) {
return rc->second;
}
} else {
/* not an alias, try directly */
map<string,RelativeHSV>::const_iterator rc = relative_colors.find (name);
if (rc != relative_colors.end()) {
return rc->second.get();
Colors::const_iterator rc = colors.find (name);
if (rc != colors.end()) {
return rc->second;
}
}
@@ -674,25 +537,6 @@ UIConfiguration::color (const std::string& name, bool* failed) const
0xff);
}
ArdourCanvas::HSV
UIConfiguration::RelativeHSV::get() const
{
HSV base (UIConfiguration::instance()->base_color_by_name (base_color));
/* this operation is a little wierd. because of the way we originally
* computed the alpha specification for the modifiers used here
* we need to reset base's alpha to zero before adding the modifier.
*/
HSV self (base + modifier);
if (quantized_hue >= 0.0) {
self.h = quantized_hue;
}
return self;
}
Color
UIConfiguration::quantized (Color c) const
{
@@ -702,29 +546,14 @@ UIConfiguration::quantized (Color c) const
}
void
UIConfiguration::set_base (string const& name, ArdourCanvas::Color color)
UIConfiguration::set_color (string const& name, ArdourCanvas::Color color)
{
BaseColors::iterator i = base_colors.find (name);
if (i == base_colors.end()) {
Colors::iterator i = colors.find (name);
if (i == colors.end()) {
return;
}
i->second = color;
base_modified = true;
ARDOUR_UI_UTILS::ColorsChanged (); /* EMIT SIGNAL */
}
void
UIConfiguration::set_relative (const string& name, const RelativeHSV& rhsv)
{
RelativeColors::iterator i = relative_colors.find (name);
if (i == relative_colors.end()) {
return;
}
i->second = rhsv;
derived_modified = true;
colors_modified = true;
ARDOUR_UI_UTILS::ColorsChanged (); /* EMIT SIGNAL */
}
@@ -761,8 +590,4 @@ UIConfiguration::load_rc_file (bool themechange, bool allow_own)
Gtkmm2ext::UI::instance()->load_rcfile (rc_file_path, themechange);
}
std::ostream& operator<< (std::ostream& o, const UIConfiguration::RelativeHSV& rhsv)
{
return o << rhsv.base_color << " + HSV(" << rhsv.modifier << ")";
}

42
gtk2_ardour/ui_config.h
View File

@@ -38,18 +38,6 @@
class UIConfiguration : public PBD::Stateful
{
public:
struct RelativeHSV {
RelativeHSV (const std::string& b, const ArdourCanvas::HSV& mod)
: base_color (b)
, modifier (mod)
, quantized_hue (-1.0) {}
std::string base_color;
ArdourCanvas::HSV modifier;
double quantized_hue;
ArdourCanvas::HSV get() const;
};
UIConfiguration();
~UIConfiguration();
@@ -66,23 +54,18 @@ class UIConfiguration : public PBD::Stateful
XMLNode& get_variables (std::string);
void set_variables (const XMLNode&);
typedef std::map<std::string,RelativeHSV> RelativeColors;
typedef std::map<std::string,ArdourCanvas::Color> Colors;
typedef std::map<std::string,std::string> ColorAliases;
typedef std::map<std::string,ArdourCanvas::Color> BaseColors;
BaseColors base_colors;
RelativeColors relative_colors;
Colors colors;
ColorAliases color_aliases;
void set_alias (std::string const & name, std::string const & alias);
void set_relative (const std::string& name, const RelativeHSV& new_value);
void set_base (const std::string& name, ArdourCanvas::Color);
void set_color (const std::string& name, ArdourCanvas::Color);
RelativeHSV color_as_relative_hsv (ArdourCanvas::Color c);
std::string color_as_alias (ArdourCanvas::Color c);
ArdourCanvas::Color quantized (ArdourCanvas::Color) const;
ArdourCanvas::Color base_color_by_name (const std::string&) const;
ArdourCanvas::Color color (const std::string&, bool* failed = 0) const;
ArdourCanvas::HSV color_hsv (const std::string&) const;
@@ -103,17 +86,6 @@ class UIConfiguration : public PBD::Stateful
#include "canvas_vars.h"
#undef CANVAS_FONT_VARIABLE
#undef CANVAS_BASE_COLOR
#define CANVAS_BASE_COLOR(var,name,val) \
ArdourCanvas::Color get_##var() const { return base_color_by_name (name); }
#include "base_colors.h"
#undef CANVAS_BASE_COLOR
#undef COLOR_ALIAS
#define COLOR_ALIAS(var,name,alias) ArdourCanvas::Color get_##var() const { return color (name); }
#include "color_aliases.h"
#undef COLOR_ALIAS
private:
/* declare variables */
@@ -128,16 +100,14 @@ class UIConfiguration : public PBD::Stateful
XMLNode& state ();
bool _dirty;
bool base_modified;
bool aliases_modified;
bool derived_modified;
bool colors_modified;
static UIConfiguration* _instance;
int store_color_theme ();
void load_base_colors (XMLNode const &);
void load_color_aliases (XMLNode const &);
void load_relative_colors (XMLNode const &);
void load_colors (XMLNode const &);
void reset_gtk_theme ();
void colors_changed ();
int load_color_theme (bool allow_own=true);
@@ -145,7 +115,5 @@ class UIConfiguration : public PBD::Stateful
uint32_t block_save;
};
std::ostream& operator<< (std::ostream& o, const UIConfiguration::RelativeHSV& rhsv);
#endif /* __ardour_ui_configuration_h__ */