src/gui.cpp

   1 /* Calf DSP Library
   2  * GUI functions for a plugin.
   3  * Copyright (C) 2007-2011 Krzysztof Foltman
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General
  16  * Public License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  */
  20
  21 #include <calf/gui_config.h>
  22 #include <calf/gui_controls.h>
  23 #include <calf/preset.h>
  24 #include <calf/preset_gui.h>
  25 #include <gdk/gdk.h>
  26
  27 #include <iostream>
  28
  29 using namespace calf_plugins;
  30 using namespace std;
  31
  32 /******************************** GUI proper ********************************/
  33
  34 plugin_gui::plugin_gui(plugin_gui_window *_window)
  35 : last_status_serial_no(0)
  36 , window(_window)
  37 {
  38     ignore_stack = 0;
  39     top_container = NULL;
  40     param_count = 0;
  41     container = NULL;
  42     effect_name = NULL;
  43     preset_access = new gui_preset_access(this);
  44     optclosed = false;
  45     optwidget = NULL;
  46     optwindow = NULL;
  47     opttitle = NULL;
  48 }
  49
  50 control_base *plugin_gui::create_widget_from_xml(const char *element, const char *attributes[])
  51 {
  52     if (!strcmp(element, "knob"))
  53         return new knob_param_control;
  54     if (!strcmp(element, "hscale"))
  55         return new hscale_param_control;
  56     if (!strcmp(element, "vscale"))
  57         return new vscale_param_control;
  58     if (!strcmp(element, "combo"))
  59         return new combo_box_param_control;
  60     if (!strcmp(element, "check"))
  61         return new check_param_control;
  62     if (!strcmp(element, "radio"))
  63         return new radio_param_control;
  64     if (!strcmp(element, "toggle"))
  65         return new toggle_param_control;
  66     if (!strcmp(element, "tap"))
  67         return new tap_button_param_control;
  68     if (!strcmp(element, "spin"))
  69         return new spin_param_control;
  70     if (!strcmp(element, "button"))
  71         return new button_param_control;
  72     if (!strcmp(element, "label"))
  73         return new label_param_control;
  74     if (!strcmp(element, "value"))
  75         return new value_param_control;
  76     if (!strcmp(element, "vumeter"))
  77         return new vumeter_param_control;
  78     if (!strcmp(element, "line-graph"))
  79         return new line_graph_param_control;
  80     if (!strcmp(element, "phase-graph"))
  81         return new phase_graph_param_control;
  82     if (!strcmp(element, "keyboard"))
  83         return new keyboard_param_control;
  84     if (!strcmp(element, "curve"))
  85         return new curve_param_control;
  86     if (!strcmp(element, "led"))
  87         return new led_param_control;
  88     if (!strcmp(element, "tube"))
  89         return new tube_param_control;
  90     if (!strcmp(element, "entry"))
  91         return new entry_param_control;
  92     if (!strcmp(element, "filechooser"))
  93         return new filechooser_param_control;
  94     if (!strcmp(element, "listview"))
  95         return new listview_param_control;
  96     if (!strcmp(element, "notebook"))
  97         return new notebook_param_control;
  98     if (!strcmp(element, "table"))
  99         return new table_container;
 100     if (!strcmp(element, "vbox"))
 101         return new vbox_container;
 102     if (!strcmp(element, "hbox"))
 103         return new hbox_container;
 104     if (!strcmp(element, "align"))
 105         return new alignment_container;
 106     if (!strcmp(element, "frame"))
 107         return new frame_container;
 108     if (!strcmp(element, "scrolled"))
 109         return new scrolled_container;
 110     return NULL;
 111 }
 112
 113 void plugin_gui::xml_element_start(void *data, const char *element, const char *attributes[])
 114 {
 115     plugin_gui *gui = (plugin_gui *)data;
 116     gui->xml_element_start(element, attributes);
 117 }
 118
 119 int plugin_gui::get_param_no_by_name(string param_name)
 120 {
 121     int param_no = -1;
 122     map<string, int>::iterator it = param_name_map.find(param_name);
 123     if (it == param_name_map.end())
 124         g_error("Unknown parameter %s", param_name.c_str());
 125     else
 126         param_no = it->second;
 127
 128     return param_no;
 129 }
 130
 131 void plugin_gui::xml_element_start(const char *element, const char *attributes[])
 132 {
 133     if (ignore_stack) {
 134         ignore_stack++;
 135         return;
 136     }
 137     control_base::xml_attribute_map xam;
 138     while(*attributes)
 139     {
 140         xam[attributes[0]] = attributes[1];
 141         attributes += 2;
 142     }
 143
 144     if (!strcmp(element, "if"))
 145     {
 146         if (!xam.count("cond") || xam["cond"].empty())
 147         {
 148             g_error("Incorrect <if cond=\"[!]symbol\"> element");
 149         }
 150         string cond = xam["cond"];
 151         bool state = true;
 152         if (cond.substr(0, 1) == "!") {
 153             state = false;
 154             cond.erase(0, 1);
 155         }
 156         if (window->environment->check_condition(cond.c_str()) == state)
 157             return;
 158         ignore_stack = 1;
 159         return;
 160     }
 161     control_base *cc = create_widget_from_xml(element, attributes);
 162     if (cc == NULL)
 163         g_error("Unxpected element %s in GUI definition\n", element);
 164
 165     cc->attribs = xam;
 166     cc->create(this);
 167     stack.push_back(cc);
 168 }
 169
 170 void plugin_gui::xml_element_end(void *data, const char *element)
 171 {
 172     plugin_gui *gui = (plugin_gui *)data;
 173     if (gui->ignore_stack) {
 174         gui->ignore_stack--;
 175         return;
 176     }
 177     if (!strcmp(element, "if"))
 178         return;
 179
 180     control_base *control = gui->stack.back();
 181     control->created();
 182
 183     gui->stack.pop_back();
 184     if (gui->stack.empty())
 185     {
 186         gui->top_container = control;
 187         gtk_widget_show_all(control->widget);
 188     }
 189     else
 190         gui->stack.back()->add(control);
 191 }
 192
 193
 194 GtkWidget *plugin_gui::create_from_xml(plugin_ctl_iface *_plugin, const char *xml)
 195 {
 196     top_container = NULL;
 197     parser = XML_ParserCreate("UTF-8");
 198     plugin = _plugin;
 199     stack.clear();
 200     ignore_stack = 0;
 201
 202     param_name_map.clear();
 203     read_serials.clear();
 204     int size = plugin->get_metadata_iface()->get_param_count();
 205     read_serials.resize(size);
 206     for (int i = 0; i < size; i++)
 207         param_name_map[plugin->get_metadata_iface()->get_param_props(i)->short_name] = i;
 208
 209     XML_SetUserData(parser, this);
 210     XML_SetElementHandler(parser, xml_element_start, xml_element_end);
 211     XML_Status status = XML_Parse(parser, xml, strlen(xml), 1);
 212     if (status == XML_STATUS_ERROR)
 213     {
 214         g_error("Parse error: %s in XML", XML_ErrorString(XML_GetErrorCode(parser)));
 215     }
 216
 217     XML_ParserFree(parser);
 218     last_status_serial_no = plugin->send_status_updates(this, 0);
 219     GtkWidget *eventbox  = gtk_event_box_new();
 220     GtkWidget *decoTable = gtk_table_new(3, 1, FALSE);
 221
 222     // decorations
 223     // overall background
 224     //GtkWidget *bgImg     = gtk_image_new_from_file(PKGLIBDIR "/background.png");
 225     //gtk_widget_set_size_request(GTK_WIDGET(bgImg), 1, 1);
 226
 227     // images for left side
 228     GtkWidget *nwImg     = gtk_image_new_from_file(PKGLIBDIR "/side_nw.png");
 229     GtkWidget *swImg     = gtk_image_new_from_file(PKGLIBDIR "/side_sw.png");
 230     GtkWidget *wImg      = gtk_image_new_from_file(PKGLIBDIR "/side_w.png");
 231     gtk_widget_set_size_request(GTK_WIDGET(wImg), 56, 1);
 232
 233     // images for right side
 234     GtkWidget *neImg     = gtk_image_new_from_file(PKGLIBDIR "/side_ne.png");
 235     GtkWidget *seImg     = gtk_image_new_from_file(PKGLIBDIR "/side_se.png");
 236     GtkWidget *eImg      = gtk_image_new_from_file(PKGLIBDIR "/side_e.png");
 237     GtkWidget *logoImg   = gtk_image_new_from_file(PKGLIBDIR "/side_e_logo.png");
 238     gtk_widget_set_size_request(GTK_WIDGET(eImg), 56, 1);
 239
 240     // pack left box
 241     leftBox = gtk_vbox_new(FALSE, 0);
 242     gtk_box_pack_start(GTK_BOX(leftBox), GTK_WIDGET(nwImg), FALSE, FALSE, 0);
 243     gtk_box_pack_start(GTK_BOX(leftBox), GTK_WIDGET(wImg), TRUE, TRUE, 0);
 244     gtk_box_pack_end(GTK_BOX(leftBox), GTK_WIDGET(swImg), FALSE, FALSE, 0);
 245
 246      // pack right box
 247     rightBox = gtk_vbox_new(FALSE, 0);
 248     gtk_box_pack_start(GTK_BOX(rightBox), GTK_WIDGET(neImg), FALSE, FALSE, 0);
 249     gtk_box_pack_start(GTK_BOX(rightBox), GTK_WIDGET(eImg), TRUE, TRUE, 0);
 250     gtk_box_pack_start(GTK_BOX(rightBox), GTK_WIDGET(logoImg), FALSE, FALSE, 0);
 251     gtk_box_pack_end(GTK_BOX(rightBox), GTK_WIDGET(seImg), FALSE, FALSE, 0);
 252
 253     //gtk_table_attach(GTK_TABLE(decoTable), GTK_WIDGET(bgImg),     0, 2, 0, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
 254     gtk_table_attach(GTK_TABLE(decoTable), GTK_WIDGET(leftBox),   0, 1, 0, 1, (GtkAttachOptions)(0), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
 255     gtk_table_attach(GTK_TABLE(decoTable), GTK_WIDGET(rightBox),  2, 3, 0, 1, (GtkAttachOptions)(0), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
 256
 257     gtk_table_attach(GTK_TABLE(decoTable), top_container->widget, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 15, 5);
 258     gtk_container_add( GTK_CONTAINER(eventbox), decoTable );
 259     gtk_widget_set_name( GTK_WIDGET(eventbox), "Calf-Plugin" );
 260
 261     // create window with viewport
 262 //    GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL);
 263 //    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 264 //    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_NONE);
 265 //    gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), GTK_WIDGET(decoTable));
 266
 267     return GTK_WIDGET(eventbox);
 268 }
 269
 270 void plugin_gui::send_configure(const char *key, const char *value)
 271 {
 272     // XXXKF this should really be replaced by a separate list of SCI-capable param controls
 273     for (unsigned int i = 0; i < params.size(); i++)
 274     {
 275         assert(params[i] != NULL);
 276         send_configure_iface *sci = dynamic_cast<send_configure_iface *>(params[i]);
 277         if (sci)
 278             sci->send_configure(key, value);
 279     }
 280 }
 281
 282 void plugin_gui::send_status(const char *key, const char *value)
 283 {
 284     // XXXKF this should really be replaced by a separate list of SUI-capable param controls
 285     for (unsigned int i = 0; i < params.size(); i++)
 286     {
 287         assert(params[i] != NULL);
 288         send_updates_iface *sui = dynamic_cast<send_updates_iface *>(params[i]);
 289         if (sui)
 290             sui->send_status(key, value);
 291     }
 292 }
 293
 294 void plugin_gui::remove_param_ctl(int param, param_control *ctl)
 295 {
 296     std::multimap<int, param_control *>::iterator it = par2ctl.find(param);
 297     while(it != par2ctl.end() && it->first == param)
 298     {
 299         if (it->second == ctl)
 300         {
 301             std::multimap<int, param_control *>::iterator orig = it;
 302             ++orig;
 303             par2ctl.erase(it, orig);
 304             it = orig;
 305         }
 306         else
 307             ++it;
 308     }
 309     unsigned last = params.size() - 1;
 310     for (unsigned i = 0; i < params.size(); ++i)
 311     {
 312         if (params[i] == ctl)
 313         {
 314             if (i != last)
 315                 std::swap(params[i], params[last]);
 316             params.erase(params.begin() + last, params.end());
 317         }
 318     }
 319 }
 320
 321 void plugin_gui::on_idle()
 322 {
 323     set<unsigned> changed;
 324     for (unsigned i = 0; i < read_serials.size(); i++)
 325     {
 326         int write_serial = plugin->get_write_serial(i);
 327         if (write_serial - read_serials[i] > 0)
 328         {
 329             read_serials[i] = write_serial;
 330             changed.insert(i);
 331         }
 332     }
 333     for (unsigned i = 0; i < params.size(); i++)
 334     {
 335         int param_no = params[i]->param_no;
 336         if (param_no != -1)
 337         {
 338             const parameter_properties &props = *plugin->get_metadata_iface()->get_param_props(param_no);
 339             bool is_output = (props.flags & PF_PROP_OUTPUT) != 0;
 340             if (is_output || (param_no != -1 && changed.count(param_no)))
 341                 params[i]->set();
 342         }
 343         params[i]->on_idle();
 344     }
 345     last_status_serial_no = plugin->send_status_updates(this, last_status_serial_no);
 346     // XXXKF iterate over par2ctl, too...
 347 }
 348
 349 void plugin_gui::refresh()
 350 {
 351     for (unsigned int i = 0; i < params.size(); i++)
 352         params[i]->set();
 353     plugin->send_configures(this);
 354     last_status_serial_no = plugin->send_status_updates(this, last_status_serial_no);
 355 }
 356
 357 void plugin_gui::refresh(int param_no, param_control *originator)
 358 {
 359     std::multimap<int, param_control *>::iterator it = par2ctl.find(param_no);
 360     while(it != par2ctl.end() && it->first == param_no)
 361     {
 362         if (it->second != originator)
 363             it->second->set();
 364         ++it;
 365     }
 366 }
 367
 368 void plugin_gui::set_param_value(int param_no, float value, param_control *originator)
 369 {
 370     plugin->set_param_value(param_no, value);
 371     refresh(param_no);
 372 }
 373
 374 /// Get a radio button group (if it exists) for a parameter
 375 GSList *plugin_gui::get_radio_group(int param)
 376 {
 377     map<int, GSList *>::const_iterator i = param_radio_groups.find(param);
 378     if (i == param_radio_groups.end())
 379         return NULL;
 380     else
 381         return i->second;
 382 }
 383
 384 /// Set a radio button group for a parameter
 385 void plugin_gui::set_radio_group(int param, GSList *group)
 386 {
 387     param_radio_groups[param] = group;
 388 }
 389
 390 void plugin_gui::show_rack_ears(bool show)
 391 {
 392     // if hidden, add a no-show-all attribute so that LV2 host doesn't accidentally override
 393     // the setting by doing a show_all on the outermost container
 394     gtk_widget_set_no_show_all(leftBox, !show);
 395     gtk_widget_set_no_show_all(rightBox, !show);
 396     if (show)
 397     {
 398         gtk_widget_show(leftBox);
 399         gtk_widget_show(rightBox);
 400     }
 401     else
 402     {
 403         gtk_widget_hide(leftBox);
 404         gtk_widget_hide(rightBox);
 405     }
 406 }
 407
 408 void plugin_gui::on_automation_add(GtkWidget *widget, void *user_data)
 409 {
 410     plugin_gui *self = (plugin_gui *)user_data;
 411     self->plugin->add_automation(self->context_menu_last_designator, automation_range(0, 1, self->context_menu_param_no));
 412 }
 413
 414 void plugin_gui::on_automation_delete(GtkWidget *widget, void *user_data)
 415 {
 416     automation_menu_entry *ame = (automation_menu_entry *)user_data;
 417     ame->gui->plugin->delete_automation(ame->source, ame->gui->context_menu_param_no);
 418 }
 419
 420 void plugin_gui::on_automation_set_lower_or_upper(automation_menu_entry *ame, bool is_upper)
 421 {
 422     const parameter_properties *props = plugin->get_metadata_iface()->get_param_props(context_menu_param_no);
 423     float mapped = props->to_01(plugin->get_param_value(context_menu_param_no));
 424
 425     automation_map mappings;
 426     plugin->get_automation(context_menu_param_no, mappings);
 427     automation_map::const_iterator i = mappings.find(ame->source);
 428     if (i != mappings.end())
 429     {
 430         if (is_upper)
 431             plugin->add_automation(context_menu_last_designator, automation_range(i->second.min_value, mapped, context_menu_param_no));
 432         else
 433             plugin->add_automation(context_menu_last_designator, automation_range(mapped, i->second.max_value, context_menu_param_no));
 434     }
 435 }
 436
 437 void plugin_gui::on_automation_set_lower(GtkWidget *widget, void *user_data)
 438 {
 439     automation_menu_entry *ame = (automation_menu_entry *)user_data;
 440     ame->gui->on_automation_set_lower_or_upper(ame, false);
 441 }
 442
 443 void plugin_gui::on_automation_set_upper(GtkWidget *widget, void *user_data)
 444 {
 445     automation_menu_entry *ame = (automation_menu_entry *)user_data;
 446     ame->gui->on_automation_set_lower_or_upper(ame, true);
 447 }
 448
 449 void plugin_gui::cleanup_automation_entries()
 450 {
 451     for (int i = 0; i < (int)automation_menu_callback_data.size(); i++)
 452         delete automation_menu_callback_data[i];
 453     automation_menu_callback_data.clear();
 454 }
 455
 456 void plugin_gui::on_control_popup(param_control *ctl, int param_no)
 457 {
 458     cleanup_automation_entries();
 459     if (param_no == -1)
 460         return;
 461     context_menu_param_no = param_no;
 462     GtkWidget *menu = gtk_menu_new();
 463
 464     multimap<uint32_t, automation_range> mappings;
 465     plugin->get_automation(param_no, mappings);
 466
 467     context_menu_last_designator = plugin->get_last_automation_source();
 468
 469     GtkWidget *item;
 470     if (context_menu_last_designator != 0xFFFFFFFF)
 471     {
 472         stringstream ss;
 473         ss << "_Bind to: Ch" << (1 + (context_menu_last_designator >> 8)) << ", CC#" << (context_menu_last_designator & 127);
 474         item = gtk_menu_item_new_with_mnemonic(ss.str().c_str());
 475         g_signal_connect(item, "activate", (GCallback)on_automation_add, this);
 476         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 477     }
 478     else
 479     {
 480         item = gtk_menu_item_new_with_label("Send CC to automate");
 481         gtk_widget_set_sensitive(item, FALSE);
 482         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 483     }
 484
 485     for(multimap<uint32_t, automation_range>::const_iterator i = mappings.begin(); i != mappings.end(); ++i)
 486     {
 487         automation_menu_entry *ame = new automation_menu_entry(this, i->first);
 488         automation_menu_callback_data.push_back(ame);
 489         stringstream ss;
 490         ss << "Mapping: Ch" << (1 + (i->first >> 8)) << ", CC#" << (i->first & 127);
 491         item = gtk_menu_item_new_with_label(ss.str().c_str());
 492         gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
 493
 494         GtkWidget *submenu = gtk_menu_new();
 495         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
 496
 497         item = gtk_menu_item_new_with_mnemonic("_Delete");
 498         g_signal_connect(item, "activate", (GCallback)on_automation_delete, ame);
 499         gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
 500
 501         item = gtk_menu_item_new_with_mnemonic("Set _lower limit");
 502         g_signal_connect(item, "activate", (GCallback)on_automation_set_lower, ame);
 503         gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
 504
 505         item = gtk_menu_item_new_with_mnemonic("Set _upper limit");
 506         g_signal_connect(item, "activate", (GCallback)on_automation_set_upper, ame);
 507         gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
 508         //g_signal_connect(item, "activate", (GCallback)on_automation_add, this);
 509
 510     }
 511
 512     gtk_widget_show_all(menu);
 513     gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time());
 514 }
 515
 516 void plugin_gui::destroy_child_widgets(GtkWidget *parent)
 517 {
 518     if (parent && GTK_IS_CONTAINER(parent))
 519     {
 520         GList *children = gtk_container_get_children(GTK_CONTAINER(parent));
 521         for(GList *p = children; p; p = p->next)
 522             gtk_widget_destroy(GTK_WIDGET(p->data));
 523         g_list_free(children);
 524     }
 525 }
 526
 527 plugin_gui::~plugin_gui()
 528 {
 529     cleanup_automation_entries();
 530     delete preset_access;
 531 }
 532
 533 /***************************** GUI environment ********************************************/
 534
 535 bool window_update_controller::check_redraw(GtkWidget *toplevel)
 536 {
 537     GdkWindow *gdkwin = gtk_widget_get_window(toplevel);
 538     if (!gdkwin)
 539         return false;
 540
 541     if (!gdk_window_is_viewable(gdkwin))
 542         return false;
 543     GdkWindowState state = gdk_window_get_state(gdkwin);
 544     if (state & GDK_WINDOW_STATE_ICONIFIED)
 545     {
 546         ++refresh_counter;
 547         if (refresh_counter & 15)
 548             return false;
 549     }
 550     return true;
 551 }
 552
 553 /***************************** GUI environment ********************************************/
 554
 555 gui_environment::gui_environment()
 556 {
 557     keyfile = g_key_file_new();
 558
 559     gchar *fn = g_build_filename(getenv("HOME"), ".calfrc", NULL);
 560     string filename = fn;
 561     g_free(fn);
 562     g_key_file_load_from_file(keyfile, filename.c_str(), (GKeyFileFlags)(G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS), NULL);
 563
 564     config_db = new calf_utils::gkeyfile_config_db(keyfile, filename.c_str(), "gui");
 565     gui_config.load(config_db);
 566 }
 567
 568 gui_environment::~gui_environment()
 569 {
 570     delete config_db;
 571     if (keyfile)
 572         g_key_file_free(keyfile);
 573 }