/[svn]/gigedit/trunk/src/gigedit/paramedit.h
ViewVC logotype

Diff of /gigedit/trunk/src/gigedit/paramedit.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1460 by persson, Sat Oct 27 12:28:33 2007 UTC revision 2690 by schoenebeck, Sun Jan 4 18:36:42 2015 UTC
# Line 1  Line 1 
1  /*                                                         -*- c++ -*-  /*                                                         -*- c++ -*-
2   * Copyright (C) 2006, 2007 Andreas Persson   * Copyright (C) 2006-2015 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 22  Line 22 
22    
23  #include <gig.h>  #include <gig.h>
24    
25  #include <math.h>  #include <cmath>
26    
27    #include <glibmm/convert.h>
28  #include <gtkmm/adjustment.h>  #include <gtkmm/adjustment.h>
29  #include <gtkmm/alignment.h>  #include <gtkmm/alignment.h>
30  #include <gtkmm/box.h>  #include <gtkmm/box.h>
31    #include <gtkmm/checkbutton.h>
32  #include <gtkmm/comboboxtext.h>  #include <gtkmm/comboboxtext.h>
33    #include <gtkmm/frame.h>
34  #include <gtkmm/label.h>  #include <gtkmm/label.h>
35  #include <gtkmm/scale.h>  #include <gtkmm/scale.h>
36  #include <gtkmm/spinbutton.h>  #include <gtkmm/spinbutton.h>
37    #include <gtkmm/table.h>
38    #include <gtkmm/textview.h>
39    
40    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 12) || GTKMM_MAJOR_VERSION < 2
41    #define OLD_TOOLTIPS
42  #include <gtkmm/tooltips.h>  #include <gtkmm/tooltips.h>
43    #endif
44    
45    
46    Glib::ustring gig_to_utf8(const gig::String& gig_string);
47    gig::String gig_from_utf8(const Glib::ustring& utf8_string);
48    
49    int note_value(const Glib::ustring& note);
50    Glib::ustring note_str(int note);
51    
52    void spin_button_show_notes(Gtk::SpinButton& spin_button);
53    
54  class LabelWidget {  class LabelWidget {
55  public:  public:
# Line 44  public: Line 62  public:
62          return sig_changed;          return sig_changed;
63      }      }
64  protected:  protected:
65    #ifdef OLD_TOOLTIPS
66      Gtk::Tooltips tooltips;      Gtk::Tooltips tooltips;
67    #endif
68      sigc::signal<void> sig_changed;      sigc::signal<void> sig_changed;
69  };  };
70    
71    class ReadOnlyLabelWidget : public LabelWidget {
72    public:
73        Gtk::Label text;
74    
75        ReadOnlyLabelWidget(const char* leftHandText);
76        ReadOnlyLabelWidget(const char* leftHandText, const char* rightHandText);
77    };
78    
79  class NumEntry : public LabelWidget {  class NumEntry : public LabelWidget {
80  protected:  protected:
81    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
82      Gtk::Adjustment adjust;      Gtk::Adjustment adjust;
83    #else
84        Glib::RefPtr<Gtk::Adjustment> adjust;
85    #endif
86      Gtk::HScale scale;      Gtk::HScale scale;
87      Gtk::SpinButton spinbutton;      Gtk::SpinButton spinbutton;
88      Gtk::HBox box;      Gtk::HBox box;
# Line 62  public: Line 94  public:
94      NumEntry(const char* labelText, double lower = 0, double upper = 127,      NumEntry(const char* labelText, double lower = 0, double upper = 127,
95               int decimals = 0);               int decimals = 0);
96      void set_tip(const Glib::ustring& tip_text) {      void set_tip(const Glib::ustring& tip_text) {
97    #ifdef OLD_TOOLTIPS
98          tooltips.set_tip(spinbutton, tip_text);          tooltips.set_tip(spinbutton, tip_text);
99    #else
100            spinbutton.set_tooltip_text(tip_text);
101    #endif
102      }      }
103      void set_upper(double upper) {      void set_upper(double upper) {
104    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
105          adjust.set_upper(upper);          adjust.set_upper(upper);
106    #else
107            adjust->set_upper(upper);
108    #endif
109      }      }
110  };  };
111    
# Line 118  void NumEntryTemp<T>::value_changed() Line 158  void NumEntryTemp<T>::value_changed()
158  template<typename T>  template<typename T>
159  void NumEntryTemp<T>::set_value(T value)  void NumEntryTemp<T>::set_value(T value)
160  {  {
161    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
162      if (value > adjust.get_upper()) value = T(adjust.get_upper());      if (value > adjust.get_upper()) value = T(adjust.get_upper());
163    #else
164        if (value > adjust->get_upper()) value = T(adjust->get_upper());
165    #endif
166      if (this->value != value) {      if (this->value != value) {
167          this->value = value;          this->value = value;
168          const double f = pow(10, spinbutton.get_digits());          const double f = pow(10, spinbutton.get_digits());
# Line 164  public: Line 208  public:
208      void set_choices(const char** texts, const T* values);      void set_choices(const char** texts, const T* values);
209    
210      void set_tip(const Glib::ustring& tip_text) {      void set_tip(const Glib::ustring& tip_text) {
211          tooltips.set_tip(combobox, tip_text); //FIXME: don't Gtk::ComboBoxes support tooltips ???  #ifdef OLD_TOOLTIPS
212            tooltips.set_tip(combobox, tip_text);
213    #else
214            combobox.set_tooltip_text(tip_text);
215    #endif
216      }      }
217  };  };
218    
219  template<typename T>  template<typename T>
220  ChoiceEntry<T>::ChoiceEntry(const char* labelText) :  ChoiceEntry<T>::ChoiceEntry(const char* labelText) :
221        LabelWidget(labelText, align),
222      align(0, 0, 0, 0),      align(0, 0, 0, 0),
223      LabelWidget(labelText, align)      values(0)
224  {  {
225      combobox.signal_changed().connect(sig_changed.make_slot());      combobox.signal_changed().connect(sig_changed.make_slot());
226      align.add(combobox);      align.add(combobox);
# Line 181  template<typename T> Line 230  template<typename T>
230  void ChoiceEntry<T>::set_choices(const char** texts, const T* values)  void ChoiceEntry<T>::set_choices(const char** texts, const T* values)
231  {  {
232      for (int i = 0 ; texts[i] ; i++) {      for (int i = 0 ; texts[i] ; i++) {
233    #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 24) || GTKMM_MAJOR_VERSION < 2
234          combobox.append_text(texts[i]);          combobox.append_text(texts[i]);
235    #else
236            combobox.append(texts[i]);
237    #endif
238      }      }
239      this->values = values;      this->values = values;
240  }  }
# Line 215  public: Line 268  public:
268      ChoiceEntryLeverageCtrl(const char* labelText);      ChoiceEntryLeverageCtrl(const char* labelText);
269      gig::leverage_ctrl_t get_value() const { return value; }      gig::leverage_ctrl_t get_value() const { return value; }
270      void set_value(gig::leverage_ctrl_t value);      void set_value(gig::leverage_ctrl_t value);
271        void set_tip(const Glib::ustring& tip_text) {
272            combobox.set_tooltip_text(tip_text);
273        }
274  };  };
275    
276    
# Line 227  public: Line 283  public:
283      void set_value(bool value) { checkbutton.set_active(value); }      void set_value(bool value) { checkbutton.set_active(value); }
284    
285      void set_tip(const Glib::ustring& tip_text) {      void set_tip(const Glib::ustring& tip_text) {
286    #ifdef OLD_TOOLTIPS
287          tooltips.set_tip(checkbutton, tip_text);          tooltips.set_tip(checkbutton, tip_text);
288    #else
289            checkbutton.set_tooltip_text(tip_text);
290    #endif
291      }      }
292  };  };
293    
# Line 244  public: Line 304  public:
304      void set_value(int32_t value);      void set_value(int32_t value);
305  };  };
306    
307    
308  class StringEntry : public LabelWidget {  class StringEntry : public LabelWidget {
309  private:  private:
310      Gtk::Entry entry;      Gtk::Entry entry;
     gig::String* ptr;  
     void value_changed();  
311  public:  public:
312      StringEntry(const char* labelText);      StringEntry(const char* labelText);
313      void set_ptr(gig::String* ptr);      gig::String get_value() const;
314        void set_value(const gig::String& value);
315        void set_width_chars(int n_chars) { entry.set_width_chars(n_chars); }
316    };
317    
318    class StringEntryMultiLine : public LabelWidget {
319    private:
320        Gtk::TextView text_view;
321        Glib::RefPtr<Gtk::TextBuffer> text_buffer;
322        Gtk::Frame frame;
323    public:
324        StringEntryMultiLine(const char* labelText);
325        gig::String get_value() const;
326        void set_value(const gig::String& value);
327  };  };
328    
329    
330    /**
331     * Container widget for LabelWidgets.
332     */
333    class Table : public Gtk::Table
334    {
335    public:
336        Table(int x, int y);
337        void add(BoolEntry& boolentry);
338        void add(BoolEntryPlus6& boolentry);
339        void add(LabelWidget& labelwidget);
340    private:
341        int rowno;
342    };
343    
344    
345    /**
346     * Base class for editor components that use LabelWidgets to edit
347     * member variables of the same class. By connecting the widgets to
348     * members of the model class, the model is automatically kept
349     * updated.
350     */
351    template<class M>
352    class PropEditor {
353    public:
354        sigc::signal<void>& signal_changed() {
355            return sig_changed;
356        }
357    protected:
358        M* m;
359        int update_model; // to prevent infinite update loops
360        PropEditor() : m(0), update_model(0) { }
361        sigc::signal<void> sig_changed;
362    
363        template<class C, typename T>
364        void connect(C& widget, T M::* member) {
365            // gcc 4.1.2 needs this temporary variable to resolve the
366            // address
367            void (PropEditor::*f)(const C* w, T M::* member) =
368                &PropEditor::set_member;
369            widget.signal_value_changed().connect(
370                sigc::bind(sigc::mem_fun(*this, f), &widget, member));
371    
372            void (PropEditor::*g)(C* w, T M::* member) =
373                &PropEditor::get_member;
374            sig.connect(
375                sigc::bind(sigc::mem_fun(*this, g), &widget, member));
376        }
377    
378        template<class C, class S, typename T>
379        void connect(C& widget, void (S::*setter)(T)) {
380            void (PropEditor::*f)(const C* w, void (S::*setter)(T)) =
381                &PropEditor<M>::call_setter;
382            widget.signal_value_changed().connect(
383                sigc::bind(sigc::mem_fun(*this, f), &widget, setter));
384        }
385    
386        void connect(NoteEntry& eKeyRangeLow, NoteEntry& eKeyRangeHigh,
387                     gig::range_t M::* range) {
388            eKeyRangeLow.signal_value_changed().connect(
389                sigc::bind(
390                    sigc::mem_fun(*this, &PropEditor::key_range_low_changed),
391                    &eKeyRangeLow, &eKeyRangeHigh, range));
392            eKeyRangeHigh.signal_value_changed().connect(
393                sigc::bind(
394                    sigc::mem_fun(*this, &PropEditor::key_range_high_changed),
395                    &eKeyRangeLow, &eKeyRangeHigh, range));
396            sig.connect(
397                sigc::bind(sigc::mem_fun(*this, &PropEditor::get_key_range),
398                           &eKeyRangeLow, &eKeyRangeHigh, range));
399        }
400    
401        void update(M* m) {
402            update_model++;
403            this->m = m;
404            sig.emit();
405            update_model--;
406        }
407    
408    private:
409        sigc::signal<void> sig;
410    
411        void key_range_low_changed(NoteEntry* eKeyRangeLow,
412                                   NoteEntry* eKeyRangeHigh,
413                                   gig::range_t M::* range) {
414            if (update_model == 0) {
415                uint8_t value = eKeyRangeLow->get_value();
416                (m->*range).low = value;
417                if (value > (m->*range).high) {
418                    eKeyRangeHigh->set_value(value);
419                }
420                sig_changed();
421            }
422        }
423    
424        void key_range_high_changed(NoteEntry* eKeyRangeLow,
425                                    NoteEntry* eKeyRangeHigh,
426                                    gig::range_t M::* range) {
427            if (update_model == 0) {
428                uint8_t value = eKeyRangeHigh->get_value();
429                (m->*range).high = value;
430                if (value < (m->*range).low) {
431                    eKeyRangeLow->set_value(value);
432                }
433                sig_changed();
434            }
435        }
436    
437        template<class C, typename T>
438        void set_member(const C* w, T M::* member) {
439            if (update_model == 0) {
440                m->*member = w->get_value();
441                sig_changed();
442            }
443        }
444    
445        template<class C, typename T>
446        void get_member(C* w, T M::* member) {
447            w->set_value(m->*member);
448        }
449    
450        void get_key_range(NoteEntry* eKeyRangeLow,
451                           NoteEntry* eKeyRangeHigh,
452                           gig::range_t M::* range) {
453            eKeyRangeLow->set_value((m->*range).low);
454            eKeyRangeHigh->set_value((m->*range).high);
455        }
456    
457        template<class C, class S, typename T>
458        void call_setter(const C* w, void (S::*setter)(T)) {
459            if (update_model == 0) {
460                (static_cast<S*>(this)->*setter)(w->get_value());
461                sig_changed();
462            }
463        }
464    };
465    
466  #endif  #endif
Legend:
Removed from v.1460  
changed lines
  Added in v.2690
  ViewVC Help
Powered by ViewVC