src/calf/gui.h

   1 /* Calf DSP Library
   2  * Universal GUI module
   3  * Copyright (C) 2007 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., 59 Temple Place, Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20 #ifndef __CALF_GUI_H
  21 #define __CALF_GUI_H
  22
  23 #include <expat.h>
  24 #include <map>
  25 #include <set>
  26 #include <vector>
  27 #include <gtk/gtk.h>
  28 #include "custom_ctl.h"
  29
  30 struct CalfCurve;
  31 struct CalfKeyboard;
  32 struct CalfLed;
  33
  34 namespace calf_plugins {
  35
  36 class plugin_gui;
  37
  38 struct control_base
  39 {
  40     typedef std::map<std::string, std::string> xml_attribute_map;
  41     xml_attribute_map attribs;
  42     plugin_gui *gui;
  43     void require_attribute(const char *name);
  44     void require_int_attribute(const char *name);
  45     int get_int(const char *name, int def_value = 0);
  46     float get_float(const char *name, float def_value = 0.f);
  47 };
  48
  49 #define _GUARD_CHANGE_ if (in_change) return; guard_change __gc__(this);
  50
  51 struct param_control: public control_base
  52 {
  53     int param_no;
  54     GtkWidget *label, *widget;
  55     int in_change;
  56
  57     struct guard_change {
  58         param_control *pc;
  59         guard_change(param_control *_pc) : pc(_pc) { pc->in_change++; }
  60         ~guard_change() { pc->in_change--; }
  61     };
  62
  63     param_control() { gui = NULL; param_no = -1; label = NULL; in_change = 0;}
  64     inline parameter_properties &get_props();
  65
  66     virtual void init_xml(const char *element) {}
  67     virtual GtkWidget *create_label();
  68     virtual void update_label();
  69     /// called to create a widget for a control
  70     virtual GtkWidget *create(plugin_gui *_gui, int _param_no)=0;
  71     /// called to transfer the value from control to parameter(s)
  72     virtual void get()=0;
  73     /// called to transfer the value from parameter(s) to control
  74     virtual void set()=0;
  75     /// called on DSSI configure()
  76     virtual void configure(const char *key, const char *value) {}
  77     virtual void hook_params();
  78     virtual void on_idle() {}
  79     virtual ~param_control();
  80 };
  81
  82 struct control_container: public control_base
  83 {
  84     GtkContainer *container;
  85
  86     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes)=0;
  87     virtual void add(GtkWidget *w, control_base *base) { gtk_container_add(container, w); }
  88     virtual ~control_container() {}
  89 };
  90
  91 struct table_container: public control_container
  92 {
  93     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
  94     virtual void add(GtkWidget *w, control_base *base);
  95 };
  96
  97 struct alignment_container: public control_container
  98 {
  99     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 100 };
 101
 102 struct frame_container: public control_container
 103 {
 104     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 105 };
 106
 107 struct box_container: public control_container
 108 {
 109     virtual void add(GtkWidget *w, control_base *base);
 110 };
 111
 112 struct vbox_container: public box_container
 113 {
 114     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 115 };
 116
 117 struct hbox_container: public box_container
 118 {
 119     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 120 };
 121
 122 struct notebook_container: public control_container
 123 {
 124     virtual void add(GtkWidget *w, control_base *base);
 125     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 126 };
 127
 128 struct scrolled_container: public control_container
 129 {
 130     virtual void add(GtkWidget *w, control_base *base);
 131     virtual GtkWidget *create(plugin_gui *_gui, const char *element, xml_attribute_map &attributes);
 132 };
 133
 134 /// Display-only control: static text
 135 struct label_param_control: public param_control
 136 {
 137     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 138     virtual void get() {}
 139     virtual void set() {}
 140 };
 141
 142 /// Display-only control: value text
 143 struct value_param_control: public param_control
 144 {
 145     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 146     virtual void get() {}
 147     virtual void set();
 148 };
 149
 150 /// Display-only control: volume meter
 151 struct vumeter_param_control: public param_control
 152 {
 153     CalfVUMeter *meter;
 154
 155     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 156     virtual void get() {}
 157     virtual void set();
 158 };
 159
 160 /// Display-only control: LED
 161 struct led_param_control: public param_control
 162 {
 163     CalfLed *meter;
 164
 165     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 166     virtual void get() {}
 167     virtual void set();
 168 };
 169
 170 /// Horizontal slider
 171 struct hscale_param_control: public param_control
 172 {
 173     GtkHScale *scale;
 174
 175     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 176     virtual void get();
 177     virtual void set();
 178     virtual void init_xml(const char *element);
 179     static void hscale_value_changed(GtkHScale *widget, gpointer value);
 180     static gchar *hscale_format_value(GtkScale *widget, double arg1, gpointer value);
 181 };
 182
 183 /// Vertical slider
 184 struct vscale_param_control: public param_control
 185 {
 186     GtkVScale *scale;
 187
 188     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 189     virtual void get();
 190     virtual void set();
 191     virtual void init_xml(const char *element);
 192     static void vscale_value_changed(GtkHScale *widget, gpointer value);
 193 };
 194
 195 /// Spin button
 196 struct spin_param_control: public param_control
 197 {
 198     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 199     virtual void get();
 200     virtual void set();
 201     static void value_changed(GtkSpinButton *widget, gpointer value);
 202 };
 203
 204 struct toggle_param_control: public param_control
 205 {
 206     GtkCheckButton *scale;
 207
 208     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 209     virtual void get();
 210     virtual void set();
 211     static void toggle_value_changed(GtkCheckButton *widget, gpointer value);
 212 };
 213
 214 struct button_param_control: public param_control
 215 {
 216     GtkCheckButton *scale;
 217
 218     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 219     virtual void get();
 220     virtual void set();
 221     static void button_clicked(GtkButton *widget, gpointer value);
 222 };
 223
 224 struct combo_box_param_control: public param_control
 225 {
 226     GtkComboBox *scale;
 227
 228     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 229     virtual void get();
 230     virtual void set();
 231     static void combo_value_changed(GtkComboBox *widget, gpointer value);
 232 };
 233
 234 struct line_graph_param_control: public param_control
 235 {
 236     CalfLineGraph *graph;
 237     int last_generation;
 238
 239     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 240     virtual void get() {}
 241     virtual void set();
 242     virtual void on_idle();
 243     virtual ~line_graph_param_control();
 244 };
 245
 246 struct knob_param_control: public param_control
 247 {
 248     CalfKnob *knob;
 249
 250     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 251     virtual void get();
 252     virtual void set();
 253     static void knob_value_changed(GtkWidget *widget, gpointer value);
 254 };
 255
 256 struct keyboard_param_control: public param_control
 257 {
 258     CalfKeyboard *kb;
 259
 260     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 261     virtual void get() {}
 262     virtual void set() {}
 263 };
 264
 265 struct curve_param_control: public param_control, public send_configure_iface
 266 {
 267     CalfCurve *curve;
 268
 269     virtual GtkWidget *create(plugin_gui *_gui, int _param_no);
 270     virtual void get() {}
 271     virtual void set() {}
 272     virtual void send_configure(const char *key, const char *value);
 273 };
 274
 275 class plugin_gui_window;
 276
 277 class plugin_gui: public send_configure_iface
 278 {
 279 protected:
 280     int param_count;
 281     std::multimap<int, param_control *> par2ctl;
 282     XML_Parser parser;
 283     param_control *current_control;
 284     std::vector<control_container *> container_stack;
 285     control_container *top_container;
 286     std::map<std::string, int> param_name_map;
 287     int ignore_stack;
 288 public:
 289     plugin_gui_window *window;
 290     GtkWidget *container;
 291     const char *effect_name;
 292     plugin_ctl_iface *plugin;
 293     std::vector<param_control *> params;
 294
 295     plugin_gui(plugin_gui_window *_window);
 296     GtkWidget *create_from_xml(plugin_ctl_iface *_plugin, const char *xml);
 297     param_control *create_control_from_xml(const char *element, const char *attributes[]);
 298     control_container *create_container_from_xml(const char *element, const char *attributes[]);
 299
 300     void add_param_ctl(int param, param_control *ctl) { par2ctl.insert(std::pair<int, param_control *>(param, ctl)); }
 301     void refresh();
 302     void refresh(int param_no, param_control *originator = NULL);
 303     void xml_element_start(const char *element, const char *attributes[]);
 304     void set_param_value(int param_no, float value, param_control *originator = NULL);
 305     void send_configure(const char *key, const char *value);
 306     void on_idle();
 307     ~plugin_gui();
 308     static void xml_element_start(void *data, const char *element, const char *attributes[]);
 309     static void xml_element_end(void *data, const char *element);
 310 };
 311
 312 class main_window_owner_iface;
 313
 314 class main_window_iface
 315 {
 316 public:
 317     virtual void set_owner(main_window_owner_iface *owner)=0;
 318
 319     virtual void add_plugin(plugin_ctl_iface *plugin)=0;
 320     virtual void del_plugin(plugin_ctl_iface *plugin)=0;
 321
 322     virtual void set_window(plugin_ctl_iface *plugin, plugin_gui_window *window)=0;
 323     virtual void refresh_all_presets(bool builtin_too)=0;
 324     virtual bool check_condition(const char *name)=0;
 325     virtual ~main_window_iface() {}
 326 };
 327
 328 class main_window_owner_iface
 329 {
 330 public:
 331     virtual void new_plugin(const char *name) = 0;
 332     virtual void remove_plugin(plugin_ctl_iface *plugin) = 0;
 333     virtual ~main_window_owner_iface() {}
 334 };
 335
 336 class plugin_gui_window
 337 {
 338 public:
 339     plugin_gui *gui;
 340     GtkWindow *toplevel;
 341     GtkUIManager *ui_mgr;
 342     GtkActionGroup *std_actions, *builtin_preset_actions, *user_preset_actions, *command_actions;
 343     main_window_iface *main;
 344     int source_id;
 345
 346     plugin_gui_window(main_window_iface *_main);
 347     std::string make_gui_preset_list(GtkActionGroup *grp, bool builtin, char &ch);
 348     std::string make_gui_command_list(GtkActionGroup *grp);
 349     void fill_gui_presets(bool builtin, char &ch);
 350     void create(plugin_ctl_iface *_plugin, const char *title, const char *effect);
 351     void close();
 352     static gboolean on_idle(void *data);
 353     ~plugin_gui_window();
 354 };
 355
 356
 357 inline parameter_properties &param_control::get_props()
 358 {
 359     return  *gui->plugin->get_param_props(param_no);
 360 }
 361
 362 class null_audio_module;
 363
 364 struct activate_command_params
 365 {
 366     typedef void (*CommandFunc)(null_audio_module *);
 367     plugin_gui *gui;
 368     int function_idx;
 369
 370     activate_command_params(plugin_gui *_gui, int _idx)
 371     : gui(_gui), function_idx(_idx)
 372     {
 373     }
 374 };
 375
 376 void activate_command(GtkAction *action, activate_command_params *params);
 377
 378 };
 379
 380 #endif