/[svn]/gigedit/trunk/src/gigedit/mainwindow.cpp
ViewVC logotype

Annotation of /gigedit/trunk/src/gigedit/mainwindow.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3811 - (hide annotations) (download)
Fri Aug 14 11:54:49 2020 UTC (3 years, 7 months ago) by schoenebeck
File size: 233350 byte(s)
* Fixed wrong instruments being duplicated if instrument name filter was
  used.

* Bumped version (1.1.1.svn28).

1 schoenebeck 1225 /*
2 schoenebeck 3711 * Copyright (C) 2006-2020 Andreas Persson
3 schoenebeck 1225 *
4     * This program is free software; you can redistribute it and/or
5     * modify it under the terms of the GNU General Public License as
6     * published by the Free Software Foundation; either version 2, or (at
7     * your option) any later version.
8     *
9     * This program is distributed in the hope that it will be useful, but
10     * WITHOUT ANY WARRANTY; without even the implied warranty of
11     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12     * General Public License for more details.
13     *
14     * You should have received a copy of the GNU General Public License
15     * along with program; see the file COPYING. If not, write to the Free
16     * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
17     * 02110-1301 USA.
18     */
19    
20     #include <iostream>
21 persson 1714 #include <cstring>
22 schoenebeck 1225
23 schoenebeck 3364 #include "compat.h"
24 persson 2841
25 persson 2325 #include <glibmm/convert.h>
26     #include <glibmm/dispatcher.h>
27     #include <glibmm/miscutils.h>
28     #include <glibmm/stringutils.h>
29 schoenebeck 3340 #include <glibmm/regex.h>
30 persson 2151 #include <gtkmm/aboutdialog.h>
31 schoenebeck 1225 #include <gtkmm/filechooserdialog.h>
32     #include <gtkmm/messagedialog.h>
33 schoenebeck 3364 #if HAS_GTKMM_STOCK
34     # include <gtkmm/stock.h>
35     #endif
36 schoenebeck 1225 #include <gtkmm/targetentry.h>
37     #include <gtkmm/main.h>
38 schoenebeck 3364 #if GTKMM_MAJOR_VERSION < 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION < 89)
39     # include <gtkmm/toggleaction.h>
40     #endif
41 schoenebeck 3157 #include <gtkmm/accelmap.h>
42 persson 2344 #if GTKMM_MAJOR_VERSION < 3
43 persson 1799 #include "wrapLabel.hh"
44 persson 2344 #endif
45 schoenebeck 1225
46 schoenebeck 1396 #include "global.h"
47 persson 2169 #include "compat.h"
48 schoenebeck 1396
49 schoenebeck 1225 #include <stdio.h>
50 schoenebeck 3364 #ifdef LIBSNDFILE_HEADER_FILE
51     # include LIBSNDFILE_HEADER_FILE(sndfile.h)
52     #else
53     # include <sndfile.h>
54     #endif
55 schoenebeck 2553 #include <assert.h>
56 schoenebeck 1225
57     #include "mainwindow.h"
58 schoenebeck 2541 #include "Settings.h"
59 schoenebeck 2548 #include "CombineInstrumentsDialog.h"
60 schoenebeck 2604 #include "scripteditor.h"
61 schoenebeck 2610 #include "scriptslots.h"
62 schoenebeck 2624 #include "ReferencesView.h"
63 schoenebeck 1411 #include "../../gfx/status_attached.xpm"
64     #include "../../gfx/status_detached.xpm"
65 schoenebeck 3106 #include "gfx/builtinpix.h"
66 schoenebeck 3151 #include "MacroEditor.h"
67 schoenebeck 3157 #include "MacrosSetup.h"
68 schoenebeck 3258 #if defined(__APPLE__)
69     # include "MacHelper.h"
70     #endif
71 schoenebeck 1411
72 schoenebeck 3299 static const Gdk::ModifierType primaryModifierKey =
73     #if defined(__APPLE__)
74     Gdk::META_MASK; // Cmd key on Mac
75     #else
76     Gdk::CONTROL_MASK; // Ctrl key on all other OSs
77     #endif
78    
79 persson 1533 MainWindow::MainWindow() :
80 schoenebeck 2626 m_DimRegionChooser(*this),
81 persson 1533 dimreg_label(_("Changes apply to:")),
82     dimreg_all_regions(_("all regions")),
83     dimreg_all_dimregs(_("all dimension splits")),
84 schoenebeck 3106 dimreg_stereo(_("both channels")),
85 schoenebeck 3109 labelLegend(_("Legend:")),
86 schoenebeck 3106 labelNoSample(_(" No Sample")),
87     labelMissingSample(_(" Missing some Sample(s)")),
88     labelLooped(_(" Looped")),
89     labelSomeLoops(_(" Some Loop(s)"))
90 schoenebeck 1225 {
91 schoenebeck 3106 loadBuiltInPix();
92    
93 schoenebeck 3339 this->file = NULL;
94    
95 schoenebeck 1225 // set_border_width(5);
96    
97 schoenebeck 3225 if (!Settings::singleton()->autoRestoreWindowDimension) {
98 schoenebeck 3368 #if GTKMM_MAJOR_VERSION >= 3
99 schoenebeck 3737 set_default_size(1010, -1);
100 schoenebeck 3368 #else
101 schoenebeck 3737 set_default_size(915, -1);
102 schoenebeck 3368 #endif
103 schoenebeck 3225 set_position(Gtk::WIN_POS_CENTER);
104     }
105    
106 schoenebeck 1225 add(m_VBox);
107    
108     // Handle selection
109 schoenebeck 3806 m_TreeViewInstruments.get_selection()->signal_changed().connect(
110 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_sel_change));
111    
112 schoenebeck 3806 // m_TreeViewInstruments.set_reorderable();
113 schoenebeck 1225
114 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
115 schoenebeck 3806 m_TreeViewInstruments.signal_button_press_event().connect(
116 schoenebeck 3364 sigc::mem_fun(*this, &MainWindow::on_button_release));
117     #else
118 schoenebeck 3806 m_TreeViewInstruments.signal_button_press_event().connect_notify(
119 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_button_release));
120 schoenebeck 3364 #endif
121 schoenebeck 1225
122     // Add the TreeView tab, inside a ScrolledWindow, with the button underneath:
123 schoenebeck 3806 m_ScrolledWindow.add(m_TreeViewInstruments);
124 schoenebeck 1225 // m_ScrolledWindow.set_size_request(200, 600);
125     m_ScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
126    
127     m_ScrolledWindowSamples.add(m_TreeViewSamples);
128     m_ScrolledWindowSamples.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
129    
130 schoenebeck 2604 m_ScrolledWindowScripts.add(m_TreeViewScripts);
131     m_ScrolledWindowScripts.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
132 schoenebeck 1225
133 schoenebeck 3368 #if GTKMM_MAJOR_VERSION < 3
134 schoenebeck 1225 m_TreeViewNotebook.set_size_request(300);
135 schoenebeck 3368 #endif
136 schoenebeck 1225
137 schoenebeck 3340 m_searchLabel.set_text(Glib::ustring(" ") + _("Filter:"));
138     m_searchField.pack_start(m_searchLabel, Gtk::PACK_SHRINK);
139     m_searchField.pack_start(m_searchText);
140     m_searchField.set_spacing(5);
141    
142     m_left_vbox.pack_start(m_TreeViewNotebook);
143     m_left_vbox.pack_start(m_searchField, Gtk::PACK_SHRINK);
144    
145     m_HPaned.add1(m_left_vbox);
146    
147 persson 1533 dimreg_hbox.add(dimreg_label);
148     dimreg_hbox.add(dimreg_all_regions);
149     dimreg_hbox.add(dimreg_all_dimregs);
150     dimreg_stereo.set_active();
151     dimreg_hbox.add(dimreg_stereo);
152     dimreg_vbox.add(dimreg_edit);
153 persson 1582 dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);
154 schoenebeck 3106 {
155 schoenebeck 3109 legend_hbox.add(labelLegend);
156    
157 schoenebeck 3106 imageNoSample.set(redDot);
158 schoenebeck 3364 #if HAS_GTKMM_ALIGNMENT
159 schoenebeck 3108 imageNoSample.set_alignment(Gtk::ALIGN_END);
160     labelNoSample.set_alignment(Gtk::ALIGN_START);
161 schoenebeck 3364 #else
162     imageNoSample.set_halign(Gtk::ALIGN_END);
163     labelNoSample.set_halign(Gtk::ALIGN_START);
164     #endif
165 schoenebeck 3106 legend_hbox.add(imageNoSample);
166     legend_hbox.add(labelNoSample);
167    
168     imageMissingSample.set(yellowDot);
169 schoenebeck 3364 #if HAS_GTKMM_ALIGNMENT
170 schoenebeck 3108 imageMissingSample.set_alignment(Gtk::ALIGN_END);
171     labelMissingSample.set_alignment(Gtk::ALIGN_START);
172 schoenebeck 3364 #else
173     imageMissingSample.set_halign(Gtk::ALIGN_END);
174     labelMissingSample.set_halign(Gtk::ALIGN_START);
175     #endif
176 schoenebeck 3106 legend_hbox.add(imageMissingSample);
177     legend_hbox.add(labelMissingSample);
178    
179     imageLooped.set(blackLoop);
180 schoenebeck 3364 #if HAS_GTKMM_ALIGNMENT
181 schoenebeck 3108 imageLooped.set_alignment(Gtk::ALIGN_END);
182     labelLooped.set_alignment(Gtk::ALIGN_START);
183 schoenebeck 3364 #else
184     imageLooped.set_halign(Gtk::ALIGN_END);
185     labelLooped.set_halign(Gtk::ALIGN_START);
186     #endif
187 schoenebeck 3106 legend_hbox.add(imageLooped);
188     legend_hbox.add(labelLooped);
189    
190     imageSomeLoops.set(grayLoop);
191 schoenebeck 3364 #if HAS_GTKMM_ALIGNMENT
192 schoenebeck 3108 imageSomeLoops.set_alignment(Gtk::ALIGN_END);
193     labelSomeLoops.set_alignment(Gtk::ALIGN_START);
194 schoenebeck 3364 #else
195     imageSomeLoops.set_halign(Gtk::ALIGN_END);
196     labelSomeLoops.set_halign(Gtk::ALIGN_START);
197     #endif
198 schoenebeck 3106 legend_hbox.add(imageSomeLoops);
199     legend_hbox.add(labelSomeLoops);
200    
201 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
202 schoenebeck 3106 legend_hbox.show_all_children();
203 schoenebeck 3364 #endif
204 schoenebeck 3106 }
205     dimreg_vbox.pack_start(legend_hbox, Gtk::PACK_SHRINK);
206 persson 1533 m_HPaned.add2(dimreg_vbox);
207 schoenebeck 1225
208 schoenebeck 2536 dimreg_label.set_tooltip_text(_("To automatically apply your changes above globally to the entire instrument, check all 3 check boxes on the right."));
209     dimreg_all_regions.set_tooltip_text(_("If checked: all changes you perform above will automatically be applied to all regions of this instrument as well."));
210     dimreg_all_dimregs.set_tooltip_text(_("If checked: all changes you perform above will automatically be applied as well to all dimension splits of the region selected below."));
211     dimreg_stereo.set_tooltip_text(_("If checked: all changes you perform above will automatically be applied to both audio channel splits (only if a \"stereo\" dimension is defined below)."));
212 schoenebeck 1225
213 persson 1831 m_TreeViewNotebook.append_page(m_ScrolledWindowSamples, _("Samples"));
214     m_TreeViewNotebook.append_page(m_ScrolledWindow, _("Instruments"));
215 schoenebeck 2604 m_TreeViewNotebook.append_page(m_ScrolledWindowScripts, _("Scripts"));
216 schoenebeck 1225
217 schoenebeck 3364 #if USE_GLIB_ACTION
218     m_actionGroup = Gio::SimpleActionGroup::create();
219     m_actionGroup->add_action(
220     "New", sigc::mem_fun(*this, &MainWindow::on_action_file_new)
221     );
222     m_actionGroup->add_action(
223     "Open", sigc::mem_fun(*this, &MainWindow::on_action_file_open)
224     );
225     m_actionGroup->add_action(
226     "Save", sigc::mem_fun(*this, &MainWindow::on_action_file_save)
227     );
228     m_actionGroup->add_action(
229     "SaveAs", sigc::mem_fun(*this, &MainWindow::on_action_file_save_as)
230     );
231     m_actionGroup->add_action(
232     "Properties", sigc::mem_fun(*this, &MainWindow::on_action_file_properties)
233     );
234     m_actionGroup->add_action(
235     "InstrProperties", sigc::mem_fun(*this, &MainWindow::show_instr_props)
236     );
237     m_actionMIDIRules = m_actionGroup->add_action(
238     "MidiRules", sigc::mem_fun(*this, &MainWindow::show_midi_rules)
239     );
240     m_actionGroup->add_action(
241     "ScriptSlots", sigc::mem_fun(*this, &MainWindow::show_script_slots)
242     );
243     m_actionGroup->add_action(
244     "Quit", sigc::mem_fun(*this, &MainWindow::on_action_quit)
245     );
246     m_actionGroup->add_action(
247     "MenuSample", sigc::mem_fun(*this, &MainWindow::show_samples_tab)
248     );
249     m_actionGroup->add_action(
250     "MenuInstrument", sigc::mem_fun(*this, &MainWindow::show_intruments_tab)
251     );
252     m_actionGroup->add_action(
253     "MenuScript", sigc::mem_fun(*this, &MainWindow::show_scripts_tab)
254     );
255     #else
256 schoenebeck 1225 actionGroup = Gtk::ActionGroup::create();
257    
258     actionGroup->add(Gtk::Action::create("MenuFile", _("_File")));
259 schoenebeck 3158 actionGroup->add(Gtk::Action::create("New", Gtk::Stock::NEW),
260 schoenebeck 1225 sigc::mem_fun(
261     *this, &MainWindow::on_action_file_new));
262 schoenebeck 3158 Glib::RefPtr<Gtk::Action> action =
263     Gtk::Action::create("Open", Gtk::Stock::OPEN);
264     action->property_label() = action->property_label() + "...";
265     actionGroup->add(action,
266 schoenebeck 1225 sigc::mem_fun(
267     *this, &MainWindow::on_action_file_open));
268 schoenebeck 3158 actionGroup->add(Gtk::Action::create("Save", Gtk::Stock::SAVE),
269 schoenebeck 1225 sigc::mem_fun(
270     *this, &MainWindow::on_action_file_save));
271 schoenebeck 3158 action = Gtk::Action::create("SaveAs", Gtk::Stock::SAVE_AS);
272     action->property_label() = action->property_label() + "...";
273     actionGroup->add(action,
274 persson 1261 Gtk::AccelKey("<shift><control>s"),
275 schoenebeck 1225 sigc::mem_fun(
276 persson 1261 *this, &MainWindow::on_action_file_save_as));
277 schoenebeck 1225 actionGroup->add(Gtk::Action::create("Properties",
278 schoenebeck 3158 Gtk::Stock::PROPERTIES),
279 schoenebeck 1225 sigc::mem_fun(
280     *this, &MainWindow::on_action_file_properties));
281     actionGroup->add(Gtk::Action::create("InstrProperties",
282 schoenebeck 3158 Gtk::Stock::PROPERTIES),
283 schoenebeck 1225 sigc::mem_fun(
284     *this, &MainWindow::show_instr_props));
285 persson 2507 actionGroup->add(Gtk::Action::create("MidiRules",
286 schoenebeck 2610 _("_Midi Rules...")),
287 persson 2507 sigc::mem_fun(
288     *this, &MainWindow::show_midi_rules));
289 schoenebeck 2610 actionGroup->add(Gtk::Action::create("ScriptSlots",
290     _("_Script Slots...")),
291     sigc::mem_fun(
292     *this, &MainWindow::show_script_slots));
293 schoenebeck 3158 actionGroup->add(Gtk::Action::create("Quit", Gtk::Stock::QUIT),
294 schoenebeck 1225 sigc::mem_fun(
295 persson 1261 *this, &MainWindow::on_action_quit));
296 schoenebeck 2625 actionGroup->add(
297     Gtk::Action::create("MenuSample", _("_Sample")),
298     sigc::mem_fun(*this, &MainWindow::show_samples_tab)
299     );
300     actionGroup->add(
301     Gtk::Action::create("MenuInstrument", _("_Instrument")),
302     sigc::mem_fun(*this, &MainWindow::show_intruments_tab)
303     );
304     actionGroup->add(
305 schoenebeck 3144 Gtk::Action::create("MenuScript", _("Scr_ipt")),
306 schoenebeck 2625 sigc::mem_fun(*this, &MainWindow::show_scripts_tab)
307     );
308     actionGroup->add(Gtk::Action::create("AllInstruments", _("_Select")));
309 schoenebeck 3339 actionGroup->add(Gtk::Action::create("AssignScripts", _("Assign Script")));
310 schoenebeck 1225
311 schoenebeck 2464 actionGroup->add(Gtk::Action::create("MenuEdit", _("_Edit")));
312 schoenebeck 3364 #endif
313 schoenebeck 2464
314 schoenebeck 3123 const Gdk::ModifierType primaryModifierKey =
315     #if defined(__APPLE__)
316     Gdk::META_MASK; // Cmd key on Mac
317     #else
318     Gdk::CONTROL_MASK; // Ctrl key on all other OSs
319     #endif
320    
321 schoenebeck 3364 #if USE_GLIB_ACTION
322     m_actionCopyDimRgn = m_actionGroup->add_action(
323     "CopyDimRgn", sigc::mem_fun(*this, &MainWindow::copy_selected_dimrgn)
324     );
325     m_actionPasteDimRgn = m_actionGroup->add_action(
326     "PasteDimRgn", sigc::mem_fun(*this, &MainWindow::paste_copied_dimrgn)
327     );
328     m_actionAdjustClipboard = m_actionGroup->add_action(
329     "AdjustClipboard", sigc::mem_fun(*this, &MainWindow::adjust_clipboard_content)
330     );
331     m_actionGroup->add_action(
332     "SelectPrevInstr", sigc::mem_fun(*this, &MainWindow::select_prev_instrument)
333     );
334     m_actionGroup->add_action(
335     "SelectNextInstr", sigc::mem_fun(*this, &MainWindow::select_next_instrument)
336     );
337     m_actionGroup->add_action(
338     "SelectPrevRegion", sigc::mem_fun(*this, &MainWindow::select_prev_region)
339     );
340     m_actionGroup->add_action(
341     "SelectNextRegion", sigc::mem_fun(*this, &MainWindow::select_next_region)
342     );
343     m_actionGroup->add_action(
344     "SelectPrevDimRgnZone", sigc::mem_fun(*this, &MainWindow::select_prev_dim_rgn_zone)
345     );
346     m_actionGroup->add_action(
347     "SelectNextDimRgnZone", sigc::mem_fun(*this, &MainWindow::select_next_dim_rgn_zone)
348     );
349     m_actionGroup->add_action(
350     "SelectPrevDimension", sigc::mem_fun(*this, &MainWindow::select_prev_dimension)
351     );
352     m_actionGroup->add_action(
353     "SelectNextDimension", sigc::mem_fun(*this, &MainWindow::select_next_dimension)
354     );
355     m_actionGroup->add_action(
356     "SelectAddPrevDimRgnZone", sigc::mem_fun(*this, &MainWindow::select_add_prev_dim_rgn_zone)
357     );
358     m_actionGroup->add_action(
359     "SelectAddNextDimRgnZone", sigc::mem_fun(*this, &MainWindow::select_add_next_dim_rgn_zone)
360     );
361     #else
362 schoenebeck 3144 actionGroup->add(Gtk::Action::create("CopyDimRgn",
363     _("Copy selected dimension region")),
364     Gtk::AccelKey(GDK_KEY_c, Gdk::MOD1_MASK),
365     sigc::mem_fun(*this, &MainWindow::copy_selected_dimrgn));
366    
367     actionGroup->add(Gtk::Action::create("PasteDimRgn",
368     _("Paste dimension region")),
369     Gtk::AccelKey(GDK_KEY_v, Gdk::MOD1_MASK),
370     sigc::mem_fun(*this, &MainWindow::paste_copied_dimrgn));
371    
372 schoenebeck 3151 actionGroup->add(Gtk::Action::create("AdjustClipboard",
373     _("Adjust Clipboard Content")),
374     Gtk::AccelKey(GDK_KEY_x, Gdk::MOD1_MASK),
375     sigc::mem_fun(*this, &MainWindow::adjust_clipboard_content));
376    
377 schoenebeck 3339 actionGroup->add(Gtk::Action::create("SelectPrevInstr",
378     _("Select Previous Instrument")),
379     Gtk::AccelKey(GDK_KEY_Up, primaryModifierKey),
380     sigc::mem_fun(*this, &MainWindow::select_prev_instrument));
381    
382     actionGroup->add(Gtk::Action::create("SelectNextInstr",
383     _("Select Next Instrument")),
384     Gtk::AccelKey(GDK_KEY_Down, primaryModifierKey),
385     sigc::mem_fun(*this, &MainWindow::select_next_instrument));
386    
387 schoenebeck 3123 actionGroup->add(Gtk::Action::create("SelectPrevRegion",
388     _("Select Previous Region")),
389     Gtk::AccelKey(GDK_KEY_Left, primaryModifierKey),
390     sigc::mem_fun(*this, &MainWindow::select_prev_region));
391    
392     actionGroup->add(Gtk::Action::create("SelectNextRegion",
393     _("Select Next Region")),
394     Gtk::AccelKey(GDK_KEY_Right, primaryModifierKey),
395     sigc::mem_fun(*this, &MainWindow::select_next_region));
396    
397     actionGroup->add(Gtk::Action::create("SelectPrevDimRgnZone",
398     _("Select Previous Dimension Region Zone")),
399     Gtk::AccelKey(GDK_KEY_Left, Gdk::MOD1_MASK),
400     sigc::mem_fun(*this, &MainWindow::select_prev_dim_rgn_zone));
401    
402     actionGroup->add(Gtk::Action::create("SelectNextDimRgnZone",
403     _("Select Next Dimension Region Zone")),
404     Gtk::AccelKey(GDK_KEY_Right, Gdk::MOD1_MASK),
405     sigc::mem_fun(*this, &MainWindow::select_next_dim_rgn_zone));
406    
407     actionGroup->add(Gtk::Action::create("SelectPrevDimension",
408     _("Select Previous Dimension")),
409     Gtk::AccelKey(GDK_KEY_Up, Gdk::MOD1_MASK),
410     sigc::mem_fun(*this, &MainWindow::select_prev_dimension));
411    
412     actionGroup->add(Gtk::Action::create("SelectNextDimension",
413     _("Select Next Dimension")),
414     Gtk::AccelKey(GDK_KEY_Down, Gdk::MOD1_MASK),
415     sigc::mem_fun(*this, &MainWindow::select_next_dimension));
416    
417 schoenebeck 3134 actionGroup->add(Gtk::Action::create("SelectAddPrevDimRgnZone",
418     _("Add Previous Dimension Region Zone to Selection")),
419     Gtk::AccelKey(GDK_KEY_Left, Gdk::MOD1_MASK | Gdk::SHIFT_MASK),
420     sigc::mem_fun(*this, &MainWindow::select_add_prev_dim_rgn_zone));
421 schoenebeck 3123
422 schoenebeck 3134 actionGroup->add(Gtk::Action::create("SelectAddNextDimRgnZone",
423     _("Add Next Dimension Region Zone to Selection")),
424     Gtk::AccelKey(GDK_KEY_Right, Gdk::MOD1_MASK | Gdk::SHIFT_MASK),
425     sigc::mem_fun(*this, &MainWindow::select_add_next_dim_rgn_zone));
426 schoenebeck 3364 #endif
427 schoenebeck 3134
428 schoenebeck 3364 #if USE_GLIB_ACTION
429     m_actionToggleCopySampleUnity = m_actionGroup->add_action_bool("CopySampleUnity", true);
430     m_actionToggleCopySampleTune = m_actionGroup->add_action_bool("CopySampleTune", true);
431     m_actionToggleCopySampleLoop = m_actionGroup->add_action_bool("CopySampleLoop", true);
432     #else
433 schoenebeck 2464 Glib::RefPtr<Gtk::ToggleAction> toggle_action =
434 schoenebeck 2536 Gtk::ToggleAction::create("CopySampleUnity", _("Copy Sample's _Unity Note"));
435 schoenebeck 2464 toggle_action->set_active(true);
436     actionGroup->add(toggle_action);
437    
438     toggle_action =
439     Gtk::ToggleAction::create("CopySampleTune", _("Copy Sample's _Fine Tune"));
440     toggle_action->set_active(true);
441     actionGroup->add(toggle_action);
442    
443     toggle_action =
444     Gtk::ToggleAction::create("CopySampleLoop", _("Copy Sample's _Loop Points"));
445     toggle_action->set_active(true);
446     actionGroup->add(toggle_action);
447 schoenebeck 3364 #endif
448 schoenebeck 2464
449 schoenebeck 3364 #if USE_GLIB_ACTION
450     m_actionToggleStatusBar =
451     m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);
452     m_actionToggleRestoreWinDim =
453     m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);
454 schoenebeck 3711 m_actionInstrDoubleClickOpensProps =
455     m_actionGroup->add_action_bool(
456     "OpenInstrPropsByDoubleClick",
457     sigc::mem_fun(*this, &MainWindow::on_instr_double_click_opens_props),
458     Settings::singleton()->instrumentDoubleClickOpensProps
459     );
460 schoenebeck 3409 m_actionToggleShowTooltips = m_actionGroup->add_action_bool(
461     "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),
462     Settings::singleton()->showTooltips
463     );
464 schoenebeck 3364 m_actionToggleSaveWithTempFile =
465     m_actionGroup->add_action_bool("SaveWithTemporaryFile", sigc::mem_fun(*this, &MainWindow::on_save_with_temporary_file), Settings::singleton()->saveWithTemporaryFile);
466     m_actionGroup->add_action("RefreshAll", sigc::mem_fun(*this, &MainWindow::on_action_refresh_all));
467     #else
468 schoenebeck 3157 actionGroup->add(Gtk::Action::create("MenuMacro", _("_Macro")));
469    
470    
471 schoenebeck 3144 actionGroup->add(Gtk::Action::create("MenuView", _("Vie_w")));
472 schoenebeck 2464 toggle_action =
473 schoenebeck 1415 Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
474     toggle_action->set_active(true);
475     actionGroup->add(toggle_action,
476     sigc::mem_fun(
477     *this, &MainWindow::on_action_view_status_bar));
478 schoenebeck 2918
479     toggle_action =
480     Gtk::ToggleAction::create("AutoRestoreWinDim", _("_Auto Restore Window Dimension"));
481     toggle_action->set_active(Settings::singleton()->autoRestoreWindowDimension);
482     actionGroup->add(toggle_action,
483     sigc::mem_fun(
484     *this, &MainWindow::on_auto_restore_win_dim));
485    
486 schoenebeck 2967 toggle_action =
487 schoenebeck 3711 Gtk::ToggleAction::create("OpenInstrPropsByDoubleClick", _("Instrument Properties by Double Click"));
488     toggle_action->set_active(Settings::singleton()->instrumentDoubleClickOpensProps);
489     actionGroup->add(toggle_action,
490     sigc::mem_fun(
491     *this, &MainWindow::on_instr_double_click_opens_props));
492    
493     toggle_action =
494 schoenebeck 3409 Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));
495     toggle_action->set_active(Settings::singleton()->showTooltips);
496     actionGroup->add(
497     toggle_action,
498     sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips)
499     );
500    
501     toggle_action =
502 schoenebeck 2967 Gtk::ToggleAction::create("SaveWithTemporaryFile", _("Save with _temporary file"));
503     toggle_action->set_active(Settings::singleton()->saveWithTemporaryFile);
504     actionGroup->add(toggle_action,
505     sigc::mem_fun(
506     *this, &MainWindow::on_save_with_temporary_file));
507    
508 schoenebeck 2772 actionGroup->add(
509     Gtk::Action::create("RefreshAll", _("_Refresh All")),
510     sigc::mem_fun(*this, &MainWindow::on_action_refresh_all)
511     );
512 schoenebeck 3364 #endif
513 schoenebeck 1415
514 schoenebeck 3364 #if USE_GLIB_ACTION
515     m_actionGroup->add_action(
516     "About", sigc::mem_fun(*this, &MainWindow::on_action_help_about)
517     );
518     m_actionGroup->add_action(
519     "AddInstrument", sigc::mem_fun(*this, &MainWindow::on_action_add_instrument)
520     );
521     m_actionGroup->add_action(
522     "DupInstrument", sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
523     );
524     m_actionGroup->add_action(
525 schoenebeck 3712 "MoveInstrument", sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
526     );
527     m_actionGroup->add_action(
528 schoenebeck 3364 "CombInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
529     );
530     m_actionGroup->add_action(
531     "RemoveInstrument", sigc::mem_fun(*this, &MainWindow::on_action_remove_instrument)
532     );
533     #else
534 schoenebeck 3158 action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
535     actionGroup->add(Gtk::Action::create("MenuHelp",
536     action->property_label()));
537     actionGroup->add(Gtk::Action::create("About", Gtk::Stock::ABOUT),
538 schoenebeck 1225 sigc::mem_fun(
539     *this, &MainWindow::on_action_help_about));
540     actionGroup->add(
541     Gtk::Action::create("AddInstrument", _("Add _Instrument")),
542     sigc::mem_fun(*this, &MainWindow::on_action_add_instrument)
543     );
544     actionGroup->add(
545 schoenebeck 2395 Gtk::Action::create("DupInstrument", _("_Duplicate Instrument")),
546     sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
547     );
548     actionGroup->add(
549 schoenebeck 3712 Gtk::Action::create("MoveInstrument", _("Move _Instrument To ...")),
550     Gtk::AccelKey(GDK_KEY_i, primaryModifierKey),
551     sigc::mem_fun(*this, &MainWindow::on_action_move_instr)
552     );
553     actionGroup->add(
554 schoenebeck 3299 Gtk::Action::create("CombInstruments", _("_Combine Instruments ...")),
555     Gtk::AccelKey(GDK_KEY_j, primaryModifierKey),
556     sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
557     );
558     actionGroup->add(
559 schoenebeck 3158 Gtk::Action::create("RemoveInstrument", Gtk::Stock::REMOVE),
560 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_action_remove_instrument)
561     );
562 schoenebeck 3364 #endif
563 schoenebeck 1225
564 schoenebeck 3364 #if USE_GLIB_ACTION
565     m_actionToggleWarnOnExtensions = m_actionGroup->add_action_bool(
566     "WarnUserOnExtensions", sigc::mem_fun(*this, &MainWindow::on_action_warn_user_on_extensions),
567     Settings::singleton()->warnUserOnExtensions
568     );
569     m_actionToggleSyncSamplerSelection = m_actionGroup->add_action_bool(
570     "SyncSamplerInstrumentSelection", sigc::mem_fun(*this, &MainWindow::on_action_sync_sampler_instrument_selection),
571     Settings::singleton()->syncSamplerInstrumentSelection
572     );
573     m_actionToggleMoveRootNoteWithRegion = m_actionGroup->add_action_bool(
574     "MoveRootNoteWithRegionMoved", sigc::mem_fun(*this, &MainWindow::on_action_move_root_note_with_region_moved),
575     Settings::singleton()->moveRootNoteWithRegionMoved
576     );
577     #else
578 schoenebeck 2541 actionGroup->add(Gtk::Action::create("MenuSettings", _("_Settings")));
579    
580     toggle_action =
581     Gtk::ToggleAction::create("WarnUserOnExtensions", _("Show warning on format _extensions"));
582     toggle_action->set_active(Settings::singleton()->warnUserOnExtensions);
583     actionGroup->add(
584     toggle_action,
585     sigc::mem_fun(*this, &MainWindow::on_action_warn_user_on_extensions)
586     );
587    
588 schoenebeck 2689 toggle_action =
589     Gtk::ToggleAction::create("SyncSamplerInstrumentSelection", _("Synchronize sampler's instrument selection"));
590     toggle_action->set_active(Settings::singleton()->syncSamplerInstrumentSelection);
591     actionGroup->add(
592     toggle_action,
593     sigc::mem_fun(*this, &MainWindow::on_action_sync_sampler_instrument_selection)
594     );
595 schoenebeck 2541
596 schoenebeck 2773 toggle_action =
597     Gtk::ToggleAction::create("MoveRootNoteWithRegionMoved", _("Move root note with region moved"));
598     toggle_action->set_active(Settings::singleton()->moveRootNoteWithRegionMoved);
599     actionGroup->add(
600     toggle_action,
601     sigc::mem_fun(*this, &MainWindow::on_action_move_root_note_with_region_moved)
602     );
603 schoenebeck 3364 #endif
604 schoenebeck 2689
605 schoenebeck 3364 #if USE_GLIB_ACTION
606     m_actionGroup->add_action(
607     "CombineInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
608     );
609     m_actionGroup->add_action(
610     "MergeFiles", sigc::mem_fun(*this, &MainWindow::on_action_merge_files)
611     );
612     #else
613 schoenebeck 2548 actionGroup->add(Gtk::Action::create("MenuTools", _("_Tools")));
614    
615     actionGroup->add(
616     Gtk::Action::create("CombineInstruments", _("_Combine Instruments...")),
617     sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
618     );
619    
620 schoenebeck 2553 actionGroup->add(
621     Gtk::Action::create("MergeFiles", _("_Merge Files...")),
622     sigc::mem_fun(*this, &MainWindow::on_action_merge_files)
623     );
624 schoenebeck 3364 #endif
625 schoenebeck 2548
626 schoenebeck 1225 // sample right-click popup actions
627 schoenebeck 3364 #if USE_GLIB_ACTION
628     m_actionSampleProperties = m_actionGroup->add_action(
629     "SampleProperties", sigc::mem_fun(*this, &MainWindow::on_action_sample_properties)
630     );
631     m_actionAddSampleGroup = m_actionGroup->add_action(
632     "AddGroup", sigc::mem_fun(*this, &MainWindow::on_action_add_group)
633     );
634     m_actionAddSample = m_actionGroup->add_action(
635     "AddSample", sigc::mem_fun(*this, &MainWindow::on_action_add_sample)
636     );
637     m_actionRemoveSample = m_actionGroup->add_action(
638     "RemoveSample", sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
639     );
640     m_actionGroup->add_action(
641     "RemoveUnusedSamples", sigc::mem_fun(*this, &MainWindow::on_action_remove_unused_samples)
642     );
643     m_actionViewSampleRefs = m_actionGroup->add_action(
644     "ShowSampleRefs", sigc::mem_fun(*this, &MainWindow::on_action_view_references)
645     );
646     m_actionReplaceSample = m_actionGroup->add_action(
647     "ReplaceSample", sigc::mem_fun(*this, &MainWindow::on_action_replace_sample)
648     );
649     m_actionGroup->add_action(
650     "ReplaceAllSamplesInAllGroups", sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
651     );
652     #else
653 schoenebeck 1225 actionGroup->add(
654 schoenebeck 3158 Gtk::Action::create("SampleProperties", Gtk::Stock::PROPERTIES),
655 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_action_sample_properties)
656     );
657     actionGroup->add(
658     Gtk::Action::create("AddGroup", _("Add _Group")),
659     sigc::mem_fun(*this, &MainWindow::on_action_add_group)
660     );
661     actionGroup->add(
662 persson 1799 Gtk::Action::create("AddSample", _("Add _Sample(s)...")),
663 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_action_add_sample)
664     );
665     actionGroup->add(
666 schoenebeck 3158 Gtk::Action::create("RemoveSample", Gtk::Stock::REMOVE),
667 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
668     );
669 schoenebeck 1673 actionGroup->add(
670 schoenebeck 2772 Gtk::Action::create("RemoveUnusedSamples", _("Remove _Unused Samples")),
671     sigc::mem_fun(*this, &MainWindow::on_action_remove_unused_samples)
672     );
673     actionGroup->add(
674 schoenebeck 2624 Gtk::Action::create("ShowSampleRefs", _("Show References...")),
675     sigc::mem_fun(*this, &MainWindow::on_action_view_references)
676     );
677     actionGroup->add(
678 schoenebeck 2715 Gtk::Action::create("ReplaceSample",
679     _("Replace Sample...")),
680     sigc::mem_fun(*this, &MainWindow::on_action_replace_sample)
681     );
682     actionGroup->add(
683 persson 1799 Gtk::Action::create("ReplaceAllSamplesInAllGroups",
684     _("Replace All Samples in All Groups...")),
685 schoenebeck 1673 sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
686     );
687 schoenebeck 3364 #endif
688 schoenebeck 2604
689     // script right-click popup actions
690 schoenebeck 3364 #if USE_GLIB_ACTION
691     m_actionAddScriptGroup = m_actionGroup->add_action(
692     "AddScriptGroup", sigc::mem_fun(*this, &MainWindow::on_action_add_script_group)
693     );
694     m_actionAddScript = m_actionGroup->add_action(
695     "AddScript", sigc::mem_fun(*this, &MainWindow::on_action_add_script)
696     );
697     m_actionEditScript = m_actionGroup->add_action(
698     "EditScript", sigc::mem_fun(*this, &MainWindow::on_action_edit_script)
699     );
700     m_actionRemoveScript = m_actionGroup->add_action(
701     "RemoveScript", sigc::mem_fun(*this, &MainWindow::on_action_remove_script)
702     );
703     #else
704 schoenebeck 2604 actionGroup->add(
705     Gtk::Action::create("AddScriptGroup", _("Add _Group")),
706     sigc::mem_fun(*this, &MainWindow::on_action_add_script_group)
707     );
708     actionGroup->add(
709     Gtk::Action::create("AddScript", _("Add _Script")),
710     sigc::mem_fun(*this, &MainWindow::on_action_add_script)
711     );
712     actionGroup->add(
713     Gtk::Action::create("EditScript", _("_Edit Script...")),
714     sigc::mem_fun(*this, &MainWindow::on_action_edit_script)
715     );
716     actionGroup->add(
717 schoenebeck 3158 Gtk::Action::create("RemoveScript", Gtk::Stock::REMOVE),
718 schoenebeck 2604 sigc::mem_fun(*this, &MainWindow::on_action_remove_script)
719     );
720 schoenebeck 3364 #endif
721 schoenebeck 1225
722 schoenebeck 3364 #if USE_GTKMM_BUILDER
723     insert_action_group("AppMenu", m_actionGroup);
724    
725     m_uiManager = Gtk::Builder::create();
726     Glib::ustring ui_info =
727     "<interface>"
728     " <menubar id='MenuBar'>"
729     " <menu id='MenuFile'>"
730     " <attribute name='label' translatable='yes'>_File</attribute>"
731     " <section>"
732     " <item id='New'>"
733     " <attribute name='label' translatable='yes'>New</attribute>"
734     " <attribute name='action'>AppMenu.New</attribute>"
735     " </item>"
736     " <item id='Open'>"
737     " <attribute name='label' translatable='yes'>Open</attribute>"
738     " <attribute name='action'>AppMenu.Open</attribute>"
739     " </item>"
740     " </section>"
741     " <section>"
742     " <item id='Save'>"
743     " <attribute name='label' translatable='yes'>Save</attribute>"
744     " <attribute name='action'>AppMenu.Save</attribute>"
745     " </item>"
746     " <item id='SaveAs'>"
747     " <attribute name='label' translatable='yes'>Save As</attribute>"
748     " <attribute name='action'>AppMenu.SaveAs</attribute>"
749     " </item>"
750     " </section>"
751     " <section>"
752     " <item id='Properties'>"
753     " <attribute name='label' translatable='yes'>Properties</attribute>"
754     " <attribute name='action'>AppMenu.Properties</attribute>"
755     " </item>"
756     " </section>"
757     " <section>"
758     " <item id='Quit'>"
759     " <attribute name='label' translatable='yes'>Quit</attribute>"
760     " <attribute name='action'>AppMenu.Quit</attribute>"
761     " </item>"
762     " </section>"
763     " </menu>"
764     " <menu id='MenuEdit'>"
765     " <attribute name='label' translatable='yes'>Edit</attribute>"
766     " <section>"
767     " <item id='CopyDimRgn'>"
768     " <attribute name='label' translatable='yes'>Copy Dimension Region</attribute>"
769     " <attribute name='action'>AppMenu.CopyDimRgn</attribute>"
770     " </item>"
771     " <item id='AdjustClipboard'>"
772     " <attribute name='label' translatable='yes'>Adjust Clipboard</attribute>"
773     " <attribute name='action'>AppMenu.AdjustClipboard</attribute>"
774     " </item>"
775     " <item id='PasteDimRgn'>"
776     " <attribute name='label' translatable='yes'>Paste Dimension Region</attribute>"
777     " <attribute name='action'>AppMenu.PasteDimRgn</attribute>"
778     " </item>"
779     " </section>"
780     " <item id='SelectPrevInstr'>"
781     " <attribute name='label' translatable='yes'>Previous Instrument</attribute>"
782     " <attribute name='action'>AppMenu.SelectPrevInstr</attribute>"
783     " </item>"
784     " <item id='SelectNextInstr'>"
785     " <attribute name='label' translatable='yes'>Next Instrument</attribute>"
786     " <attribute name='action'>AppMenu.SelectNextInstr</attribute>"
787     " </item>"
788     " <section>"
789     " <item id='SelectPrevRegion'>"
790     " <attribute name='label' translatable='yes'>Previous Region</attribute>"
791     " <attribute name='action'>AppMenu.SelectPrevRegion</attribute>"
792     " </item>"
793     " <item id='SelectNextRegion'>"
794     " <attribute name='label' translatable='yes'>Next Region</attribute>"
795     " <attribute name='action'>AppMenu.SelectNextRegion</attribute>"
796     " </item>"
797     " </section>"
798     " <item id='SelectPrevDimension'>"
799     " <attribute name='label' translatable='yes'>Previous Dimension</attribute>"
800     " <attribute name='action'>AppMenu.SelectPrevDimension</attribute>"
801     " </item>"
802     " <item id='SelectNextDimension'>"
803     " <attribute name='label' translatable='yes'>Next Dimension</attribute>"
804     " <attribute name='action'>AppMenu.SelectNextDimension</attribute>"
805     " </item>"
806     " <item id='SelectPrevDimRgnZone'>"
807     " <attribute name='label' translatable='yes'>Previous Dimension Region Zone</attribute>"
808     " <attribute name='action'>AppMenu.SelectPrevDimRgnZone</attribute>"
809     " </item>"
810     " <item id='SelectNextDimRgnZone'>"
811     " <attribute name='label' translatable='yes'>Next Dimension Region Zone</attribute>"
812     " <attribute name='action'>AppMenu.SelectNextDimRgnZone</attribute>"
813     " </item>"
814     " <item id='SelectAddPrevDimRgnZone'>"
815     " <attribute name='label' translatable='yes'>Add Previous Dimension Region Zone</attribute>"
816     " <attribute name='action'>AppMenu.SelectAddPrevDimRgnZone</attribute>"
817     " </item>"
818     " <item id='SelectAddNextDimRgnZone'>"
819     " <attribute name='label' translatable='yes'>Add Next Dimension Region Zone</attribute>"
820     " <attribute name='action'>AppMenu.SelectAddNextDimRgnZone</attribute>"
821     " </item>"
822     " <section>"
823     " <item id='CopySampleUnity'>"
824     " <attribute name='label' translatable='yes'>Copy Sample Unity</attribute>"
825     " <attribute name='action'>AppMenu.CopySampleUnity</attribute>"
826     " </item>"
827     " <item id='CopySampleTune'>"
828     " <attribute name='label' translatable='yes'>Copy Sample Tune</attribute>"
829     " <attribute name='action'>AppMenu.CopySampleTune</attribute>"
830     " </item>"
831     " <item id='CopySampleLoop'>"
832     " <attribute name='label' translatable='yes'>Copy Sample Loop</attribute>"
833     " <attribute name='action'>AppMenu.CopySampleLoop</attribute>"
834     " </item>"
835     " </section>"
836     " </menu>"
837     " <menu id='MenuMacro'>"
838     " <attribute name='label' translatable='yes'>Macro</attribute>"
839     " <section>"
840     " </section>"
841     " </menu>"
842     " <menu id='MenuSample'>"
843     " <attribute name='label' translatable='yes'>Sample</attribute>"
844     " <section>"
845     " <item id='SampleProperties'>"
846     " <attribute name='label' translatable='yes'>Properties</attribute>"
847     " <attribute name='action'>AppMenu.SampleProperties</attribute>"
848     " </item>"
849     " <item id='AddGroup'>"
850     " <attribute name='label' translatable='yes'>Add Group</attribute>"
851     " <attribute name='action'>AppMenu.AddGroup</attribute>"
852     " </item>"
853     " <item id='AddSample'>"
854     " <attribute name='label' translatable='yes'>Add Sample</attribute>"
855     " <attribute name='action'>AppMenu.AddSample</attribute>"
856     " </item>"
857     " <item id='ShowSampleRefs'>"
858     " <attribute name='label' translatable='yes'>Show Sample References</attribute>"
859     " <attribute name='action'>AppMenu.ShowSampleRefs</attribute>"
860     " </item>"
861     " <item id='ReplaceSample'>"
862     " <attribute name='label' translatable='yes'>Replace Sample</attribute>"
863     " <attribute name='action'>AppMenu.ReplaceSample</attribute>"
864     " </item>"
865     " <item id='ReplaceAllSamplesInAllGroups'>"
866     " <attribute name='label' translatable='yes'>Replace all Samples in all Groups</attribute>"
867     " <attribute name='action'>AppMenu.ReplaceAllSamplesInAllGroups</attribute>"
868     " </item>"
869     " </section>"
870     " <section>"
871     " <item id='RemoveSample'>"
872     " <attribute name='label' translatable='yes'>Remove Sample</attribute>"
873     " <attribute name='action'>AppMenu.RemoveSample</attribute>"
874     " </item>"
875     " <item id='RemoveUnusedSamples'>"
876     " <attribute name='label' translatable='yes'>Remove unused Samples</attribute>"
877     " <attribute name='action'>AppMenu.RemoveUnusedSamples</attribute>"
878     " </item>"
879     " </section>"
880     " </menu>"
881     " <menu id='MenuInstrument'>"
882     " <attribute name='label' translatable='yes'>Instrument</attribute>"
883     " <section>"
884     " <item id='InstrProperties'>"
885     " <attribute name='label' translatable='yes'>Properties</attribute>"
886     " <attribute name='action'>AppMenu.InstrProperties</attribute>"
887     " </item>"
888     " <item id='MidiRules'>"
889     " <attribute name='label' translatable='yes'>MIDI Rules</attribute>"
890     " <attribute name='action'>AppMenu.MidiRules</attribute>"
891     " </item>"
892     " <item id='ScriptSlots'>"
893     " <attribute name='label' translatable='yes'>Script Slots</attribute>"
894     " <attribute name='action'>AppMenu.ScriptSlots</attribute>"
895     " </item>"
896     " </section>"
897     " <submenu id='AssignScripts'>"
898     " <attribute name='label' translatable='yes'>Assign Scripts</attribute>"
899     " </submenu>"
900     " <section>"
901     " <item id='AddInstrument'>"
902     " <attribute name='label' translatable='yes'>Add Instrument</attribute>"
903     " <attribute name='action'>AppMenu.AddInstrument</attribute>"
904     " </item>"
905     " <item id='DupInstrument'>"
906     " <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
907     " <attribute name='action'>AppMenu.DupInstrument</attribute>"
908     " </item>"
909 schoenebeck 3712 " <item id='MoveInstrument'>"
910     " <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
911     " <attribute name='action'>AppMenu.MoveInstrument</attribute>"
912     " </item>"
913 schoenebeck 3364 " <item id='CombInstruments'>"
914     " <attribute name='label' translatable='yes'>Combine Instrument</attribute>"
915     " <attribute name='action'>AppMenu.CombInstruments</attribute>"
916     " </item>"
917     " </section>"
918     " <section>"
919     " <item id='RemoveInstrument'>"
920     " <attribute name='label' translatable='yes'>Remove Instrument</attribute>"
921     " <attribute name='action'>AppMenu.RemoveInstrument</attribute>"
922     " </item>"
923     " </section>"
924     " </menu>"
925     " <menu id='MenuScript'>"
926     " <attribute name='label' translatable='yes'>Script</attribute>"
927     " <section>"
928     " <item id='AddScriptGroup'>"
929     " <attribute name='label' translatable='yes'>Add Script Group</attribute>"
930     " <attribute name='action'>AppMenu.AddScriptGroup</attribute>"
931     " </item>"
932     " <item id='AddScript'>"
933     " <attribute name='label' translatable='yes'>Add Script</attribute>"
934     " <attribute name='action'>AppMenu.AddScript</attribute>"
935     " </item>"
936     " <item id='EditScript'>"
937     " <attribute name='label' translatable='yes'>Edit Script</attribute>"
938     " <attribute name='action'>AppMenu.EditScript</attribute>"
939     " </item>"
940     " </section>"
941     " <section>"
942     " <item id='RemoveScript'>"
943     " <attribute name='label' translatable='yes'>Remove Script</attribute>"
944     " <attribute name='action'>AppMenu.RemoveScript</attribute>"
945     " </item>"
946     " </section>"
947     " </menu>"
948     " <menu id='MenuView'>"
949     " <attribute name='label' translatable='yes'>View</attribute>"
950     " <section>"
951     " <item id='Statusbar'>"
952     " <attribute name='label' translatable='yes'>Statusbar</attribute>"
953     " <attribute name='action'>AppMenu.Statusbar</attribute>"
954     " </item>"
955 schoenebeck 3409 " <item id='ShowTooltips'>"
956     " <attribute name='label' translatable='yes'>Tooltips for Beginners</attribute>"
957     " <attribute name='action'>AppMenu.ShowTooltips</attribute>"
958     " </item>"
959 schoenebeck 3364 " <item id='AutoRestoreWinDim'>"
960     " <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"
961     " <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"
962     " </item>"
963 schoenebeck 3711 " <item id='OpenInstrPropsByDoubleClick'>"
964     " <attribute name='label' translatable='yes'>Instrument Properties by Double Click</attribute>"
965     " <attribute name='action'>AppMenu.OpenInstrPropsByDoubleClick</attribute>"
966     " </item>"
967 schoenebeck 3364 " </section>"
968     " <section>"
969     " <item id='RefreshAll'>"
970     " <attribute name='label' translatable='yes'>Refresh All</attribute>"
971     " <attribute name='action'>AppMenu.RefreshAll</attribute>"
972     " </item>"
973     " </section>"
974     " </menu>"
975     " <menu id='MenuTools'>"
976     " <attribute name='label' translatable='yes'>Tools</attribute>"
977     " <section>"
978     " <item id='CombineInstruments'>"
979     " <attribute name='label' translatable='yes'>Combine Instruments ...</attribute>"
980     " <attribute name='action'>AppMenu.CombineInstruments</attribute>"
981     " </item>"
982     " <item id='MergeFiles'>"
983     " <attribute name='label' translatable='yes'>Merge Files ...</attribute>"
984     " <attribute name='action'>AppMenu.MergeFiles</attribute>"
985     " </item>"
986     " </section>"
987     " </menu>"
988     " <menu id='MenuSettings'>"
989     " <attribute name='label' translatable='yes'>Settings</attribute>"
990     " <section>"
991     " <item id='WarnUserOnExtensions'>"
992     " <attribute name='label' translatable='yes'>Warning on Format Extensions</attribute>"
993     " <attribute name='action'>AppMenu.WarnUserOnExtensions</attribute>"
994     " </item>"
995     " <item id='SyncSamplerInstrumentSelection'>"
996     " <attribute name='label' translatable='yes'>Synchronize Sampler Selection</attribute>"
997     " <attribute name='action'>AppMenu.SyncSamplerInstrumentSelection</attribute>"
998     " </item>"
999     " <item id='MoveRootNoteWithRegionMoved'>"
1000     " <attribute name='label' translatable='yes'>Move Root Note with Region moved</attribute>"
1001     " <attribute name='action'>AppMenu.MoveRootNoteWithRegionMoved</attribute>"
1002     " </item>"
1003     " <item id='SaveWithTemporaryFile'>"
1004     " <attribute name='label' translatable='yes'>Save with temporary file</attribute>"
1005     " <attribute name='action'>AppMenu.SaveWithTemporaryFile</attribute>"
1006     " </item>"
1007     " </section>"
1008     " </menu>"
1009     " <menu id='MenuHelp'>"
1010     " <attribute name='label' translatable='yes'>Help</attribute>"
1011     " <section>"
1012     " <item id='About'>"
1013     " <attribute name='label' translatable='yes'>About ...</attribute>"
1014     " <attribute name='action'>AppMenu.About</attribute>"
1015     " </item>"
1016     " </section>"
1017     " </menu>"
1018     " </menubar>"
1019     // popups
1020     " <menu id='PopupMenu'>"
1021     " <section>"
1022     " <item id='InstrProperties'>"
1023     " <attribute name='label' translatable='yes'>Instrument Properties</attribute>"
1024     " <attribute name='action'>AppMenu.InstrProperties</attribute>"
1025     " </item>"
1026     " <item id='MidiRules'>"
1027     " <attribute name='label' translatable='yes'>MIDI Rules</attribute>"
1028     " <attribute name='action'>AppMenu.MidiRules</attribute>"
1029     " </item>"
1030     " <item id='ScriptSlots'>"
1031     " <attribute name='label' translatable='yes'>Script Slots</attribute>"
1032     " <attribute name='action'>AppMenu.ScriptSlots</attribute>"
1033     " </item>"
1034     " <item id='AddInstrument'>"
1035     " <attribute name='label' translatable='yes'>Add Instrument</attribute>"
1036     " <attribute name='action'>AppMenu.AddInstrument</attribute>"
1037     " </item>"
1038     " <item id='DupInstrument'>"
1039     " <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
1040     " <attribute name='action'>AppMenu.DupInstrument</attribute>"
1041     " </item>"
1042 schoenebeck 3712 " <item id='MoveInstrument'>"
1043     " <attribute name='label' translatable='yes'>Move Instrument To ...</attribute>"
1044     " <attribute name='action'>AppMenu.MoveInstrument</attribute>"
1045     " </item>"
1046 schoenebeck 3364 " <item id='CombInstruments'>"
1047     " <attribute name='label' translatable='yes'>Combine Instruments</attribute>"
1048     " <attribute name='action'>AppMenu.CombInstruments</attribute>"
1049     " </item>"
1050     " </section>"
1051     " <section>"
1052     " <item id='RemoveInstrument'>"
1053     " <attribute name='label' translatable='yes'>Remove Instruments</attribute>"
1054     " <attribute name='action'>AppMenu.RemoveInstrument</attribute>"
1055     " </item>"
1056     " </section>"
1057     " </menu>"
1058     " <menu id='SamplePopupMenu'>"
1059     " <section>"
1060     " <item id='SampleProperties'>"
1061     " <attribute name='label' translatable='yes'>Sample Properties</attribute>"
1062     " <attribute name='action'>AppMenu.SampleProperties</attribute>"
1063     " </item>"
1064     " <item id='AddGroup'>"
1065     " <attribute name='label' translatable='yes'>Add Sample Group</attribute>"
1066     " <attribute name='action'>AppMenu.AddGroup</attribute>"
1067     " </item>"
1068     " <item id='AddSample'>"
1069     " <attribute name='label' translatable='yes'>Add Sample</attribute>"
1070     " <attribute name='action'>AppMenu.AddSample</attribute>"
1071     " </item>"
1072     " <item id='ShowSampleRefs'>"
1073     " <attribute name='label' translatable='yes'>Show Sample References ...</attribute>"
1074     " <attribute name='action'>AppMenu.ShowSampleRefs</attribute>"
1075     " </item>"
1076     " <item id='ReplaceSample'>"
1077     " <attribute name='label' translatable='yes'>Replace Sample</attribute>"
1078     " <attribute name='action'>AppMenu.ReplaceSample</attribute>"
1079     " </item>"
1080     " <item id='ReplaceAllSamplesInAllGroups'>"
1081     " <attribute name='label' translatable='yes'>Replace all Samples ...</attribute>"
1082     " <attribute name='action'>AppMenu.ReplaceAllSamplesInAllGroups</attribute>"
1083     " </item>"
1084     " </section>"
1085     " <section>"
1086     " <item id='RemoveSample'>"
1087     " <attribute name='label' translatable='yes'>Remove Sample</attribute>"
1088     " <attribute name='action'>AppMenu.RemoveSample</attribute>"
1089     " </item>"
1090     " <item id='RemoveUnusedSamples'>"
1091     " <attribute name='label' translatable='yes'>Remove unused Samples</attribute>"
1092     " <attribute name='action'>AppMenu.RemoveUnusedSamples</attribute>"
1093     " </item>"
1094     " </section>"
1095     " </menu>"
1096     " <menu id='ScriptPopupMenu'>"
1097     " <section>"
1098     " <item id='AddScriptGroup'>"
1099     " <attribute name='label' translatable='yes'>Add Script Group</attribute>"
1100     " <attribute name='action'>AppMenu.AddScriptGroup</attribute>"
1101     " </item>"
1102     " <item id='AddScript'>"
1103     " <attribute name='label' translatable='yes'>Add Script</attribute>"
1104     " <attribute name='action'>AppMenu.AddScript</attribute>"
1105     " </item>"
1106     " <item id='EditScript'>"
1107     " <attribute name='label' translatable='yes'>Edit Script</attribute>"
1108     " <attribute name='action'>AppMenu.EditScript</attribute>"
1109     " </item>"
1110     " </section>"
1111     " <section>"
1112     " <item id='RemoveScript'>"
1113     " <attribute name='label' translatable='yes'>Remove Script</attribute>"
1114     " <attribute name='action'>AppMenu.RemoveScript</attribute>"
1115     " </item>"
1116     " </section>"
1117     " </menu>"
1118     "</interface>";
1119     m_uiManager->add_from_string(ui_info);
1120     #else
1121 schoenebeck 1225 uiManager = Gtk::UIManager::create();
1122     uiManager->insert_action_group(actionGroup);
1123 persson 1261 add_accel_group(uiManager->get_accel_group());
1124 schoenebeck 1225
1125     Glib::ustring ui_info =
1126     "<ui>"
1127     " <menubar name='MenuBar'>"
1128     " <menu action='MenuFile'>"
1129     " <menuitem action='New'/>"
1130     " <menuitem action='Open'/>"
1131     " <separator/>"
1132     " <menuitem action='Save'/>"
1133     " <menuitem action='SaveAs'/>"
1134     " <separator/>"
1135     " <menuitem action='Properties'/>"
1136     " <separator/>"
1137     " <menuitem action='Quit'/>"
1138     " </menu>"
1139 schoenebeck 2464 " <menu action='MenuEdit'>"
1140 schoenebeck 3144 " <menuitem action='CopyDimRgn'/>"
1141 schoenebeck 3151 " <menuitem action='AdjustClipboard'/>"
1142 schoenebeck 3144 " <menuitem action='PasteDimRgn'/>"
1143     " <separator/>"
1144 schoenebeck 3339 " <menuitem action='SelectPrevInstr'/>"
1145     " <menuitem action='SelectNextInstr'/>"
1146     " <separator/>"
1147 schoenebeck 3123 " <menuitem action='SelectPrevRegion'/>"
1148     " <menuitem action='SelectNextRegion'/>"
1149     " <separator/>"
1150 schoenebeck 3134 " <menuitem action='SelectPrevDimension'/>"
1151     " <menuitem action='SelectNextDimension'/>"
1152 schoenebeck 3123 " <menuitem action='SelectPrevDimRgnZone'/>"
1153     " <menuitem action='SelectNextDimRgnZone'/>"
1154 schoenebeck 3134 " <menuitem action='SelectAddPrevDimRgnZone'/>"
1155     " <menuitem action='SelectAddNextDimRgnZone'/>"
1156 schoenebeck 3123 " <separator/>"
1157 schoenebeck 2464 " <menuitem action='CopySampleUnity'/>"
1158     " <menuitem action='CopySampleTune'/>"
1159     " <menuitem action='CopySampleLoop'/>"
1160     " </menu>"
1161 schoenebeck 3157 " <menu action='MenuMacro'>"
1162     " </menu>"
1163 schoenebeck 2625 " <menu action='MenuSample'>"
1164     " <menuitem action='SampleProperties'/>"
1165     " <menuitem action='AddGroup'/>"
1166     " <menuitem action='AddSample'/>"
1167     " <menuitem action='ShowSampleRefs'/>"
1168 schoenebeck 2715 " <menuitem action='ReplaceSample' />"
1169 schoenebeck 2625 " <menuitem action='ReplaceAllSamplesInAllGroups' />"
1170     " <separator/>"
1171     " <menuitem action='RemoveSample'/>"
1172 schoenebeck 2772 " <menuitem action='RemoveUnusedSamples'/>"
1173 schoenebeck 2625 " </menu>"
1174 schoenebeck 1225 " <menu action='MenuInstrument'>"
1175 schoenebeck 2625 " <menu action='AllInstruments'>"
1176     " </menu>"
1177     " <separator/>"
1178     " <menuitem action='InstrProperties'/>"
1179     " <menuitem action='MidiRules'/>"
1180     " <menuitem action='ScriptSlots'/>"
1181 schoenebeck 3339 " <menu action='AssignScripts'/>"
1182 schoenebeck 2625 " <menuitem action='AddInstrument'/>"
1183     " <menuitem action='DupInstrument'/>"
1184 schoenebeck 3712 " <menuitem action='MoveInstrument'/>"
1185 schoenebeck 3299 " <menuitem action='CombInstruments'/>"
1186 schoenebeck 2625 " <separator/>"
1187     " <menuitem action='RemoveInstrument'/>"
1188 schoenebeck 1225 " </menu>"
1189 schoenebeck 2625 " <menu action='MenuScript'>"
1190     " <menuitem action='AddScriptGroup'/>"
1191     " <menuitem action='AddScript'/>"
1192     " <menuitem action='EditScript'/>"
1193     " <separator/>"
1194     " <menuitem action='RemoveScript'/>"
1195     " </menu>"
1196 schoenebeck 1415 " <menu action='MenuView'>"
1197     " <menuitem action='Statusbar'/>"
1198 schoenebeck 3409 " <menuitem action='ShowTooltips'/>"
1199 schoenebeck 2918 " <menuitem action='AutoRestoreWinDim'/>"
1200 schoenebeck 3711 " <menuitem action='OpenInstrPropsByDoubleClick'/>"
1201 schoenebeck 2772 " <separator/>"
1202     " <menuitem action='RefreshAll'/>"
1203 schoenebeck 1415 " </menu>"
1204 schoenebeck 2548 " <menu action='MenuTools'>"
1205     " <menuitem action='CombineInstruments'/>"
1206 schoenebeck 2553 " <menuitem action='MergeFiles'/>"
1207 schoenebeck 2548 " </menu>"
1208 schoenebeck 2541 " <menu action='MenuSettings'>"
1209     " <menuitem action='WarnUserOnExtensions'/>"
1210 schoenebeck 2689 " <menuitem action='SyncSamplerInstrumentSelection'/>"
1211 schoenebeck 2773 " <menuitem action='MoveRootNoteWithRegionMoved'/>"
1212 schoenebeck 2967 " <menuitem action='SaveWithTemporaryFile'/>"
1213 schoenebeck 2541 " </menu>"
1214 schoenebeck 1225 " <menu action='MenuHelp'>"
1215     " <menuitem action='About'/>"
1216     " </menu>"
1217     " </menubar>"
1218     " <popup name='PopupMenu'>"
1219     " <menuitem action='InstrProperties'/>"
1220 persson 2507 " <menuitem action='MidiRules'/>"
1221 schoenebeck 2610 " <menuitem action='ScriptSlots'/>"
1222 schoenebeck 1225 " <menuitem action='AddInstrument'/>"
1223 schoenebeck 2395 " <menuitem action='DupInstrument'/>"
1224 schoenebeck 3712 " <menuitem action='MoveInstrument'/>"
1225 schoenebeck 3299 " <menuitem action='CombInstruments'/>"
1226 schoenebeck 1225 " <separator/>"
1227     " <menuitem action='RemoveInstrument'/>"
1228     " </popup>"
1229     " <popup name='SamplePopupMenu'>"
1230     " <menuitem action='SampleProperties'/>"
1231     " <menuitem action='AddGroup'/>"
1232     " <menuitem action='AddSample'/>"
1233 schoenebeck 2624 " <menuitem action='ShowSampleRefs'/>"
1234 schoenebeck 2715 " <menuitem action='ReplaceSample' />"
1235 persson 2442 " <menuitem action='ReplaceAllSamplesInAllGroups' />"
1236 schoenebeck 1225 " <separator/>"
1237     " <menuitem action='RemoveSample'/>"
1238 schoenebeck 2772 " <menuitem action='RemoveUnusedSamples'/>"
1239 schoenebeck 1225 " </popup>"
1240 schoenebeck 2604 " <popup name='ScriptPopupMenu'>"
1241     " <menuitem action='AddScriptGroup'/>"
1242     " <menuitem action='AddScript'/>"
1243     " <menuitem action='EditScript'/>"
1244     " <separator/>"
1245     " <menuitem action='RemoveScript'/>"
1246     " </popup>"
1247 schoenebeck 1225 "</ui>";
1248     uiManager->add_ui_from_string(ui_info);
1249 schoenebeck 3364 #endif
1250 schoenebeck 1225
1251 schoenebeck 3364 #if USE_GTKMM_BUILDER
1252     popup_menu = new Gtk::Menu(
1253     Glib::RefPtr<Gio::Menu>::cast_dynamic(
1254     m_uiManager->get_object("PopupMenu")
1255     )
1256     );
1257     sample_popup = new Gtk::Menu(
1258     Glib::RefPtr<Gio::Menu>::cast_dynamic(
1259     m_uiManager->get_object("SamplePopupMenu")
1260     )
1261     );
1262     script_popup = new Gtk::Menu(
1263     Glib::RefPtr<Gio::Menu>::cast_dynamic(
1264     m_uiManager->get_object("ScriptPopupMenu")
1265     )
1266     );
1267     #else
1268 schoenebeck 1225 popup_menu = dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/PopupMenu"));
1269 schoenebeck 2536
1270     // Set tooltips for menu items (for some reason, setting a tooltip on the
1271     // respective Gtk::Action objects above will simply be ignored, no matter
1272     // if using Gtk::Action::set_tooltip() or passing the tooltip string on
1273     // Gtk::Action::create()).
1274     {
1275     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1276     uiManager->get_widget("/MenuBar/MenuEdit/CopySampleUnity"));
1277     item->set_tooltip_text(_("Used when dragging a sample to a region's sample reference field. You may disable this for example if you want to replace an existing sample in a region with a new sample, but don't want that the region's current unity note setting will be altered by this action."));
1278     }
1279     {
1280     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1281     uiManager->get_widget("/MenuBar/MenuEdit/CopySampleTune"));
1282     item->set_tooltip_text(_("Used when dragging a sample to a region's sample reference field. You may disable this for example if you want to replace an existing sample in a region with a new sample, but don't want that the region's current sample playback tuning will be altered by this action."));
1283     }
1284     {
1285     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1286     uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));
1287 schoenebeck 3408 item->set_tooltip_text(_("Used when dragging a sample to a region's sample reference field. You may disable this for example if you want to replace an existing sample in a region with a new sample, but don't want that the region's current loop information to be altered by this action."));
1288 schoenebeck 2536 }
1289 schoenebeck 2541 {
1290     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1291     uiManager->get_widget("/MenuBar/MenuSettings/WarnUserOnExtensions"));
1292     item->set_tooltip_text(_("If checked, a warning will be shown whenever you try to use a feature which is based on a LinuxSampler extension ontop of the original gig format, which would not work with the Gigasampler/GigaStudio application."));
1293     }
1294 schoenebeck 2553 {
1295     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1296 schoenebeck 2689 uiManager->get_widget("/MenuBar/MenuSettings/SyncSamplerInstrumentSelection"));
1297     item->set_tooltip_text(_("If checked, the sampler's current instrument will automatically be switched whenever another instrument was selected in gigedit (only available in live-mode)."));
1298     }
1299     {
1300     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1301 schoenebeck 2773 uiManager->get_widget("/MenuBar/MenuSettings/MoveRootNoteWithRegionMoved"));
1302 schoenebeck 3408 item->set_tooltip_text(_("If checked, and when a region is moved by dragging it around on the virtual keyboard, the keyboard position dependent pitch will move exactly with the amount of semi tones the region was moved around."));
1303 schoenebeck 2773 }
1304     {
1305     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1306 schoenebeck 2772 uiManager->get_widget("/MenuBar/MenuSample/RemoveUnusedSamples"));
1307     item->set_tooltip_text(_("Removes all samples that are not referenced by any instrument (i.e. red ones)."));
1308     // copy tooltip to popup menu
1309     Gtk::MenuItem* item2 = dynamic_cast<Gtk::MenuItem*>(
1310     uiManager->get_widget("/SamplePopupMenu/RemoveUnusedSamples"));
1311     item2->set_tooltip_text(item->get_tooltip_text());
1312     }
1313     {
1314     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1315     uiManager->get_widget("/MenuBar/MenuView/RefreshAll"));
1316     item->set_tooltip_text(_("Reloads the currently open gig file and updates the entire graphical user interface."));
1317     }
1318     {
1319     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1320 schoenebeck 2918 uiManager->get_widget("/MenuBar/MenuView/AutoRestoreWinDim"));
1321     item->set_tooltip_text(_("If checked, size and position of all windows will be saved and automatically restored next time."));
1322     }
1323     {
1324     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1325 schoenebeck 3711 uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
1326     item->set_tooltip_text(_("If checked, double clicking an instrument opens its properties dialog."));
1327     }
1328     {
1329     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1330 schoenebeck 2553 uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));
1331     item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));
1332     }
1333     {
1334     Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1335     uiManager->get_widget("/MenuBar/MenuTools/MergeFiles"));
1336     item->set_tooltip_text(_("Add instruments and samples of other .gig files to this .gig file."));
1337     }
1338 schoenebeck 3364 #endif
1339 schoenebeck 1225
1340 schoenebeck 3364 #if USE_GTKMM_BUILDER
1341     assign_scripts_menu = new Gtk::Menu(
1342     Glib::RefPtr<Gio::Menu>::cast_dynamic(
1343     m_uiManager->get_object("AssignScripts")
1344     )
1345     );
1346     #else
1347 persson 2442 instrument_menu = static_cast<Gtk::MenuItem*>(
1348 schoenebeck 2625 uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments"))->get_submenu();
1349 persson 2442
1350 schoenebeck 3339 assign_scripts_menu = static_cast<Gtk::MenuItem*>(
1351     uiManager->get_widget("/MenuBar/MenuInstrument/AssignScripts"))->get_submenu();
1352 schoenebeck 3364 #endif
1353 schoenebeck 3339
1354 schoenebeck 3364 #if USE_GTKMM_BUILDER
1355     Gtk::Widget* menuBar = NULL;
1356     m_uiManager->get_widget("MenuBar", menuBar);
1357     #else
1358 schoenebeck 1225 Gtk::Widget* menuBar = uiManager->get_widget("/MenuBar");
1359 schoenebeck 3364 #endif
1360    
1361 schoenebeck 1225 m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
1362     m_VBox.pack_start(m_HPaned);
1363     m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
1364 schoenebeck 1661 m_VBox.pack_start(m_RegionChooser.m_VirtKeybPropsBox, Gtk::PACK_SHRINK);
1365 schoenebeck 1225 m_VBox.pack_start(m_DimRegionChooser, Gtk::PACK_SHRINK);
1366 schoenebeck 1411 m_VBox.pack_start(m_StatusBar, Gtk::PACK_SHRINK);
1367 schoenebeck 1225
1368 persson 2246 set_file_is_shared(false);
1369    
1370 schoenebeck 1411 // Status Bar:
1371 schoenebeck 3364 #if USE_GTKMM_BOX
1372     # warning No status bar layout for GTKMM 4 yet
1373     #else
1374 schoenebeck 1411 m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
1375     m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
1376 schoenebeck 3364 #endif
1377 schoenebeck 1411 m_StatusBar.show();
1378    
1379 persson 1261 m_RegionChooser.signal_region_selected().connect(
1380 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::region_changed) );
1381 persson 1261 m_DimRegionChooser.signal_dimregion_selected().connect(
1382 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::dimreg_changed) );
1383    
1384    
1385     // Create the Tree model:
1386 schoenebeck 3806 m_refInstrumentsTreeModel = Gtk::ListStore::create(m_InstrumentsModel);
1387     m_refInstrumentsModelFilter = Gtk::TreeModelFilter::create(m_refInstrumentsTreeModel);
1388     m_refInstrumentsModelFilter->set_visible_func(
1389 schoenebeck 3340 sigc::mem_fun(*this, &MainWindow::instrument_row_visible)
1390     );
1391 schoenebeck 3806 m_TreeViewInstruments.set_model(m_refInstrumentsModelFilter);
1392 schoenebeck 3340
1393 schoenebeck 3806 m_TreeViewInstruments.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1394     m_TreeViewInstruments.set_has_tooltip(true);
1395     m_TreeViewInstruments.signal_query_tooltip().connect(
1396 schoenebeck 3418 sigc::mem_fun(*this, &MainWindow::onQueryTreeViewTooltip)
1397     );
1398 schoenebeck 3806 instrument_name_connection = m_refInstrumentsTreeModel->signal_row_changed().connect(
1399 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::instrument_name_changed)
1400     );
1401    
1402     // Add the TreeView's view columns:
1403 schoenebeck 3806 m_TreeViewInstruments.append_column(_("Nr"), m_InstrumentsModel.m_col_nr);
1404     m_TreeViewInstruments.append_column_editable(_("Instrument"), m_InstrumentsModel.m_col_name);
1405     m_TreeViewInstruments.append_column(_("Scripts"), m_InstrumentsModel.m_col_scripts);
1406     m_TreeViewInstruments.set_headers_visible(true);
1407 schoenebeck 2701
1408     // establish drag&drop within the instrument tree view, allowing to reorder
1409     // the sequence of instruments within the gig file
1410     {
1411     std::vector<Gtk::TargetEntry> drag_target_instrument;
1412     drag_target_instrument.push_back(Gtk::TargetEntry("gig::Instrument"));
1413 schoenebeck 3806 m_TreeViewInstruments.drag_source_set(drag_target_instrument);
1414     m_TreeViewInstruments.drag_dest_set(drag_target_instrument);
1415     m_TreeViewInstruments.signal_drag_begin().connect(
1416 schoenebeck 2701 sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_begin)
1417     );
1418 schoenebeck 3806 m_TreeViewInstruments.signal_drag_data_get().connect(
1419 schoenebeck 2701 sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_data_get)
1420     );
1421 schoenebeck 3806 m_TreeViewInstruments.signal_drag_data_received().connect(
1422 schoenebeck 2701 sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drop_drag_data_received)
1423     );
1424     }
1425 schoenebeck 1225
1426     // create samples treeview (including its data model)
1427     m_refSamplesTreeModel = SamplesTreeStore::create(m_SamplesModel);
1428     m_TreeViewSamples.set_model(m_refSamplesTreeModel);
1429 schoenebeck 2994 m_TreeViewSamples.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1430 schoenebeck 2536 m_TreeViewSamples.set_tooltip_text(_("To actually use a sample, drag it from this list view to \"Sample\" -> \"Sample:\" on the region's settings pane on the right.\n\nRight click here for more actions on samples."));
1431 schoenebeck 1225 // m_TreeViewSamples.set_reorderable();
1432 schoenebeck 2621 m_TreeViewSamples.append_column_editable(_("Name"), m_SamplesModel.m_col_name);
1433     m_TreeViewSamples.append_column(_("Referenced"), m_SamplesModel.m_col_refcount);
1434     {
1435     Gtk::TreeViewColumn* column = m_TreeViewSamples.get_column(0);
1436     Gtk::CellRendererText* cellrenderer =
1437 persson 2658 dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
1438 schoenebeck 2621 column->add_attribute(
1439     cellrenderer->property_foreground(), m_SamplesModel.m_color
1440     );
1441     }
1442     {
1443     Gtk::TreeViewColumn* column = m_TreeViewSamples.get_column(1);
1444     Gtk::CellRendererText* cellrenderer =
1445 persson 2658 dynamic_cast<Gtk::CellRendererText*>(column->get_first_cell());
1446 schoenebeck 2621 column->add_attribute(
1447     cellrenderer->property_foreground(), m_SamplesModel.m_color
1448     );
1449     }
1450     m_TreeViewSamples.set_headers_visible(true);
1451 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
1452     m_TreeViewSamples.signal_button_press_event().connect(
1453     sigc::mem_fun(*this, &MainWindow::on_sample_treeview_button_release)
1454     );
1455     #else
1456 schoenebeck 1225 m_TreeViewSamples.signal_button_press_event().connect_notify(
1457     sigc::mem_fun(*this, &MainWindow::on_sample_treeview_button_release)
1458     );
1459 schoenebeck 3364 #endif
1460 schoenebeck 1225 m_refSamplesTreeModel->signal_row_changed().connect(
1461     sigc::mem_fun(*this, &MainWindow::sample_name_changed)
1462     );
1463    
1464 schoenebeck 2604 // create scripts treeview (including its data model)
1465     m_refScriptsTreeModel = ScriptsTreeStore::create(m_ScriptsModel);
1466     m_TreeViewScripts.set_model(m_refScriptsTreeModel);
1467     m_TreeViewScripts.set_tooltip_text(_(
1468 schoenebeck 2644 "Use CTRL + double click for editing a script."
1469     "\n\n"
1470 schoenebeck 2604 "Note: instrument scripts are a LinuxSampler extension of the gig "
1471     "format. This feature will not work with the GigaStudio software!"
1472     ));
1473     // m_TreeViewScripts.set_reorderable();
1474     m_TreeViewScripts.append_column_editable("Samples", m_ScriptsModel.m_col_name);
1475     m_TreeViewScripts.set_headers_visible(false);
1476 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
1477     m_TreeViewScripts.signal_button_press_event().connect(
1478     sigc::mem_fun(*this, &MainWindow::on_script_treeview_button_release)
1479     );
1480     #else
1481 schoenebeck 2604 m_TreeViewScripts.signal_button_press_event().connect_notify(
1482     sigc::mem_fun(*this, &MainWindow::on_script_treeview_button_release)
1483     );
1484 schoenebeck 3364 #endif
1485 schoenebeck 2695 //FIXME: why the heck does this double click signal_row_activated() only fire while CTRL key is pressed ?
1486 schoenebeck 2644 m_TreeViewScripts.signal_row_activated().connect(
1487     sigc::mem_fun(*this, &MainWindow::script_double_clicked)
1488     );
1489 schoenebeck 2604 m_refScriptsTreeModel->signal_row_changed().connect(
1490     sigc::mem_fun(*this, &MainWindow::script_name_changed)
1491     );
1492    
1493 schoenebeck 2610 // establish drag&drop between scripts tree view and ScriptSlots window
1494     std::vector<Gtk::TargetEntry> drag_target_gig_script;
1495     drag_target_gig_script.push_back(Gtk::TargetEntry("gig::Script"));
1496     m_TreeViewScripts.drag_source_set(drag_target_gig_script);
1497     m_TreeViewScripts.signal_drag_begin().connect(
1498     sigc::mem_fun(*this, &MainWindow::on_scripts_treeview_drag_begin)
1499     );
1500     m_TreeViewScripts.signal_drag_data_get().connect(
1501     sigc::mem_fun(*this, &MainWindow::on_scripts_treeview_drag_data_get)
1502     );
1503    
1504 schoenebeck 1225 // establish drag&drop between samples tree view and dimension region 'Sample' text entry
1505 persson 2169 std::vector<Gtk::TargetEntry> drag_target_gig_sample;
1506     drag_target_gig_sample.push_back(Gtk::TargetEntry("gig::Sample"));
1507 schoenebeck 1225 m_TreeViewSamples.drag_source_set(drag_target_gig_sample);
1508 persson 1303 m_TreeViewSamples.signal_drag_begin().connect(
1509     sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_begin)
1510     );
1511 schoenebeck 1225 m_TreeViewSamples.signal_drag_data_get().connect(
1512     sigc::mem_fun(*this, &MainWindow::on_sample_treeview_drag_data_get)
1513     );
1514     dimreg_edit.wSample->drag_dest_set(drag_target_gig_sample);
1515     dimreg_edit.wSample->signal_drag_data_received().connect(
1516     sigc::mem_fun(*this, &MainWindow::on_sample_label_drop_drag_data_received)
1517     );
1518 persson 1261 dimreg_edit.signal_dimreg_changed().connect(
1519 schoenebeck 1322 sigc::hide(sigc::mem_fun(*this, &MainWindow::file_changed)));
1520 persson 1261 m_RegionChooser.signal_instrument_changed().connect(
1521     sigc::mem_fun(*this, &MainWindow::file_changed));
1522 schoenebeck 2773 m_RegionChooser.signal_instrument_changed().connect(
1523     sigc::mem_fun(*this, &MainWindow::region_changed));
1524 persson 1261 m_DimRegionChooser.signal_region_changed().connect(
1525     sigc::mem_fun(*this, &MainWindow::file_changed));
1526 persson 2423 instrumentProps.signal_changed().connect(
1527 persson 1261 sigc::mem_fun(*this, &MainWindow::file_changed));
1528 schoenebeck 3637 sampleProps.signal_changed().connect(
1529     sigc::mem_fun(*this, &MainWindow::file_changed));
1530 schoenebeck 3636 fileProps.signal_changed().connect(
1531 persson 1582 sigc::mem_fun(*this, &MainWindow::file_changed));
1532 persson 2507 midiRules.signal_changed().connect(
1533     sigc::mem_fun(*this, &MainWindow::file_changed));
1534 schoenebeck 1322
1535     dimreg_edit.signal_dimreg_to_be_changed().connect(
1536     dimreg_to_be_changed_signal.make_slot());
1537     dimreg_edit.signal_dimreg_changed().connect(
1538     dimreg_changed_signal.make_slot());
1539     dimreg_edit.signal_sample_ref_changed().connect(
1540     sample_ref_changed_signal.make_slot());
1541 schoenebeck 2621 sample_ref_changed_signal.connect(
1542     sigc::mem_fun(*this, &MainWindow::on_sample_ref_changed)
1543     );
1544     samples_to_be_removed_signal.connect(
1545     sigc::mem_fun(*this, &MainWindow::on_samples_to_be_removed)
1546     );
1547 schoenebeck 1322
1548 schoenebeck 2691 dimreg_edit.signal_select_sample().connect(
1549     sigc::mem_fun(*this, &MainWindow::select_sample)
1550     );
1551    
1552 schoenebeck 3737 dimreg_edit.editScriptSlotsButton.signal_clicked().connect(
1553     sigc::mem_fun(*this, &MainWindow::show_script_slots)
1554     );
1555     // simply sending the same signal (pair) to the sampler on 'patch' variable
1556     // changes as the already existing signal (pair) when the user edits the
1557     // script's source code, because the sampler would reload the source code
1558     // and the 'patch' variables from the instrument on this signal anyway
1559     dimreg_edit.scriptVars.signal_vars_to_be_changed.connect(
1560     [this](gig::Instrument* instr) {
1561     for (int i = 0; i < instr->ScriptSlotCount(); ++i) {
1562     gig::Script* script = instr->GetScriptOfSlot(i);
1563     signal_script_to_be_changed.emit(script);
1564     }
1565     }
1566     );
1567     dimreg_edit.scriptVars.signal_vars_changed.connect(
1568     [this](gig::Instrument* instr) {
1569     for (int i = 0; i < instr->ScriptSlotCount(); ++i) {
1570     gig::Script* script = instr->GetScriptOfSlot(i);
1571     signal_script_changed.emit(script);
1572     }
1573     }
1574     );
1575 schoenebeck 3749 dimreg_edit.scriptVars.signal_edit_script.connect(
1576     [this](gig::Script* script) {
1577     editScript(script);
1578     }
1579     );
1580 schoenebeck 3737
1581 schoenebeck 1322 m_RegionChooser.signal_instrument_struct_to_be_changed().connect(
1582     sigc::hide(
1583     sigc::bind(
1584     file_structure_to_be_changed_signal.make_slot(),
1585 persson 3461 #if SIGCXX_MAJOR_VERSION > 2 || (SIGCXX_MAJOR_VERSION == 2 && SIGCXX_MINOR_VERSION >= 8)
1586     std::ref(this->file)
1587     #else
1588 schoenebeck 1322 sigc::ref(this->file)
1589 persson 3461 #endif
1590 schoenebeck 1322 )
1591     )
1592     );
1593     m_RegionChooser.signal_instrument_struct_changed().connect(
1594     sigc::hide(
1595     sigc::bind(
1596     file_structure_changed_signal.make_slot(),
1597 persson 3461 #if SIGCXX_MAJOR_VERSION > 2 || (SIGCXX_MAJOR_VERSION == 2 && SIGCXX_MINOR_VERSION >= 8)
1598     std::ref(this->file)
1599     #else
1600 schoenebeck 1322 sigc::ref(this->file)
1601 persson 3461 #endif
1602 schoenebeck 1322 )
1603     )
1604     );
1605     m_RegionChooser.signal_region_to_be_changed().connect(
1606     region_to_be_changed_signal.make_slot());
1607     m_RegionChooser.signal_region_changed_signal().connect(
1608     region_changed_signal.make_slot());
1609    
1610 schoenebeck 1654 note_on_signal.connect(
1611     sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_on_event));
1612     note_off_signal.connect(
1613     sigc::mem_fun(m_RegionChooser, &RegionChooser::on_note_off_event));
1614    
1615 persson 1533 dimreg_all_regions.signal_toggled().connect(
1616     sigc::mem_fun(*this, &MainWindow::update_dimregs));
1617     dimreg_all_dimregs.signal_toggled().connect(
1618     sigc::mem_fun(*this, &MainWindow::dimreg_all_dimregs_toggled));
1619     dimreg_stereo.signal_toggled().connect(
1620     sigc::mem_fun(*this, &MainWindow::update_dimregs));
1621    
1622 schoenebeck 3340 m_searchText.signal_changed().connect(
1623 schoenebeck 3806 sigc::mem_fun(*m_refInstrumentsModelFilter.operator->(), &Gtk::TreeModelFilter::refilter)
1624 schoenebeck 3340 );
1625    
1626 schoenebeck 1225 file = 0;
1627 persson 1261 file_is_changed = false;
1628 schoenebeck 1225
1629 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
1630 schoenebeck 1225 show_all_children();
1631 schoenebeck 3364 #endif
1632 schoenebeck 1300
1633     // start with a new gig file by default
1634     on_action_file_new();
1635 schoenebeck 2550
1636 schoenebeck 3340 m_TreeViewNotebook.signal_switch_page().connect(
1637     sigc::mem_fun(*this, &MainWindow::on_notebook_tab_switched)
1638     );
1639    
1640 schoenebeck 2550 // select 'Instruments' tab by default
1641     // (gtk allows this only if the tab childs are visible, thats why it's here)
1642 schoenebeck 3144 m_TreeViewNotebook.set_current_page(1);
1643    
1644     Gtk::Clipboard::get()->signal_owner_change().connect(
1645     sigc::mem_fun(*this, &MainWindow::on_clipboard_owner_change)
1646     );
1647     updateClipboardPasteAvailable();
1648     updateClipboardCopyAvailable();
1649 schoenebeck 3157
1650     // setup macros and their keyboard accelerators
1651     {
1652 schoenebeck 3364 #if USE_GTKMM_BUILDER
1653     menuMacro = new Gtk::Menu(
1654     Glib::RefPtr<Gio::Menu>::cast_dynamic(
1655     m_uiManager->get_object("MenuMacro")
1656     )
1657     );
1658     #else
1659 schoenebeck 3157 Gtk::Menu* menuMacro = dynamic_cast<Gtk::MenuItem*>(
1660     uiManager->get_widget("/MenuBar/MenuMacro")
1661     )->get_submenu();
1662 schoenebeck 3364 #endif
1663 schoenebeck 3157
1664     const Gdk::ModifierType noModifier = (Gdk::ModifierType)0;
1665     Gtk::AccelMap::add_entry("<Macros>/macro_0", GDK_KEY_F1, noModifier);
1666     Gtk::AccelMap::add_entry("<Macros>/macro_1", GDK_KEY_F2, noModifier);
1667     Gtk::AccelMap::add_entry("<Macros>/macro_2", GDK_KEY_F3, noModifier);
1668     Gtk::AccelMap::add_entry("<Macros>/macro_3", GDK_KEY_F4, noModifier);
1669     Gtk::AccelMap::add_entry("<Macros>/macro_4", GDK_KEY_F5, noModifier);
1670     Gtk::AccelMap::add_entry("<Macros>/macro_5", GDK_KEY_F6, noModifier);
1671     Gtk::AccelMap::add_entry("<Macros>/macro_6", GDK_KEY_F7, noModifier);
1672     Gtk::AccelMap::add_entry("<Macros>/macro_7", GDK_KEY_F8, noModifier);
1673     Gtk::AccelMap::add_entry("<Macros>/macro_8", GDK_KEY_F9, noModifier);
1674     Gtk::AccelMap::add_entry("<Macros>/macro_9", GDK_KEY_F10, noModifier);
1675     Gtk::AccelMap::add_entry("<Macros>/macro_10", GDK_KEY_F11, noModifier);
1676     Gtk::AccelMap::add_entry("<Macros>/macro_11", GDK_KEY_F12, noModifier);
1677 schoenebeck 3417 Gtk::AccelMap::add_entry("<Macros>/macro_12", GDK_KEY_F13, noModifier);
1678     Gtk::AccelMap::add_entry("<Macros>/macro_13", GDK_KEY_F14, noModifier);
1679     Gtk::AccelMap::add_entry("<Macros>/macro_14", GDK_KEY_F15, noModifier);
1680     Gtk::AccelMap::add_entry("<Macros>/macro_15", GDK_KEY_F16, noModifier);
1681     Gtk::AccelMap::add_entry("<Macros>/macro_16", GDK_KEY_F17, noModifier);
1682     Gtk::AccelMap::add_entry("<Macros>/macro_17", GDK_KEY_F18, noModifier);
1683     Gtk::AccelMap::add_entry("<Macros>/macro_18", GDK_KEY_F19, noModifier);
1684 schoenebeck 3157 Gtk::AccelMap::add_entry("<Macros>/SetupMacros", 'm', primaryModifierKey);
1685    
1686     Glib::RefPtr<Gtk::AccelGroup> accelGroup = this->get_accel_group();
1687     menuMacro->set_accel_group(accelGroup);
1688    
1689     updateMacroMenu();
1690     }
1691 schoenebeck 3258
1692 schoenebeck 3339 // setup "Assign Scripts" keyboard accelerators
1693     {
1694     Gtk::AccelMap::add_entry("<Scripts>/script_0", GDK_KEY_F1, Gdk::SHIFT_MASK);
1695     Gtk::AccelMap::add_entry("<Scripts>/script_1", GDK_KEY_F2, Gdk::SHIFT_MASK);
1696     Gtk::AccelMap::add_entry("<Scripts>/script_2", GDK_KEY_F3, Gdk::SHIFT_MASK);
1697     Gtk::AccelMap::add_entry("<Scripts>/script_3", GDK_KEY_F4, Gdk::SHIFT_MASK);
1698     Gtk::AccelMap::add_entry("<Scripts>/script_4", GDK_KEY_F5, Gdk::SHIFT_MASK);
1699     Gtk::AccelMap::add_entry("<Scripts>/script_5", GDK_KEY_F6, Gdk::SHIFT_MASK);
1700     Gtk::AccelMap::add_entry("<Scripts>/script_6", GDK_KEY_F7, Gdk::SHIFT_MASK);
1701     Gtk::AccelMap::add_entry("<Scripts>/script_7", GDK_KEY_F8, Gdk::SHIFT_MASK);
1702     Gtk::AccelMap::add_entry("<Scripts>/script_8", GDK_KEY_F9, Gdk::SHIFT_MASK);
1703     Gtk::AccelMap::add_entry("<Scripts>/script_9", GDK_KEY_F10, Gdk::SHIFT_MASK);
1704     Gtk::AccelMap::add_entry("<Scripts>/script_10", GDK_KEY_F11, Gdk::SHIFT_MASK);
1705     Gtk::AccelMap::add_entry("<Scripts>/script_11", GDK_KEY_F12, Gdk::SHIFT_MASK);
1706 schoenebeck 3417 Gtk::AccelMap::add_entry("<Scripts>/script_12", GDK_KEY_F13, Gdk::SHIFT_MASK);
1707     Gtk::AccelMap::add_entry("<Scripts>/script_13", GDK_KEY_F14, Gdk::SHIFT_MASK);
1708     Gtk::AccelMap::add_entry("<Scripts>/script_14", GDK_KEY_F15, Gdk::SHIFT_MASK);
1709     Gtk::AccelMap::add_entry("<Scripts>/script_15", GDK_KEY_F16, Gdk::SHIFT_MASK);
1710     Gtk::AccelMap::add_entry("<Scripts>/script_16", GDK_KEY_F17, Gdk::SHIFT_MASK);
1711     Gtk::AccelMap::add_entry("<Scripts>/script_17", GDK_KEY_F18, Gdk::SHIFT_MASK);
1712     Gtk::AccelMap::add_entry("<Scripts>/script_18", GDK_KEY_F19, Gdk::SHIFT_MASK);
1713 schoenebeck 3419 Gtk::AccelMap::add_entry("<Scripts>/DropAllScriptSlots", GDK_KEY_BackSpace, Gdk::SHIFT_MASK);
1714 schoenebeck 3339
1715     Glib::RefPtr<Gtk::AccelGroup> accelGroup = this->get_accel_group();
1716     assign_scripts_menu->set_accel_group(accelGroup);
1717     }
1718    
1719 schoenebeck 3409 on_show_tooltips_changed();
1720    
1721 schoenebeck 3258 Glib::signal_idle().connect_once(
1722     sigc::mem_fun(*this, &MainWindow::bringToFront),
1723     200
1724     );
1725 schoenebeck 1225 }
1726    
1727     MainWindow::~MainWindow()
1728     {
1729     }
1730    
1731 schoenebeck 3258 void MainWindow::bringToFront() {
1732     #if defined(__APPLE__)
1733     macRaiseAppWindow();
1734     #endif
1735     raise();
1736     present();
1737     }
1738    
1739 schoenebeck 3157 void MainWindow::updateMacroMenu() {
1740 schoenebeck 3364 #if !USE_GTKMM_BUILDER
1741 schoenebeck 3157 Gtk::Menu* menuMacro = dynamic_cast<Gtk::MenuItem*>(
1742     uiManager->get_widget("/MenuBar/MenuMacro")
1743     )->get_submenu();
1744 schoenebeck 3364 #endif
1745 schoenebeck 3157
1746     // remove all entries from "Macro" menu
1747     {
1748     const std::vector<Gtk::Widget*> children = menuMacro->get_children();
1749     for (int i = 0; i < children.size(); ++i) {
1750     Gtk::Widget* child = children[i];
1751     menuMacro->remove(*child);
1752     delete child;
1753     }
1754     }
1755    
1756     // (re)load all macros from config file
1757     try {
1758     Settings::singleton()->loadMacros(m_macros);
1759     } catch (Serialization::Exception e) {
1760     std::cerr << "Exception while loading macros: " << e.Message << std::endl;
1761     } catch (...) {
1762     std::cerr << "Unknown exception while loading macros!" << std::endl;
1763     }
1764    
1765     // add all configured macros as menu items to the "Macro" menu
1766     for (int iMacro = 0; iMacro < m_macros.size(); ++iMacro) {
1767     const Serialization::Archive& macro = m_macros[iMacro];
1768     std::string name =
1769     macro.name().empty() ?
1770     (std::string(_("Unnamed Macro")) + " " + ToString(iMacro+1)) : macro.name();
1771     Gtk::MenuItem* item = new Gtk::MenuItem(name);
1772     item->signal_activate().connect(
1773     sigc::bind(
1774     sigc::mem_fun(*this, &MainWindow::onMacroSelected), iMacro
1775     )
1776     );
1777     menuMacro->append(*item);
1778     item->set_accel_path("<Macros>/macro_" + ToString(iMacro));
1779 schoenebeck 3174 Glib::ustring comment = macro.comment();
1780     if (!comment.empty())
1781     item->set_tooltip_text(comment);
1782 schoenebeck 3157 }
1783     // if there are no macros configured at all, then show a dummy entry instead
1784     if (m_macros.empty()) {
1785     Gtk::MenuItem* item = new Gtk::MenuItem(_("No Macros"));
1786     item->set_sensitive(false);
1787     menuMacro->append(*item);
1788     }
1789    
1790     // add separator line to menu
1791     menuMacro->append(*new Gtk::SeparatorMenuItem);
1792    
1793     {
1794     Gtk::MenuItem* item = new Gtk::MenuItem(_("Setup Macros ..."));
1795     item->signal_activate().connect(
1796     sigc::mem_fun(*this, &MainWindow::setupMacros)
1797     );
1798     menuMacro->append(*item);
1799     item->set_accel_path("<Macros>/SetupMacros");
1800     }
1801    
1802 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
1803 schoenebeck 3157 menuMacro->show_all_children();
1804 schoenebeck 3364 #endif
1805 schoenebeck 3157 }
1806    
1807     void MainWindow::onMacroSelected(int iMacro) {
1808     printf("onMacroSelected(%d)\n", iMacro);
1809     if (iMacro < 0 || iMacro >= m_macros.size()) return;
1810     Glib::ustring errorText;
1811     try {
1812     applyMacro(m_macros[iMacro]);
1813     } catch (Serialization::Exception e) {
1814     errorText = e.Message;
1815     } catch (...) {
1816     errorText = _("Unknown exception while applying macro");
1817     }
1818     if (!errorText.empty()) {
1819     Glib::ustring txt = _("Applying macro failed:\n") + errorText;
1820     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1821     msg.run();
1822     }
1823     }
1824    
1825     void MainWindow::setupMacros() {
1826     MacrosSetup* setup = new MacrosSetup();
1827 schoenebeck 3160 gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
1828     setup->setMacros(m_macros, &m_serializationArchive, pDimRgn);
1829 schoenebeck 3157 setup->signal_macros_changed().connect(
1830     sigc::mem_fun(*this, &MainWindow::onMacrosSetupChanged)
1831     );
1832     setup->show();
1833     }
1834    
1835     void MainWindow::onMacrosSetupChanged(const std::vector<Serialization::Archive>& macros) {
1836     m_macros = macros;
1837     Settings::singleton()->saveMacros(m_macros);
1838     updateMacroMenu();
1839     }
1840    
1841 schoenebeck 3344 //NOTE: the actual signal's first argument for argument 'page' is on some gtkmm version GtkNotebookPage* and on some Gtk::Widget*. Since we don't need that argument, it is simply void* here for now.
1842     void MainWindow::on_notebook_tab_switched(void* page, guint page_num) {
1843 schoenebeck 3340 bool isInstrumentsPage = (page_num == 1);
1844     // so far we only support filtering for the instruments list, so hide the
1845     // filter text entry field if another tab is selected
1846     m_searchField.set_visible(isInstrumentsPage);
1847     }
1848    
1849 persson 1261 bool MainWindow::on_delete_event(GdkEventAny* event)
1850     {
1851 schoenebeck 1382 return !file_is_shared && file_is_changed && !close_confirmation_dialog();
1852 persson 1261 }
1853    
1854     void MainWindow::on_action_quit()
1855     {
1856 schoenebeck 1382 if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
1857 persson 1261 hide();
1858     }
1859    
1860 schoenebeck 1225 void MainWindow::region_changed()
1861     {
1862     m_DimRegionChooser.set_region(m_RegionChooser.get_region());
1863     }
1864    
1865 persson 1533 gig::Instrument* MainWindow::get_instrument()
1866 schoenebeck 1225 {
1867 schoenebeck 3807 gig::Instrument* instrument = NULL;
1868    
1869     // get indeces of visual selection
1870 schoenebeck 3806 std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
1871 schoenebeck 2994 if (rows.empty()) return NULL;
1872 schoenebeck 3807
1873     // convert index of visual selection (i.e. if filtered) to index of model
1874     Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
1875     if (!path) return NULL;
1876    
1877 schoenebeck 3364 //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
1878 schoenebeck 3807 Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
1879 schoenebeck 1225 if (it) {
1880     Gtk::TreeModel::Row row = *it;
1881 schoenebeck 3806 instrument = row[m_InstrumentsModel.m_col_instr];
1882 persson 1533 }
1883     return instrument;
1884     }
1885 schoenebeck 1225
1886 persson 1533 void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
1887     {
1888     if (all_dimregs) {
1889     for (int i = 0 ; i < region->DimensionRegions ; i++) {
1890     if (region->pDimensionRegions[i]) {
1891     dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
1892     }
1893     }
1894 schoenebeck 1225 } else {
1895 persson 1533 m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
1896 schoenebeck 1225 }
1897     }
1898    
1899 persson 1533 void MainWindow::update_dimregs()
1900     {
1901     dimreg_edit.dimregs.clear();
1902     bool all_regions = dimreg_all_regions.get_active();
1903     bool stereo = dimreg_stereo.get_active();
1904     bool all_dimregs = dimreg_all_dimregs.get_active();
1905    
1906     if (all_regions) {
1907     gig::Instrument* instrument = get_instrument();
1908     if (instrument) {
1909     for (gig::Region* region = instrument->GetFirstRegion() ;
1910     region ;
1911     region = instrument->GetNextRegion()) {
1912     add_region_to_dimregs(region, stereo, all_dimregs);
1913     }
1914     }
1915     } else {
1916     gig::Region* region = m_RegionChooser.get_region();
1917     if (region) {
1918     add_region_to_dimregs(region, stereo, all_dimregs);
1919     }
1920     }
1921 schoenebeck 3089
1922 schoenebeck 3148 m_RegionChooser.setModifyAllRegions(all_regions);
1923 schoenebeck 3089 m_DimRegionChooser.setModifyAllRegions(all_regions);
1924     m_DimRegionChooser.setModifyAllDimensionRegions(all_dimregs);
1925     m_DimRegionChooser.setModifyBothChannels(stereo);
1926 schoenebeck 3144
1927     updateClipboardCopyAvailable();
1928 persson 1533 }
1929    
1930     void MainWindow::dimreg_all_dimregs_toggled()
1931     {
1932     dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
1933     update_dimregs();
1934     }
1935    
1936     void MainWindow::dimreg_changed()
1937     {
1938     update_dimregs();
1939 schoenebeck 2626 dimreg_edit.set_dim_region(m_DimRegionChooser.get_main_dimregion());
1940 persson 1533 }
1941    
1942     void MainWindow::on_sel_change()
1943     {
1944 schoenebeck 3364 #if !USE_GTKMM_BUILDER
1945 persson 2442 // select item in instrument menu
1946 schoenebeck 3806 std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
1947 schoenebeck 2994 if (!rows.empty()) {
1948 schoenebeck 3809 // convert index of visual selection (i.e. if filtered) to index of model
1949     Gtk::TreeModel::Path row = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
1950     Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(row);
1951 schoenebeck 2994 if (it) {
1952     Gtk::TreePath path(it);
1953     int index = path[0];
1954     const std::vector<Gtk::Widget*> children =
1955     instrument_menu->get_children();
1956     static_cast<Gtk::RadioMenuItem*>(children[index])->set_active();
1957     }
1958 persson 2442 }
1959 schoenebeck 3364 #endif
1960 persson 2442
1961 schoenebeck 3339 updateScriptListOfMenu();
1962    
1963 schoenebeck 3737 gig::Instrument* instr = get_instrument();
1964 schoenebeck 2689
1965 schoenebeck 3737 m_RegionChooser.set_instrument(instr);
1966     dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
1967    
1968 schoenebeck 2689 if (Settings::singleton()->syncSamplerInstrumentSelection) {
1969     switch_sampler_instrument_signal.emit(get_instrument());
1970     }
1971 persson 1533 }
1972    
1973 persson 3470
1974     LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
1975 persson 3472 filename(filename), gig(gig),
1976     #ifdef GLIB_THREADS
1977     thread(0),
1978     #endif
1979     progress(0.f)
1980 persson 3470 {
1981     }
1982    
1983 schoenebeck 1225 void loader_progress_callback(gig::progress_t* progress)
1984     {
1985 persson 3470 LoaderSaverBase* loader = static_cast<LoaderSaverBase*>(progress->custom);
1986 schoenebeck 1225 loader->progress_callback(progress->factor);
1987     }
1988    
1989 persson 3470 void LoaderSaverBase::progress_callback(float fraction)
1990 schoenebeck 1225 {
1991     {
1992 persson 3472 #ifdef GLIB_THREADS
1993 persson 2325 Glib::Threads::Mutex::Lock lock(progressMutex);
1994 persson 3472 #else
1995     std::lock_guard<std::mutex> lock(progressMutex);
1996     #endif
1997 schoenebeck 1225 progress = fraction;
1998     }
1999     progress_dispatcher();
2000     }
2001    
2002 persson 3021 #if defined(WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
2003     // make sure stack is 16-byte aligned for SSE instructions
2004     __attribute__((force_align_arg_pointer))
2005     #endif
2006 persson 3470 void LoaderSaverBase::thread_function()
2007 schoenebeck 1225 {
2008 persson 3472 #ifdef GLIB_THREADS
2009 persson 2841 printf("thread_function self=%p\n",
2010     static_cast<void*>(Glib::Threads::Thread::self()));
2011 persson 3472 #else
2012     std::cout << "thread_function self=" << std::this_thread::get_id() << "\n";
2013     #endif
2014 schoenebeck 2683 printf("Start %s\n", filename.c_str());
2015     try {
2016     gig::progress_t progress;
2017     progress.callback = loader_progress_callback;
2018     progress.custom = this;
2019 schoenebeck 1225
2020 persson 3470 thread_function_sub(progress);
2021 schoenebeck 2683 printf("End\n");
2022     finished_dispatcher();
2023     } catch (RIFF::Exception e) {
2024     error_message = e.Message;
2025     error_dispatcher.emit();
2026     } catch (...) {
2027     error_message = _("Unknown exception occurred");
2028     error_dispatcher.emit();
2029     }
2030 schoenebeck 1225 }
2031    
2032 persson 3470 void LoaderSaverBase::launch()
2033 schoenebeck 1225 {
2034 persson 3472 #ifdef GLIB_THREADS
2035 persson 2332 #ifdef OLD_THREADS
2036 persson 3470 thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
2037 persson 2332 #else
2038 persson 3470 thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
2039 persson 2332 #endif
2040 persson 2841 printf("launch thread=%p\n", static_cast<void*>(thread));
2041 persson 3472 #else
2042     thread = std::thread([this](){ thread_function(); });
2043     std::cout << "launch thread=" << thread.get_id() << "\n";
2044     #endif
2045 schoenebeck 1225 }
2046    
2047 persson 3470 float LoaderSaverBase::get_progress()
2048 schoenebeck 1225 {
2049 persson 3472 #ifdef GLIB_THREADS
2050 persson 3470 Glib::Threads::Mutex::Lock lock(progressMutex);
2051 persson 3472 #else
2052     std::lock_guard<std::mutex> lock(progressMutex);
2053     #endif
2054 persson 3470 return progress;
2055 schoenebeck 1225 }
2056    
2057 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_progress()
2058 schoenebeck 1225 {
2059     return progress_dispatcher;
2060     }
2061    
2062 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_finished()
2063 schoenebeck 1225 {
2064     return finished_dispatcher;
2065     }
2066    
2067 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_error()
2068 schoenebeck 2683 {
2069     return error_dispatcher;
2070     }
2071    
2072 persson 3471 void LoaderSaverBase::join() {
2073 persson 3472 #ifdef GLIB_THREADS
2074 persson 3471 thread->join();
2075 persson 3472 #else
2076     thread.join();
2077     #endif
2078 persson 3471 }
2079 schoenebeck 2683
2080 persson 3471
2081 persson 3470 Loader::Loader(const char* filename) :
2082     LoaderSaverBase(filename, 0)
2083 schoenebeck 2683 {
2084     }
2085    
2086 persson 3470 void Loader::thread_function_sub(gig::progress_t& progress)
2087 schoenebeck 2683 {
2088 persson 3470 RIFF::File* riff = new RIFF::File(filename);
2089     gig = new gig::File(riff);
2090 schoenebeck 2683
2091 persson 3470 gig->GetInstrument(0, &progress);
2092 schoenebeck 2683 }
2093    
2094 persson 3470
2095     Saver::Saver(gig::File* file, Glib::ustring filename) :
2096     LoaderSaverBase(filename, file)
2097 schoenebeck 2683 {
2098     }
2099    
2100 persson 3470 void Saver::thread_function_sub(gig::progress_t& progress)
2101 schoenebeck 2683 {
2102 persson 3470 // if no filename was provided, that means "save", if filename was provided means "save as"
2103     if (filename.empty()) {
2104     if (!Settings::singleton()->saveWithTemporaryFile) {
2105     // save directly over the existing .gig file
2106     // (requires less disk space than solution below
2107     // but may be slower)
2108     gig->Save(&progress);
2109     } else {
2110     // save the file as separate temporary file first,
2111     // then move the saved file over the old file
2112     // (may result in performance speedup during save)
2113     gig::String tmpname = filename + ".TMP";
2114     gig->Save(tmpname, &progress);
2115     #if defined(WIN32)
2116     if (!DeleteFile(filename.c_str())) {
2117     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file).");
2118     }
2119     #else // POSIX ...
2120     if (unlink(filename.c_str())) {
2121     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file): " + gig::String(strerror(errno)));
2122     }
2123     #endif
2124     if (rename(tmpname.c_str(), filename.c_str())) {
2125     #if defined(WIN32)
2126     throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file).");
2127 schoenebeck 2683 #else
2128 persson 3470 throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file): " + gig::String(strerror(errno)));
2129 schoenebeck 2683 #endif
2130 persson 3470 }
2131     }
2132     } else {
2133     gig->Save(filename, &progress);
2134 schoenebeck 2683 }
2135     }
2136    
2137    
2138     ProgressDialog::ProgressDialog(const Glib::ustring& title, Gtk::Window& parent)
2139 schoenebeck 1225 : Gtk::Dialog(title, parent, true)
2140     {
2141 schoenebeck 3364 #if USE_GTKMM_BOX
2142     get_content_area()->pack_start(progressBar);
2143     #else
2144 schoenebeck 1225 get_vbox()->pack_start(progressBar);
2145 schoenebeck 3364 #endif
2146     #if HAS_GTKMM_SHOW_ALL_CHILDREN
2147 schoenebeck 1225 show_all_children();
2148 schoenebeck 3364 #endif
2149 schoenebeck 2683 resize(600,50);
2150 schoenebeck 1225 }
2151    
2152     // Clear all GUI elements / controls. This method is typically called
2153     // before a new .gig file is to be created or to be loaded.
2154     void MainWindow::__clear() {
2155     // forget all samples that ought to be imported
2156     m_SampleImportQueue.clear();
2157     // clear the samples and instruments tree views
2158 schoenebeck 3806 m_refInstrumentsTreeModel->clear();
2159 schoenebeck 1225 m_refSamplesTreeModel->clear();
2160 schoenebeck 2615 m_refScriptsTreeModel->clear();
2161 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2162 persson 2442 // remove all entries from "Instrument" menu
2163     while (!instrument_menu->get_children().empty()) {
2164     remove_instrument_from_menu(0);
2165     }
2166 schoenebeck 3364 #endif
2167 schoenebeck 1225 // free libgig's gig::File instance
2168 schoenebeck 1382 if (file && !file_is_shared) delete file;
2169     file = NULL;
2170 schoenebeck 1411 set_file_is_shared(false);
2171 schoenebeck 1225 }
2172    
2173 schoenebeck 2553 void MainWindow::__refreshEntireGUI() {
2174     // clear the samples and instruments tree views
2175 schoenebeck 3806 m_refInstrumentsTreeModel->clear();
2176 schoenebeck 2553 m_refSamplesTreeModel->clear();
2177 schoenebeck 2615 m_refScriptsTreeModel->clear();
2178 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2179 schoenebeck 2553 // remove all entries from "Instrument" menu
2180     while (!instrument_menu->get_children().empty()) {
2181     remove_instrument_from_menu(0);
2182     }
2183 schoenebeck 3364 #endif
2184 schoenebeck 2553
2185     if (!this->file) return;
2186    
2187     load_gig(
2188     this->file, this->file->pInfo->Name.c_str(), this->file_is_shared
2189     );
2190     }
2191    
2192 schoenebeck 1225 void MainWindow::on_action_file_new()
2193     {
2194 schoenebeck 1382 if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
2195 persson 1261
2196 schoenebeck 1382 if (file_is_shared && !leaving_shared_mode_dialog()) return;
2197    
2198 schoenebeck 1225 // clear all GUI elements
2199     __clear();
2200     // create a new .gig file (virtually yet)
2201     gig::File* pFile = new gig::File;
2202     // already add one new instrument by default
2203     gig::Instrument* pInstrument = pFile->AddInstrument();
2204 persson 2446 pInstrument->pInfo->Name = gig_from_utf8(_("Unnamed Instrument"));
2205 schoenebeck 1225 // update GUI with that new gig::File
2206 persson 1261 load_gig(pFile, 0 /*no file name yet*/);
2207 schoenebeck 1225 }
2208    
2209 persson 1261 bool MainWindow::close_confirmation_dialog()
2210     {
2211     gchar* msg = g_strdup_printf(_("Save changes to \"%s\" before closing?"),
2212     Glib::filename_display_basename(filename).c_str());
2213     Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
2214     g_free(msg);
2215     dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));
2216     dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);
2217 schoenebeck 3364 #if HAS_GTKMM_STOCK
2218 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2219     dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);
2220 schoenebeck 3364 #else
2221     dialog.add_button(_("_OK"), Gtk::RESPONSE_OK);
2222     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2223     #endif
2224 persson 1261 dialog.set_default_response(Gtk::RESPONSE_YES);
2225     int response = dialog.run();
2226 persson 1303 dialog.hide();
2227 schoenebeck 2683
2228 schoenebeck 2694 // user decided to exit app without saving
2229     if (response == Gtk::RESPONSE_NO) return true;
2230    
2231     // user cancelled dialog, thus don't close app
2232     if (response == Gtk::RESPONSE_CANCEL) return false;
2233    
2234 schoenebeck 2683 // TODO: the following return valid is disabled and hard coded instead for
2235     // now, due to the fact that saving with progress bar is now implemented
2236     // asynchronously, as a result the app does not close automatically anymore
2237     // after saving the file has completed
2238     //
2239     // if (response == Gtk::RESPONSE_YES) return file_save();
2240     // return response != Gtk::RESPONSE_CANCEL;
2241     //
2242     if (response == Gtk::RESPONSE_YES) file_save();
2243     return false; // always prevent closing the app for now (see comment above)
2244 persson 1261 }
2245    
2246 schoenebeck 1382 bool MainWindow::leaving_shared_mode_dialog() {
2247     Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
2248     Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
2249     dialog.set_secondary_text(
2250     _("If you proceed to work on another instrument file, it won't be "
2251     "used by the sampler until you tell the sampler explicitly to "
2252 persson 2151 "load it."));
2253 schoenebeck 1382 dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
2254 schoenebeck 3364 #if HAS_GTKMM_STOCK
2255 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2256 schoenebeck 3364 #else
2257     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2258     #endif
2259 schoenebeck 1382 dialog.set_default_response(Gtk::RESPONSE_CANCEL);
2260     int response = dialog.run();
2261     dialog.hide();
2262     return response == Gtk::RESPONSE_YES;
2263     }
2264    
2265 schoenebeck 1225 void MainWindow::on_action_file_open()
2266     {
2267 schoenebeck 1382 if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
2268 persson 1261
2269 schoenebeck 1382 if (file_is_shared && !leaving_shared_mode_dialog()) return;
2270    
2271 schoenebeck 1225 Gtk::FileChooserDialog dialog(*this, _("Open file"));
2272 schoenebeck 3364 #if HAS_GTKMM_STOCK
2273 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2274     dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
2275 schoenebeck 3364 #else
2276     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2277     dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
2278     #endif
2279 persson 1261 dialog.set_default_response(Gtk::RESPONSE_OK);
2280 persson 2169 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
2281 schoenebeck 1225 Gtk::FileFilter filter;
2282     filter.add_pattern("*.gig");
2283 persson 2169 #else
2284     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
2285     filter->add_pattern("*.gig");
2286     #endif
2287 schoenebeck 1225 dialog.set_filter(filter);
2288 persson 1725 if (current_gig_dir != "") {
2289     dialog.set_current_folder(current_gig_dir);
2290 persson 1261 }
2291 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
2292 persson 3477 dialog.hide();
2293 persson 1261 std::string filename = dialog.get_filename();
2294     printf("filename=%s\n", filename.c_str());
2295 persson 3472 #ifdef GLIB_THREADS
2296 persson 2841 printf("on_action_file_open self=%p\n",
2297     static_cast<void*>(Glib::Threads::Thread::self()));
2298 persson 3472 #else
2299     std::cout << "on_action_file_open self=" <<
2300     std::this_thread::get_id() << "\n";
2301     #endif
2302 persson 1261 load_file(filename.c_str());
2303 persson 1725 current_gig_dir = Glib::path_get_dirname(filename);
2304 schoenebeck 1225 }
2305     }
2306    
2307     void MainWindow::load_file(const char* name)
2308     {
2309 persson 1303 __clear();
2310 schoenebeck 2683
2311     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2312     _("Loading") + Glib::ustring(" '") +
2313     Glib::filename_display_basename(name) + "' ...",
2314     *this
2315     );
2316 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2317 schoenebeck 2683 progress_dialog->show_all();
2318 schoenebeck 3364 #endif
2319 schoenebeck 2683 loader = new Loader(name); //FIXME: memory leak!
2320 schoenebeck 1225 loader->signal_progress().connect(
2321     sigc::mem_fun(*this, &MainWindow::on_loader_progress));
2322     loader->signal_finished().connect(
2323     sigc::mem_fun(*this, &MainWindow::on_loader_finished));
2324 schoenebeck 2683 loader->signal_error().connect(
2325     sigc::mem_fun(*this, &MainWindow::on_loader_error));
2326 schoenebeck 1225 loader->launch();
2327     }
2328    
2329     void MainWindow::load_instrument(gig::Instrument* instr) {
2330     if (!instr) {
2331     Glib::ustring txt = "Provided instrument is NULL!\n";
2332     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2333     msg.run();
2334     Gtk::Main::quit();
2335     }
2336 schoenebeck 1328 // clear all GUI elements
2337     __clear();
2338     // load the instrument
2339 schoenebeck 1225 gig::File* pFile = (gig::File*) instr->GetParent();
2340 schoenebeck 1382 load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
2341 schoenebeck 2664 // automatically select the given instrument
2342     int i = 0;
2343     for (gig::Instrument* instrument = pFile->GetFirstInstrument(); instrument;
2344     instrument = pFile->GetNextInstrument(), ++i)
2345     {
2346     if (instrument == instr) {
2347     // select item in "instruments" tree view
2348 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(Gtk::TreePath(ToString(i)));
2349 schoenebeck 2664 // make sure the selected item in the "instruments" tree view is
2350     // visible (scroll to it)
2351 schoenebeck 3806 m_TreeViewInstruments.scroll_to_row(Gtk::TreePath(ToString(i)));
2352 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2353 schoenebeck 2664 // select item in instrument menu
2354     {
2355     const std::vector<Gtk::Widget*> children =
2356     instrument_menu->get_children();
2357     static_cast<Gtk::RadioMenuItem*>(children[i])->set_active();
2358     }
2359 schoenebeck 3364 #endif
2360 schoenebeck 2664 // update region chooser and dimension region chooser
2361     m_RegionChooser.set_instrument(instr);
2362     break;
2363     }
2364     }
2365 schoenebeck 1225 }
2366    
2367     void MainWindow::on_loader_progress()
2368     {
2369 schoenebeck 2683 progress_dialog->set_fraction(loader->get_progress());
2370 schoenebeck 1225 }
2371    
2372     void MainWindow::on_loader_finished()
2373     {
2374 persson 3471 loader->join();
2375 schoenebeck 1225 printf("Loader finished!\n");
2376 persson 3472 #ifdef GLIB_THREADS
2377 persson 2841 printf("on_loader_finished self=%p\n",
2378     static_cast<void*>(Glib::Threads::Thread::self()));
2379 persson 3472 #else
2380     std::cout << "on_loader_finished self=" <<
2381     std::this_thread::get_id() << "\n";
2382     #endif
2383 schoenebeck 2683 load_gig(loader->gig, loader->filename.c_str());
2384     progress_dialog->hide();
2385 schoenebeck 1225 }
2386    
2387 schoenebeck 2683 void MainWindow::on_loader_error()
2388     {
2389 persson 3471 loader->join();
2390 schoenebeck 2683 Glib::ustring txt = _("Could not load file: ") + loader->error_message;
2391     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2392     msg.run();
2393     progress_dialog->hide();
2394     }
2395    
2396 schoenebeck 1225 void MainWindow::on_action_file_save()
2397     {
2398 persson 1261 file_save();
2399     }
2400    
2401 persson 1303 bool MainWindow::check_if_savable()
2402     {
2403     if (!file) return false;
2404    
2405     if (!file->GetFirstSample()) {
2406     Gtk::MessageDialog(*this, _("The file could not be saved "
2407     "because it contains no samples"),
2408     false, Gtk::MESSAGE_ERROR).run();
2409     return false;
2410     }
2411    
2412     for (gig::Instrument* instrument = file->GetFirstInstrument() ; instrument ;
2413     instrument = file->GetNextInstrument()) {
2414     if (!instrument->GetFirstRegion()) {
2415     Gtk::MessageDialog(*this, _("The file could not be saved "
2416     "because there are instruments "
2417     "that have no regions"),
2418     false, Gtk::MESSAGE_ERROR).run();
2419     return false;
2420     }
2421     }
2422     return true;
2423     }
2424    
2425 persson 1261 bool MainWindow::file_save()
2426     {
2427 persson 1303 if (!check_if_savable()) return false;
2428 schoenebeck 1382 if (!file_is_shared && !file_has_name) return file_save_as();
2429 persson 1261
2430 schoenebeck 1225 std::cout << "Saving file\n" << std::flush;
2431 schoenebeck 1322 file_structure_to_be_changed_signal.emit(this->file);
2432 schoenebeck 2683
2433     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2434     _("Saving") + Glib::ustring(" '") +
2435     Glib::filename_display_basename(this->filename) + "' ...",
2436     *this
2437     );
2438 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2439 schoenebeck 2683 progress_dialog->show_all();
2440 schoenebeck 3364 #endif
2441 schoenebeck 2683 saver = new Saver(this->file); //FIXME: memory leak!
2442     saver->signal_progress().connect(
2443     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2444     saver->signal_finished().connect(
2445     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2446     saver->signal_error().connect(
2447     sigc::mem_fun(*this, &MainWindow::on_saver_error));
2448     saver->launch();
2449    
2450     return true;
2451     }
2452    
2453     void MainWindow::on_saver_progress()
2454     {
2455     progress_dialog->set_fraction(saver->get_progress());
2456     }
2457    
2458     void MainWindow::on_saver_error()
2459     {
2460 persson 3471 saver->join();
2461 schoenebeck 2683 file_structure_changed_signal.emit(this->file);
2462     Glib::ustring txt = _("Could not save file: ") + saver->error_message;
2463     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2464     msg.run();
2465     }
2466    
2467     void MainWindow::on_saver_finished()
2468     {
2469 persson 3471 saver->join();
2470 schoenebeck 2683 this->file = saver->gig;
2471     this->filename = saver->filename;
2472     current_gig_dir = Glib::path_get_dirname(filename);
2473     set_title(Glib::filename_display_basename(filename));
2474     file_has_name = true;
2475     file_is_changed = false;
2476     std::cout << "Saving file done. Importing queued samples now ...\n" << std::flush;
2477 schoenebeck 1225 __import_queued_samples();
2478 schoenebeck 2683 std::cout << "Importing queued samples done.\n" << std::flush;
2479    
2480 schoenebeck 1322 file_structure_changed_signal.emit(this->file);
2481 schoenebeck 2683
2482 schoenebeck 2697 __refreshEntireGUI();
2483 schoenebeck 2683 progress_dialog->hide();
2484 schoenebeck 1225 }
2485    
2486     void MainWindow::on_action_file_save_as()
2487     {
2488 persson 1303 if (!check_if_savable()) return;
2489 persson 1261 file_save_as();
2490     }
2491    
2492     bool MainWindow::file_save_as()
2493     {
2494 schoenebeck 3158 Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);
2495 schoenebeck 3364 #if HAS_GTKMM_STOCK
2496 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2497     dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
2498 schoenebeck 3364 #else
2499     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2500     dialog.add_button(_("_Save"), Gtk::RESPONSE_OK);
2501     #endif
2502 persson 1261 dialog.set_default_response(Gtk::RESPONSE_OK);
2503 persson 2151 dialog.set_do_overwrite_confirmation();
2504 persson 1261
2505 persson 2169 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
2506 schoenebeck 1225 Gtk::FileFilter filter;
2507     filter.add_pattern("*.gig");
2508 persson 2169 #else
2509     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
2510     filter->add_pattern("*.gig");
2511     #endif
2512 schoenebeck 1225 dialog.set_filter(filter);
2513 persson 1261
2514 schoenebeck 1679 // set initial dir and filename of the Save As dialog
2515     // and prepare that initial filename as a copy of the gig
2516     {
2517     std::string basename = Glib::path_get_basename(filename);
2518     std::string dir = Glib::path_get_dirname(filename);
2519 persson 1831 basename = std::string(_("copy_of_")) + basename;
2520 schoenebeck 1679 Glib::ustring copyFileName = Glib::build_filename(dir, basename);
2521     if (Glib::path_is_absolute(filename)) {
2522     dialog.set_filename(copyFileName);
2523     } else {
2524 persson 1725 if (current_gig_dir != "") dialog.set_current_folder(current_gig_dir);
2525 schoenebeck 1679 }
2526     dialog.set_current_name(Glib::filename_display_basename(copyFileName));
2527 persson 1261 }
2528    
2529 schoenebeck 1679 // show warning in the dialog
2530 schoenebeck 3364 HBox descriptionArea;
2531 schoenebeck 1679 descriptionArea.set_spacing(15);
2532 persson 2845 Gtk::Image warningIcon;
2533     warningIcon.set_from_icon_name("dialog-warning",
2534     Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
2535 schoenebeck 1679 descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
2536 persson 2344 #if GTKMM_MAJOR_VERSION < 3
2537 persson 1799 view::WrapLabel description;
2538 persson 2344 #else
2539     Gtk::Label description;
2540     description.set_line_wrap();
2541     #endif
2542 schoenebeck 1679 description.set_markup(
2543     _("\n<b>CAUTION:</b> You <b>MUST</b> use the "
2544     "<span style=\"italic\">\"Save\"</span> dialog instead of "
2545     "<span style=\"italic\">\"Save As...\"</span> if you want to save "
2546     "to the same .gig file. Using "
2547     "<span style=\"italic\">\"Save As...\"</span> for writing to the "
2548     "same .gig file will end up in corrupted sample wave data!\n")
2549     );
2550 persson 1799 descriptionArea.pack_start(description);
2551 schoenebeck 3364 #if USE_GTKMM_BOX
2552     dialog.get_content_area()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2553     #else
2554 schoenebeck 1679 dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2555 schoenebeck 3364 #endif
2556     #if HAS_GTKMM_SHOW_ALL_CHILDREN
2557 persson 1799 descriptionArea.show_all();
2558 schoenebeck 3364 #endif
2559 schoenebeck 1679
2560 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
2561 persson 3477 dialog.hide();
2562 schoenebeck 2683 std::string filename = dialog.get_filename();
2563     if (!Glib::str_has_suffix(filename, ".gig")) {
2564     filename += ".gig";
2565 schoenebeck 1225 }
2566 schoenebeck 2683 printf("filename=%s\n", filename.c_str());
2567    
2568     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2569     _("Saving") + Glib::ustring(" '") +
2570     Glib::filename_display_basename(filename) + "' ...",
2571     *this
2572     );
2573 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2574 schoenebeck 2683 progress_dialog->show_all();
2575 schoenebeck 3364 #endif
2576 schoenebeck 2683
2577     saver = new Saver(file, filename); //FIXME: memory leak!
2578     saver->signal_progress().connect(
2579     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2580     saver->signal_finished().connect(
2581     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2582     saver->signal_error().connect(
2583     sigc::mem_fun(*this, &MainWindow::on_saver_error));
2584     saver->launch();
2585    
2586 persson 1261 return true;
2587 schoenebeck 1225 }
2588 persson 1261 return false;
2589 schoenebeck 1225 }
2590    
2591     // actually write the sample(s)' data to the gig file
2592     void MainWindow::__import_queued_samples() {
2593     std::cout << "Starting sample import\n" << std::flush;
2594     Glib::ustring error_files;
2595 persson 2841 printf("Samples to import: %d\n", int(m_SampleImportQueue.size()));
2596 schoenebeck 3116 for (std::map<gig::Sample*, SampleImportItem>::iterator iter = m_SampleImportQueue.begin();
2597 schoenebeck 1225 iter != m_SampleImportQueue.end(); ) {
2598 schoenebeck 3116 printf("Importing sample %s\n",iter->second.sample_path.c_str());
2599 schoenebeck 1225 SF_INFO info;
2600     info.format = 0;
2601 schoenebeck 3116 SNDFILE* hFile = sf_open(iter->second.sample_path.c_str(), SFM_READ, &info);
2602 persson 2398 sf_command(hFile, SFC_SET_SCALE_FLOAT_INT_READ, 0, SF_TRUE);
2603 schoenebeck 1225 try {
2604 persson 1831 if (!hFile) throw std::string(_("could not open file"));
2605 schoenebeck 1225 // determine sample's bit depth
2606     int bitdepth;
2607     switch (info.format & 0xff) {
2608     case SF_FORMAT_PCM_S8:
2609     case SF_FORMAT_PCM_16:
2610 persson 1265 case SF_FORMAT_PCM_U8:
2611 schoenebeck 1225 bitdepth = 16;
2612     break;
2613     case SF_FORMAT_PCM_24:
2614     case SF_FORMAT_PCM_32:
2615     case SF_FORMAT_FLOAT:
2616     case SF_FORMAT_DOUBLE:
2617 persson 1265 bitdepth = 24;
2618 schoenebeck 1225 break;
2619     default:
2620     sf_close(hFile); // close sound file
2621 persson 1831 throw std::string(_("format not supported")); // unsupported subformat (yet?)
2622 schoenebeck 1225 }
2623 persson 1265
2624 schoenebeck 3116 // reset write position for sample
2625     iter->first->SetPos(0);
2626    
2627 persson 1265 const int bufsize = 10000;
2628 schoenebeck 1225 switch (bitdepth) {
2629 persson 1265 case 16: {
2630     short* buffer = new short[bufsize * info.channels];
2631     sf_count_t cnt = info.frames;
2632     while (cnt) {
2633     // libsndfile does the conversion for us (if needed)
2634     int n = sf_readf_short(hFile, buffer, bufsize);
2635     // write from buffer directly (physically) into .gig file
2636 schoenebeck 3116 iter->first->Write(buffer, n);
2637 persson 1265 cnt -= n;
2638     }
2639     delete[] buffer;
2640 schoenebeck 1225 break;
2641 persson 1265 }
2642     case 24: {
2643     int* srcbuf = new int[bufsize * info.channels];
2644     uint8_t* dstbuf = new uint8_t[bufsize * 3 * info.channels];
2645     sf_count_t cnt = info.frames;
2646     while (cnt) {
2647     // libsndfile returns 32 bits, convert to 24
2648     int n = sf_readf_int(hFile, srcbuf, bufsize);
2649     int j = 0;
2650     for (int i = 0 ; i < n * info.channels ; i++) {
2651     dstbuf[j++] = srcbuf[i] >> 8;
2652     dstbuf[j++] = srcbuf[i] >> 16;
2653     dstbuf[j++] = srcbuf[i] >> 24;
2654     }
2655     // write from buffer directly (physically) into .gig file
2656 schoenebeck 3116 iter->first->Write(dstbuf, n);
2657 persson 1265 cnt -= n;
2658     }
2659     delete[] srcbuf;
2660     delete[] dstbuf;
2661 schoenebeck 1225 break;
2662 persson 1265 }
2663 schoenebeck 1225 }
2664     // cleanup
2665     sf_close(hFile);
2666 schoenebeck 1853 // let the sampler re-cache the sample if needed
2667 schoenebeck 3116 sample_changed_signal.emit(iter->first);
2668 schoenebeck 1225 // on success we remove the sample from the import queue,
2669     // otherwise keep it, maybe it works the next time ?
2670 schoenebeck 3116 std::map<gig::Sample*, SampleImportItem>::iterator cur = iter;
2671 schoenebeck 1225 ++iter;
2672     m_SampleImportQueue.erase(cur);
2673     } catch (std::string what) {
2674     // remember the files that made trouble (and their cause)
2675 persson 2442 if (!error_files.empty()) error_files += "\n";
2676 schoenebeck 3116 error_files += iter->second.sample_path += " (" + what + ")";
2677 schoenebeck 1225 ++iter;
2678     }
2679     }
2680     // show error message box when some sample(s) could not be imported
2681 persson 2442 if (!error_files.empty()) {
2682 schoenebeck 1382 Glib::ustring txt = _("Could not import the following sample(s):\n") + error_files;
2683 schoenebeck 1225 Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2684     msg.run();
2685     }
2686     }
2687    
2688     void MainWindow::on_action_file_properties()
2689     {
2690 schoenebeck 3636 fileProps.show();
2691     fileProps.deiconify();
2692 schoenebeck 1225 }
2693    
2694 schoenebeck 2541 void MainWindow::on_action_warn_user_on_extensions() {
2695     Settings::singleton()->warnUserOnExtensions =
2696     !Settings::singleton()->warnUserOnExtensions;
2697     }
2698    
2699 schoenebeck 3409 void MainWindow::on_action_show_tooltips() {
2700     Settings::singleton()->showTooltips =
2701     !Settings::singleton()->showTooltips;
2702    
2703     on_show_tooltips_changed();
2704     }
2705    
2706     void MainWindow::on_show_tooltips_changed() {
2707     const bool b = Settings::singleton()->showTooltips;
2708    
2709     dimreg_label.set_has_tooltip(b);
2710     dimreg_all_regions.set_has_tooltip(b);
2711     dimreg_all_dimregs.set_has_tooltip(b);
2712     dimreg_stereo.set_has_tooltip(b);
2713 schoenebeck 3418
2714     // Not doing this here, we let onQueryTreeViewTooltip() handle this per cell
2715 schoenebeck 3806 //m_TreeViewInstruments.set_has_tooltip(b);
2716 schoenebeck 3418
2717 schoenebeck 3409 m_TreeViewSamples.set_has_tooltip(b);
2718     m_TreeViewScripts.set_has_tooltip(b);
2719    
2720     set_has_tooltip(b);
2721     }
2722    
2723 schoenebeck 2689 void MainWindow::on_action_sync_sampler_instrument_selection() {
2724     Settings::singleton()->syncSamplerInstrumentSelection =
2725     !Settings::singleton()->syncSamplerInstrumentSelection;
2726     }
2727    
2728 schoenebeck 2773 void MainWindow::on_action_move_root_note_with_region_moved() {
2729     Settings::singleton()->moveRootNoteWithRegionMoved =
2730     !Settings::singleton()->moveRootNoteWithRegionMoved;
2731     }
2732    
2733 schoenebeck 1225 void MainWindow::on_action_help_about()
2734     {
2735     Gtk::AboutDialog dialog;
2736 persson 1959 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 12) || GTKMM_MAJOR_VERSION > 2
2737     dialog.set_program_name("Gigedit");
2738     #else
2739     dialog.set_name("Gigedit");
2740     #endif
2741 schoenebeck 1225 dialog.set_version(VERSION);
2742 persson 3456 dialog.set_copyright("Copyright (C) 2006-2019 Andreas Persson");
2743 schoenebeck 2476 const std::string sComment =
2744     _("Built " __DATE__ "\nUsing ") +
2745     ::gig::libraryName() + " " + ::gig::libraryVersion() + "\n\n" +
2746     _(
2747     "Gigedit is released under the GNU General Public License.\n"
2748     "\n"
2749 schoenebeck 2627 "This program is distributed WITHOUT ANY WARRANTY; So better "
2750     "backup your Gigasampler/GigaStudio files before editing them with "
2751 schoenebeck 2476 "this application.\n"
2752     "\n"
2753 schoenebeck 3540 "Please report bugs to: https://bugs.linuxsampler.org"
2754 schoenebeck 2476 );
2755     dialog.set_comments(sComment.c_str());
2756 schoenebeck 3540 dialog.set_website("https://www.linuxsampler.org");
2757     dialog.set_website_label("https://www.linuxsampler.org");
2758 schoenebeck 3225 dialog.set_position(Gtk::WIN_POS_CENTER);
2759 schoenebeck 1225 dialog.run();
2760     }
2761    
2762 schoenebeck 3636 FilePropDialog::FilePropDialog()
2763 schoenebeck 2560 : eFileFormat(_("File Format")),
2764     eName(_("Name")),
2765 persson 1831 eCreationDate(_("Creation date")),
2766     eComments(_("Comments")),
2767     eProduct(_("Product")),
2768     eCopyright(_("Copyright")),
2769     eArtists(_("Artists")),
2770     eGenre(_("Genre")),
2771     eKeywords(_("Keywords")),
2772     eEngineer(_("Engineer")),
2773     eTechnician(_("Technician")),
2774     eSoftware(_("Software")),
2775     eMedium(_("Medium")),
2776     eSource(_("Source")),
2777     eSourceForm(_("Source form")),
2778     eCommissioned(_("Commissioned")),
2779     eSubject(_("Subject")),
2780 schoenebeck 3364 #if HAS_GTKMM_STOCK
2781 schoenebeck 3158 quitButton(Gtk::Stock::CLOSE),
2782 schoenebeck 3364 #else
2783     quitButton(_("_Close")),
2784     #endif
2785 schoenebeck 2560 table(2, 1),
2786     m_file(NULL)
2787 schoenebeck 1225 {
2788 schoenebeck 3225 if (!Settings::singleton()->autoRestoreWindowDimension) {
2789     set_default_size(470, 390);
2790     set_position(Gtk::WIN_POS_MOUSE);
2791     }
2792    
2793 persson 1831 set_title(_("File Properties"));
2794 persson 1582 eName.set_width_chars(50);
2795    
2796 schoenebeck 3636 connect(eFileFormat, &FilePropDialog::set_FileFormat);
2797 persson 1582 connect(eName, &DLS::Info::Name);
2798     connect(eCreationDate, &DLS::Info::CreationDate);
2799     connect(eComments, &DLS::Info::Comments);
2800     connect(eProduct, &DLS::Info::Product);
2801     connect(eCopyright, &DLS::Info::Copyright);
2802     connect(eArtists, &DLS::Info::Artists);
2803     connect(eGenre, &DLS::Info::Genre);
2804     connect(eKeywords, &DLS::Info::Keywords);
2805     connect(eEngineer, &DLS::Info::Engineer);
2806     connect(eTechnician, &DLS::Info::Technician);
2807     connect(eSoftware, &DLS::Info::Software);
2808     connect(eMedium, &DLS::Info::Medium);
2809     connect(eSource, &DLS::Info::Source);
2810     connect(eSourceForm, &DLS::Info::SourceForm);
2811     connect(eCommissioned, &DLS::Info::Commissioned);
2812     connect(eSubject, &DLS::Info::Subject);
2813    
2814 schoenebeck 2560 table.add(eFileFormat);
2815 persson 1582 table.add(eName);
2816     table.add(eCreationDate);
2817     table.add(eComments);
2818     table.add(eProduct);
2819     table.add(eCopyright);
2820     table.add(eArtists);
2821     table.add(eGenre);
2822     table.add(eKeywords);
2823     table.add(eEngineer);
2824     table.add(eTechnician);
2825     table.add(eSoftware);
2826     table.add(eMedium);
2827     table.add(eSource);
2828     table.add(eSourceForm);
2829     table.add(eCommissioned);
2830     table.add(eSubject);
2831    
2832 schoenebeck 3364 #if USE_GTKMM_GRID
2833     table.set_column_spacing(5);
2834     #else
2835 schoenebeck 1225 table.set_col_spacings(5);
2836 schoenebeck 3364 #endif
2837    
2838 persson 1582 add(vbox);
2839 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2840 schoenebeck 3364 table.set_margin(5);
2841     #else
2842 persson 1582 table.set_border_width(5);
2843 schoenebeck 3364 #endif
2844 persson 1582 vbox.add(table);
2845     vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
2846     buttonBox.set_layout(Gtk::BUTTONBOX_END);
2847 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2848 schoenebeck 3364 buttonBox.set_margin(5);
2849     #else
2850 persson 1582 buttonBox.set_border_width(5);
2851 schoenebeck 3364 #endif
2852 persson 1582 buttonBox.show();
2853     buttonBox.pack_start(quitButton);
2854 persson 2151 quitButton.set_can_default();
2855 persson 1582 quitButton.grab_focus();
2856     quitButton.signal_clicked().connect(
2857 schoenebeck 3636 sigc::mem_fun(*this, &FilePropDialog::hide));
2858 schoenebeck 1225
2859 persson 1582 quitButton.show();
2860     vbox.show();
2861 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2862 schoenebeck 1225 show_all_children();
2863 schoenebeck 3364 #endif
2864 schoenebeck 1225 }
2865    
2866 schoenebeck 3636 void FilePropDialog::set_file(gig::File* file)
2867 schoenebeck 2560 {
2868     m_file = file;
2869 persson 3469 update(file->pInfo);
2870 schoenebeck 2560
2871     // update file format version combo box
2872     const std::string sGiga = "Gigasampler/GigaStudio v";
2873     const int major = file->pVersion->major;
2874     std::vector<std::string> txts;
2875     std::vector<int> values;
2876     txts.push_back(sGiga + "2"); values.push_back(2);
2877 schoenebeck 3441 txts.push_back(sGiga + "3"); values.push_back(3);
2878     txts.push_back(sGiga + "4"); values.push_back(4);
2879     if (major < 2 || major > 4) {
2880 schoenebeck 2560 txts.push_back(sGiga + ToString(major)); values.push_back(major);
2881     }
2882     std::vector<const char*> texts;
2883     for (int i = 0; i < txts.size(); ++i) texts.push_back(txts[i].c_str());
2884 persson 2579 texts.push_back(NULL); values.push_back(0);
2885 persson 3469
2886     update_model++;
2887 schoenebeck 2560 eFileFormat.set_choices(&texts[0], &values[0]);
2888     eFileFormat.set_value(major);
2889 persson 3469 update_model--;
2890 schoenebeck 2560 }
2891    
2892 schoenebeck 3636 void FilePropDialog::set_FileFormat(int value)
2893 schoenebeck 1225 {
2894 persson 3469 m_file->pVersion->major = value;
2895 schoenebeck 1225 }
2896    
2897 persson 1582
2898 persson 2445 void InstrumentProps::set_Name(const gig::String& name)
2899     {
2900     m->pInfo->Name = name;
2901     }
2902    
2903     void InstrumentProps::update_name()
2904     {
2905     update_model++;
2906     eName.set_value(m->pInfo->Name);
2907     update_model--;
2908     }
2909    
2910 persson 1460 void InstrumentProps::set_IsDrum(bool value)
2911     {
2912 persson 2423 m->IsDrum = value;
2913 persson 1460 }
2914    
2915     void InstrumentProps::set_MIDIBank(uint16_t value)
2916     {
2917 persson 2423 m->MIDIBank = value;
2918 persson 1460 }
2919    
2920     void InstrumentProps::set_MIDIProgram(uint32_t value)
2921     {
2922 persson 2423 m->MIDIProgram = value;
2923 persson 1460 }
2924    
2925 persson 2423 InstrumentProps::InstrumentProps() :
2926 schoenebeck 3364 #if HAS_GTKMM_STOCK
2927 schoenebeck 3158 quitButton(Gtk::Stock::CLOSE),
2928 schoenebeck 3364 #else
2929     quitButton(_("_Close")),
2930     #endif
2931 persson 2423 table(2,1),
2932     eName(_("Name")),
2933     eIsDrum(_("Is drum")),
2934     eMIDIBank(_("MIDI bank"), 0, 16383),
2935     eMIDIProgram(_("MIDI program")),
2936 schoenebeck 3643 eAttenuation(_("Attenuation (dB)"), -96, +96, 0, 1),
2937 persson 2423 eEffectSend(_("Effect send"), 0, 65535),
2938     eFineTune(_("Fine tune"), -8400, 8400),
2939 schoenebeck 3643 ePitchbendRange(_("Pitchbend range (halftones)"), 0, 48),
2940 persson 2423 ePianoReleaseMode(_("Piano release mode")),
2941     eDimensionKeyRangeLow(_("Keyswitching range low")),
2942 schoenebeck 3635 eDimensionKeyRangeHigh(_("Keyswitching range high")),
2943     table2(2,1),
2944     eName2(_("Name")),
2945     eCreationDate(_("Creation date")),
2946     eComments(_("Comments")),
2947     eProduct(_("Product")),
2948     eCopyright(_("Copyright")),
2949     eArtists(_("Artists")),
2950     eGenre(_("Genre")),
2951     eKeywords(_("Keywords")),
2952     eEngineer(_("Engineer")),
2953     eTechnician(_("Technician")),
2954     eSoftware(_("Software")),
2955     eMedium(_("Medium")),
2956     eSource(_("Source")),
2957     eSourceForm(_("Source form")),
2958     eCommissioned(_("Commissioned")),
2959     eSubject(_("Subject"))
2960 persson 1460 {
2961 schoenebeck 3225 if (!Settings::singleton()->autoRestoreWindowDimension) {
2962     //set_default_size(470, 390);
2963     set_position(Gtk::WIN_POS_MOUSE);
2964     }
2965    
2966 persson 1831 set_title(_("Instrument Properties"));
2967 schoenebeck 1225
2968 schoenebeck 3635 tabs.append_page(vbox[1], _("Settings"));
2969     tabs.append_page(vbox[2], _("Info"));
2970    
2971 schoenebeck 1656 eDimensionKeyRangeLow.set_tip(
2972     _("start of the keyboard area which should switch the "
2973     "\"keyswitching\" dimension")
2974     );
2975     eDimensionKeyRangeHigh.set_tip(
2976     _("end of the keyboard area which should switch the "
2977     "\"keyswitching\" dimension")
2978     );
2979    
2980 persson 2445 connect(eName, &InstrumentProps::set_Name);
2981 persson 1460 connect(eIsDrum, &InstrumentProps::set_IsDrum);
2982     connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
2983     connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
2984     connect(eAttenuation, &gig::Instrument::Attenuation);
2985     connect(eEffectSend, &gig::Instrument::EffectSend);
2986     connect(eFineTune, &gig::Instrument::FineTune);
2987     connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
2988     connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
2989 persson 2423 connect(eDimensionKeyRangeLow, eDimensionKeyRangeHigh,
2990     &gig::Instrument::DimensionKeyRange);
2991 persson 1460
2992 persson 2445 eName.signal_value_changed().connect(sig_name_changed.make_slot());
2993    
2994 schoenebeck 3635 connect(eName2, &InstrumentProps::set_Name);
2995     connectLambda(eCreationDate, [this](gig::String s) {
2996     m->pInfo->CreationDate = s;
2997     });
2998     connectLambda(eComments, [this](gig::String s) {
2999     m->pInfo->Comments = s;
3000     });
3001     connectLambda(eProduct, [this](gig::String s) {
3002     m->pInfo->Product = s;
3003     });
3004     connectLambda(eCopyright, [this](gig::String s) {
3005     m->pInfo->Copyright = s;
3006     });
3007     connectLambda(eArtists, [this](gig::String s) {
3008     m->pInfo->Artists = s;
3009     });
3010     connectLambda(eGenre, [this](gig::String s) {
3011     m->pInfo->Genre = s;
3012     });
3013     connectLambda(eKeywords, [this](gig::String s) {
3014     m->pInfo->Keywords = s;
3015     });
3016     connectLambda(eEngineer, [this](gig::String s) {
3017     m->pInfo->Engineer = s;
3018     });
3019     connectLambda(eTechnician, [this](gig::String s) {
3020     m->pInfo->Technician = s;
3021     });
3022     connectLambda(eSoftware, [this](gig::String s) {
3023     m->pInfo->Software = s;
3024     });
3025     connectLambda(eMedium, [this](gig::String s) {
3026     m->pInfo->Medium = s;
3027     });
3028     connectLambda(eSource, [this](gig::String s) {
3029     m->pInfo->Source = s;
3030     });
3031     connectLambda(eSourceForm, [this](gig::String s) {
3032     m->pInfo->SourceForm = s;
3033     });
3034     connectLambda(eCommissioned, [this](gig::String s) {
3035     m->pInfo->Commissioned = s;
3036     });
3037     connectLambda(eSubject, [this](gig::String s) {
3038     m->pInfo->Subject = s;
3039     });
3040    
3041     // tab 1
3042 schoenebeck 3364 #if USE_GTKMM_GRID
3043     table.set_column_spacing(5);
3044     #else
3045 schoenebeck 1225 table.set_col_spacings(5);
3046 schoenebeck 3364 #endif
3047 persson 1582 table.add(eName);
3048     table.add(eIsDrum);
3049     table.add(eMIDIBank);
3050     table.add(eMIDIProgram);
3051     table.add(eAttenuation);
3052     table.add(eEffectSend);
3053     table.add(eFineTune);
3054     table.add(ePitchbendRange);
3055     table.add(ePianoReleaseMode);
3056     table.add(eDimensionKeyRangeLow);
3057     table.add(eDimensionKeyRangeHigh);
3058 schoenebeck 1225
3059 schoenebeck 3635 // tab 2
3060     #if USE_GTKMM_GRID
3061     table2.set_column_spacing(5);
3062     #else
3063     table2.set_col_spacings(5);
3064     #endif
3065     table2.add(eName2);
3066     table2.add(eCreationDate);
3067     table2.add(eComments);
3068     table2.add(eProduct);
3069     table2.add(eCopyright);
3070     table2.add(eArtists);
3071     table2.add(eGenre);
3072     table2.add(eKeywords);
3073     table2.add(eEngineer);
3074     table2.add(eTechnician);
3075     table2.add(eSoftware);
3076     table2.add(eMedium);
3077     table2.add(eSource);
3078     table2.add(eSourceForm);
3079     table2.add(eCommissioned);
3080     table2.add(eSubject);
3081    
3082     add(vbox[0]);
3083 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3084 schoenebeck 3364 table.set_margin(5);
3085     #else
3086 schoenebeck 1225 table.set_border_width(5);
3087 schoenebeck 3364 #endif
3088 schoenebeck 3635 vbox[1].pack_start(table);
3089     vbox[2].pack_start(table2);
3090 schoenebeck 1225 table.show();
3091 schoenebeck 3635 table2.show();
3092     vbox[0].pack_start(tabs);
3093     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3094 schoenebeck 1225 buttonBox.set_layout(Gtk::BUTTONBOX_END);
3095 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3096 schoenebeck 3364 buttonBox.set_margin(5);
3097     #else
3098 schoenebeck 1225 buttonBox.set_border_width(5);
3099 schoenebeck 3364 #endif
3100 schoenebeck 1225 buttonBox.show();
3101     buttonBox.pack_start(quitButton);
3102 persson 2151 quitButton.set_can_default();
3103 schoenebeck 1225 quitButton.grab_focus();
3104    
3105     quitButton.signal_clicked().connect(
3106     sigc::mem_fun(*this, &InstrumentProps::hide));
3107    
3108     quitButton.show();
3109 schoenebeck 3635 vbox[0].show();
3110 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
3111 schoenebeck 1225 show_all_children();
3112 schoenebeck 3364 #endif
3113 schoenebeck 1225 }
3114    
3115     void InstrumentProps::set_instrument(gig::Instrument* instrument)
3116     {
3117 persson 2423 update(instrument);
3118 persson 1460
3119     update_model++;
3120 schoenebeck 3635
3121     // tab 1
3122 persson 2445 eName.set_value(instrument->pInfo->Name);
3123 persson 1460 eIsDrum.set_value(instrument->IsDrum);
3124     eMIDIBank.set_value(instrument->MIDIBank);
3125     eMIDIProgram.set_value(instrument->MIDIProgram);
3126 schoenebeck 3635 // tab 2
3127     eName2.set_value(instrument->pInfo->Name);
3128     eCreationDate.set_value(instrument->pInfo->CreationDate);
3129     eComments.set_value(instrument->pInfo->Comments);
3130     eProduct.set_value(instrument->pInfo->Product);
3131     eCopyright.set_value(instrument->pInfo->Copyright);
3132     eArtists.set_value(instrument->pInfo->Artists);
3133     eGenre.set_value(instrument->pInfo->Genre);
3134     eKeywords.set_value(instrument->pInfo->Keywords);
3135     eEngineer.set_value(instrument->pInfo->Engineer);
3136     eTechnician.set_value(instrument->pInfo->Technician);
3137     eSoftware.set_value(instrument->pInfo->Software);
3138     eMedium.set_value(instrument->pInfo->Medium);
3139     eSource.set_value(instrument->pInfo->Source);
3140     eSourceForm.set_value(instrument->pInfo->SourceForm);
3141     eCommissioned.set_value(instrument->pInfo->Commissioned);
3142     eSubject.set_value(instrument->pInfo->Subject);
3143    
3144 persson 1460 update_model--;
3145 schoenebeck 1225 }
3146    
3147    
3148 schoenebeck 3637 SampleProps::SampleProps() :
3149     #if HAS_GTKMM_STOCK
3150     quitButton(Gtk::Stock::CLOSE),
3151     #else
3152     quitButton(_("_Close")),
3153     #endif
3154     table(2,1),
3155     eName(_("Name")),
3156     eUnityNote(_("Unity Note")),
3157     eSampleGroup(_("Sample Group")),
3158     eSampleFormatInfo(_("Sample Format")),
3159     eSampleID("Sample ID"),
3160     eChecksum("Wave Data CRC-32"),
3161     eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
3162     eLoopStart(_("Loop start position"), 0, 9999999),
3163     eLoopLength(_("Loop size"), 0, 9999999),
3164     eLoopType(_("Loop type")),
3165     eLoopPlayCount(_("Playback count")),
3166     table2(2,1),
3167     eName2(_("Name")),
3168     eCreationDate(_("Creation date")),
3169     eComments(_("Comments")),
3170     eProduct(_("Product")),
3171     eCopyright(_("Copyright")),
3172     eArtists(_("Artists")),
3173     eGenre(_("Genre")),
3174     eKeywords(_("Keywords")),
3175     eEngineer(_("Engineer")),
3176     eTechnician(_("Technician")),
3177     eSoftware(_("Software")),
3178     eMedium(_("Medium")),
3179     eSource(_("Source")),
3180     eSourceForm(_("Source form")),
3181     eCommissioned(_("Commissioned")),
3182     eSubject(_("Subject"))
3183     {
3184     if (!Settings::singleton()->autoRestoreWindowDimension) {
3185     //set_default_size(470, 390);
3186     set_position(Gtk::WIN_POS_MOUSE);
3187     }
3188    
3189     set_title(_("Sample Properties"));
3190    
3191     tabs.append_page(vbox[1], _("Settings"));
3192     tabs.append_page(vbox[2], _("Info"));
3193    
3194     connect(eName, &SampleProps::set_Name);
3195     connect(eUnityNote, &gig::Sample::MIDIUnityNote);
3196     connect(eLoopsCount, &gig::Sample::Loops);
3197     connectLambda(eLoopStart, [this](uint32_t start){
3198     m->LoopStart = start;
3199     m->LoopEnd = start + m->LoopSize;
3200     });
3201     connectLambda(eLoopLength, [this](uint32_t length){
3202     m->LoopSize = length;
3203     m->LoopEnd = m->LoopStart + length;
3204     });
3205     {
3206     const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
3207     static const gig::loop_type_t values[] = {
3208     gig::loop_type_normal,
3209     gig::loop_type_bidirectional,
3210     gig::loop_type_backward
3211     };
3212     eLoopType.set_choices(choices, values);
3213     }
3214     connect(eLoopType, &gig::Sample::LoopType);
3215     connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
3216    
3217     eName.signal_value_changed().connect(sig_name_changed.make_slot());
3218    
3219     connect(eName2, &SampleProps::set_Name);
3220     connectLambda(eCreationDate, [this](gig::String s) {
3221     m->pInfo->CreationDate = s;
3222     });
3223     connectLambda(eComments, [this](gig::String s) {
3224     m->pInfo->Comments = s;
3225     });
3226     connectLambda(eProduct, [this](gig::String s) {
3227     m->pInfo->Product = s;
3228     });
3229     connectLambda(eCopyright, [this](gig::String s) {
3230     m->pInfo->Copyright = s;
3231     });
3232     connectLambda(eArtists, [this](gig::String s) {
3233     m->pInfo->Artists = s;
3234     });
3235     connectLambda(eGenre, [this](gig::String s) {
3236     m->pInfo->Genre = s;
3237     });
3238     connectLambda(eKeywords, [this](gig::String s) {
3239     m->pInfo->Keywords = s;
3240     });
3241     connectLambda(eEngineer, [this](gig::String s) {
3242     m->pInfo->Engineer = s;
3243     });
3244     connectLambda(eTechnician, [this](gig::String s) {
3245     m->pInfo->Technician = s;
3246     });
3247     connectLambda(eSoftware, [this](gig::String s) {
3248     m->pInfo->Software = s;
3249     });
3250     connectLambda(eMedium, [this](gig::String s) {
3251     m->pInfo->Medium = s;
3252     });
3253     connectLambda(eSource, [this](gig::String s) {
3254     m->pInfo->Source = s;
3255     });
3256     connectLambda(eSourceForm, [this](gig::String s) {
3257     m->pInfo->SourceForm = s;
3258     });
3259     connectLambda(eCommissioned, [this](gig::String s) {
3260     m->pInfo->Commissioned = s;
3261     });
3262     connectLambda(eSubject, [this](gig::String s) {
3263     m->pInfo->Subject = s;
3264     });
3265    
3266     // tab 1
3267     #if USE_GTKMM_GRID
3268     table.set_column_spacing(5);
3269     #else
3270     table.set_col_spacings(5);
3271     #endif
3272     table.add(eName);
3273     table.add(eUnityNote);
3274     table.add(eSampleGroup);
3275     table.add(eSampleFormatInfo);
3276     table.add(eSampleID);
3277     table.add(eChecksum);
3278     table.add(eLoopsCount);
3279     table.add(eLoopStart);
3280     table.add(eLoopLength);
3281     table.add(eLoopType);
3282     table.add(eLoopPlayCount);
3283    
3284     // tab 2
3285     #if USE_GTKMM_GRID
3286     table2.set_column_spacing(5);
3287     #else
3288     table2.set_col_spacings(5);
3289     #endif
3290     table2.add(eName2);
3291     table2.add(eCreationDate);
3292     table2.add(eComments);
3293     table2.add(eProduct);
3294     table2.add(eCopyright);
3295     table2.add(eArtists);
3296     table2.add(eGenre);
3297     table2.add(eKeywords);
3298     table2.add(eEngineer);
3299     table2.add(eTechnician);
3300     table2.add(eSoftware);
3301     table2.add(eMedium);
3302     table2.add(eSource);
3303     table2.add(eSourceForm);
3304     table2.add(eCommissioned);
3305     table2.add(eSubject);
3306    
3307     add(vbox[0]);
3308     #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3309     table.set_margin(5);
3310     #else
3311     table.set_border_width(5);
3312     #endif
3313     vbox[1].pack_start(table);
3314     vbox[2].pack_start(table2);
3315     table.show();
3316     table2.show();
3317     vbox[0].pack_start(tabs);
3318     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3319     buttonBox.set_layout(Gtk::BUTTONBOX_END);
3320     #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3321     buttonBox.set_margin(5);
3322     #else
3323     buttonBox.set_border_width(5);
3324     #endif
3325     buttonBox.show();
3326     buttonBox.pack_start(quitButton);
3327     quitButton.set_can_default();
3328     quitButton.grab_focus();
3329    
3330     quitButton.signal_clicked().connect(
3331     sigc::mem_fun(*this, &SampleProps::hide));
3332    
3333     quitButton.show();
3334     vbox[0].show();
3335     #if HAS_GTKMM_SHOW_ALL_CHILDREN
3336     show_all_children();
3337     #endif
3338     }
3339    
3340     void SampleProps::set_sample(gig::Sample* sample)
3341     {
3342     update(sample);
3343    
3344     update_model++;
3345    
3346     // tab 1
3347     eName.set_value(sample->pInfo->Name);
3348     eUnityNote.set_value(sample->MIDIUnityNote);
3349     // show sample group name
3350     {
3351     Glib::ustring s = "---";
3352     if (sample && sample->GetGroup())
3353     s = sample->GetGroup()->Name;
3354     eSampleGroup.text.set_text(s);
3355     }
3356     // assemble sample format info string
3357     {
3358     Glib::ustring s;
3359     if (sample) {
3360     switch (sample->Channels) {
3361     case 1: s = _("Mono"); break;
3362     case 2: s = _("Stereo"); break;
3363     default:
3364     s = ToString(sample->Channels) + _(" audio channels");
3365     break;
3366     }
3367     s += " " + ToString(sample->BitDepth) + " Bits";
3368     s += " " + ToString(sample->SamplesPerSecond/1000) + "."
3369     + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
3370     } else {
3371     s = _("No sample assigned to this dimension region.");
3372     }
3373     eSampleFormatInfo.text.set_text(s);
3374     }
3375     // generate sample's memory address pointer string
3376     {
3377     Glib::ustring s;
3378     if (sample) {
3379     char buf[64] = {};
3380     snprintf(buf, sizeof(buf), "%p", sample);
3381     s = buf;
3382     } else {
3383     s = "---";
3384     }
3385     eSampleID.text.set_text(s);
3386     }
3387     // generate raw wave form data CRC-32 checksum string
3388     {
3389     Glib::ustring s = "---";
3390     if (sample) {
3391     char buf[64] = {};
3392     snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
3393     s = buf;
3394     }
3395     eChecksum.text.set_text(s);
3396     }
3397     eLoopsCount.set_value(sample->Loops);
3398     eLoopStart.set_value(sample->LoopStart);
3399     eLoopLength.set_value(sample->LoopSize);
3400     eLoopType.set_value(sample->LoopType);
3401     eLoopPlayCount.set_value(sample->LoopPlayCount);
3402     // tab 2
3403     eName2.set_value(sample->pInfo->Name);
3404     eCreationDate.set_value(sample->pInfo->CreationDate);
3405     eComments.set_value(sample->pInfo->Comments);
3406     eProduct.set_value(sample->pInfo->Product);
3407     eCopyright.set_value(sample->pInfo->Copyright);
3408     eArtists.set_value(sample->pInfo->Artists);
3409     eGenre.set_value(sample->pInfo->Genre);
3410     eKeywords.set_value(sample->pInfo->Keywords);
3411     eEngineer.set_value(sample->pInfo->Engineer);
3412     eTechnician.set_value(sample->pInfo->Technician);
3413     eSoftware.set_value(sample->pInfo->Software);
3414     eMedium.set_value(sample->pInfo->Medium);
3415     eSource.set_value(sample->pInfo->Source);
3416     eSourceForm.set_value(sample->pInfo->SourceForm);
3417     eCommissioned.set_value(sample->pInfo->Commissioned);
3418     eSubject.set_value(sample->pInfo->Subject);
3419    
3420     update_model--;
3421     }
3422    
3423     void SampleProps::set_Name(const gig::String& name)
3424     {
3425     m->pInfo->Name = name;
3426     }
3427    
3428     void SampleProps::update_name()
3429     {
3430     update_model++;
3431     eName.set_value(m->pInfo->Name);
3432     update_model--;
3433     }
3434    
3435    
3436 persson 1261 void MainWindow::file_changed()
3437     {
3438     if (file && !file_is_changed) {
3439     set_title("*" + get_title());
3440     file_is_changed = true;
3441 schoenebeck 1225 }
3442 persson 1261 }
3443 schoenebeck 1225
3444 schoenebeck 2621 void MainWindow::updateSampleRefCountMap(gig::File* gig) {
3445     sample_ref_count.clear();
3446    
3447     if (!gig) return;
3448    
3449     for (gig::Instrument* instrument = gig->GetFirstInstrument(); instrument;
3450     instrument = gig->GetNextInstrument())
3451     {
3452     for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
3453     rgn = instrument->GetNextRegion())
3454     {
3455     for (int i = 0; i < 256; ++i) {
3456     if (!rgn->pDimensionRegions[i]) continue;
3457     if (rgn->pDimensionRegions[i]->pSample) {
3458     sample_ref_count[rgn->pDimensionRegions[i]->pSample]++;
3459     }
3460     }
3461     }
3462     }
3463     }
3464    
3465 schoenebeck 3418 bool MainWindow::onQueryTreeViewTooltip(int x, int y, bool keyboardTip, const Glib::RefPtr<Gtk::Tooltip>& tooltip) {
3466     Gtk::TreeModel::iterator iter;
3467 schoenebeck 3806 if (!m_TreeViewInstruments.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
3468 persson 3460 return false;
3469     }
3470 schoenebeck 3418 Gtk::TreeModel::Path path(iter);
3471     Gtk::TreeModel::Row row = *iter;
3472     Gtk::TreeViewColumn* pointedColumn = NULL;
3473     // resolve the precise table column the mouse points to
3474     {
3475     Gtk::TreeModel::Path path; // unused
3476     int cellX, cellY; // unused
3477 schoenebeck 3806 m_TreeViewInstruments.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
3478 schoenebeck 3418 }
3479 schoenebeck 3806 Gtk::TreeViewColumn* scriptsColumn = m_TreeViewInstruments.get_column(2);
3480 schoenebeck 3418 if (pointedColumn == scriptsColumn) { // mouse hovers scripts column ...
3481     // show the script(s) assigned to the hovered instrument as tooltip
3482 schoenebeck 3806 tooltip->set_markup( row[m_InstrumentsModel.m_col_tooltip] );
3483     m_TreeViewInstruments.set_tooltip_cell(tooltip, &path, scriptsColumn, NULL);
3484 schoenebeck 3418 } else {
3485     // if beginners' tooltips is disabled then don't show the following one
3486     if (!Settings::singleton()->showTooltips)
3487     return false;
3488     // yeah, a beginners tooltip
3489     tooltip->set_text(_(
3490     "Right click here for actions on instruments & MIDI Rules. "
3491     "Drag & drop to change the order of instruments."
3492     ));
3493 schoenebeck 3806 m_TreeViewInstruments.set_tooltip_cell(tooltip, &path, pointedColumn, NULL);
3494 schoenebeck 3418 }
3495     return true;
3496     }
3497    
3498     static Glib::ustring scriptTooltipFor(gig::Instrument* instrument, int index) {
3499     Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3500     const int iScriptSlots = instrument->ScriptSlotCount();
3501 persson 3460 Glib::ustring tooltip = "<u>(" + ToString(index) + ") ���" + name + "���</u>\n\n";
3502 schoenebeck 3418 if (!iScriptSlots)
3503     tooltip += "<span foreground='red'><i>No script assigned</i></span>";
3504     else {
3505     for (int i = 0; i < iScriptSlots; ++i) {
3506 persson 3460 tooltip += "��� " + ToString(i+1) + ". Script: ���<span foreground='#46DEFF'><b>" +
3507 schoenebeck 3418 instrument->GetScriptOfSlot(i)->Name + "</b></span>���";
3508     if (i + 1 < iScriptSlots) tooltip += "\n\n";
3509     }
3510     }
3511     return tooltip;
3512     }
3513    
3514 schoenebeck 1382 void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
3515 persson 1261 {
3516     file = 0;
3517 schoenebeck 1411 set_file_is_shared(isSharedInstrument);
3518 persson 1261
3519 schoenebeck 2772 this->filename =
3520     (filename && strlen(filename) > 0) ?
3521     filename : (!gig->GetFileName().empty()) ?
3522     gig->GetFileName() : _("Unsaved Gig File");
3523 persson 1261 set_title(Glib::filename_display_basename(this->filename));
3524     file_has_name = filename;
3525     file_is_changed = false;
3526    
3527 schoenebeck 3636 fileProps.set_file(gig);
3528 schoenebeck 1225
3529 persson 2442 instrument_name_connection.block();
3530 schoenebeck 2994 int index = 0;
3531 schoenebeck 1225 for (gig::Instrument* instrument = gig->GetFirstInstrument() ; instrument ;
3532 schoenebeck 2994 instrument = gig->GetNextInstrument(), ++index) {
3533 persson 2446 Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3534 schoenebeck 3197 const int iScriptSlots = instrument->ScriptSlotCount();
3535 persson 2442
3536 schoenebeck 3806 Gtk::TreeModel::iterator iter = m_refInstrumentsTreeModel->append();
3537 schoenebeck 1225 Gtk::TreeModel::Row row = *iter;
3538 schoenebeck 3806 row[m_InstrumentsModel.m_col_nr] = index;
3539     row[m_InstrumentsModel.m_col_name] = name;
3540     row[m_InstrumentsModel.m_col_instr] = instrument;
3541     row[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3542     row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
3543 persson 2442
3544 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3545 persson 2442 add_instrument_to_menu(name);
3546 schoenebeck 3364 #endif
3547 schoenebeck 1225 }
3548 persson 2442 instrument_name_connection.unblock();
3549 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3550 schoenebeck 2625 uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments")->show();
3551 schoenebeck 3364 #endif
3552 schoenebeck 1225
3553 schoenebeck 2621 updateSampleRefCountMap(gig);
3554    
3555 schoenebeck 1225 for (gig::Group* group = gig->GetFirstGroup(); group; group = gig->GetNextGroup()) {
3556     if (group->Name != "") {
3557     Gtk::TreeModel::iterator iterGroup = m_refSamplesTreeModel->append();
3558     Gtk::TreeModel::Row rowGroup = *iterGroup;
3559 persson 2446 rowGroup[m_SamplesModel.m_col_name] = gig_to_utf8(group->Name);
3560 schoenebeck 1225 rowGroup[m_SamplesModel.m_col_group] = group;
3561     rowGroup[m_SamplesModel.m_col_sample] = NULL;
3562     for (gig::Sample* sample = group->GetFirstSample();
3563     sample; sample = group->GetNextSample()) {
3564     Gtk::TreeModel::iterator iterSample =
3565     m_refSamplesTreeModel->append(rowGroup.children());
3566     Gtk::TreeModel::Row rowSample = *iterSample;
3567 persson 2446 rowSample[m_SamplesModel.m_col_name] =
3568     gig_to_utf8(sample->pInfo->Name);
3569 schoenebeck 1225 rowSample[m_SamplesModel.m_col_sample] = sample;
3570     rowSample[m_SamplesModel.m_col_group] = NULL;
3571 schoenebeck 2621 int refcount = sample_ref_count.count(sample) ? sample_ref_count[sample] : 0;
3572     rowSample[m_SamplesModel.m_col_refcount] = ToString(refcount) + " " + _("Refs.");
3573 schoenebeck 2625 rowSample[m_SamplesModel.m_color] = refcount ? "black" : "red";
3574 schoenebeck 1225 }
3575     }
3576     }
3577 schoenebeck 2604
3578     for (int i = 0; gig->GetScriptGroup(i); ++i) {
3579     gig::ScriptGroup* group = gig->GetScriptGroup(i);
3580 schoenebeck 1225
3581 schoenebeck 2604 Gtk::TreeModel::iterator iterGroup = m_refScriptsTreeModel->append();
3582     Gtk::TreeModel::Row rowGroup = *iterGroup;
3583     rowGroup[m_ScriptsModel.m_col_name] = gig_to_utf8(group->Name);
3584     rowGroup[m_ScriptsModel.m_col_group] = group;
3585     rowGroup[m_ScriptsModel.m_col_script] = NULL;
3586     for (int s = 0; group->GetScript(s); ++s) {
3587     gig::Script* script = group->GetScript(s);
3588    
3589     Gtk::TreeModel::iterator iterScript =
3590     m_refScriptsTreeModel->append(rowGroup.children());
3591     Gtk::TreeModel::Row rowScript = *iterScript;
3592     rowScript[m_ScriptsModel.m_col_name] = gig_to_utf8(script->Name);
3593     rowScript[m_ScriptsModel.m_col_script] = script;
3594     rowScript[m_ScriptsModel.m_col_group] = NULL;
3595     }
3596     }
3597 schoenebeck 2624 // unfold all sample groups & script groups by default
3598     m_TreeViewSamples.expand_all();
3599 schoenebeck 2604 m_TreeViewScripts.expand_all();
3600    
3601 persson 1261 file = gig;
3602    
3603 schoenebeck 1225 // select the first instrument
3604 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(Gtk::TreePath("0"));
3605 persson 2423
3606 persson 2445 instr_props_set_instrument();
3607 persson 2507 gig::Instrument* instrument = get_instrument();
3608     if (instrument) {
3609     midiRules.set_instrument(instrument);
3610     }
3611 persson 2445 }
3612    
3613     bool MainWindow::instr_props_set_instrument()
3614     {
3615     instrumentProps.signal_name_changed().clear();
3616    
3617 schoenebeck 3810 // get visual selection
3618 schoenebeck 3806 std::vector<Gtk::TreeModel::Path> rows = m_TreeViewInstruments.get_selection()->get_selected_rows();
3619 schoenebeck 2994 if (rows.empty()) {
3620     instrumentProps.hide();
3621     return false;
3622     }
3623 schoenebeck 3810
3624     // convert index of visual selection (i.e. if filtered) to index of model
3625     Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[0]);
3626    
3627 schoenebeck 3364 //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3628 schoenebeck 3810 Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
3629 persson 2445 if (it) {
3630     Gtk::TreeModel::Row row = *it;
3631 schoenebeck 3806 gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
3632 persson 2445
3633 persson 2423 instrumentProps.set_instrument(instrument);
3634 persson 2445
3635     // make sure instrument tree is updated when user changes the
3636     // instrument name in instrument properties window
3637     instrumentProps.signal_name_changed().connect(
3638     sigc::bind(
3639     sigc::mem_fun(*this,
3640     &MainWindow::instr_name_changed_by_instr_props),
3641     it));
3642     } else {
3643     instrumentProps.hide();
3644 persson 2423 }
3645 schoenebeck 3364 //NOTE: explicit boolean cast required for GTKMM4 development branch here
3646     return it ? true : false;
3647 schoenebeck 1225 }
3648    
3649     void MainWindow::show_instr_props()
3650     {
3651 persson 2445 if (instr_props_set_instrument()) {
3652 persson 1533 instrumentProps.show();
3653     instrumentProps.deiconify();
3654 schoenebeck 1225 }
3655     }
3656    
3657 persson 2445 void MainWindow::instr_name_changed_by_instr_props(Gtk::TreeModel::iterator& it)
3658     {
3659     Gtk::TreeModel::Row row = *it;
3660 schoenebeck 3806 Glib::ustring name = row[m_InstrumentsModel.m_col_name];
3661 persson 2445
3662 schoenebeck 3806 gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
3663 persson 2446 Glib::ustring gigname(gig_to_utf8(instrument->pInfo->Name));
3664     if (gigname != name) {
3665 schoenebeck 3418 Gtk::TreeModel::Path path(*it);
3666     const int index = path[0];
3667 schoenebeck 3806 row[m_InstrumentsModel.m_col_name] = gigname;
3668     row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
3669 persson 2445 }
3670     }
3671    
3672 schoenebeck 3637 bool MainWindow::sample_props_set_sample()
3673     {
3674     sampleProps.signal_name_changed().clear();
3675    
3676     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
3677     if (rows.empty()) {
3678     sampleProps.hide();
3679     return false;
3680     }
3681     //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3682     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
3683     if (it) {
3684     Gtk::TreeModel::Row row = *it;
3685     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3686    
3687     sampleProps.set_sample(sample);
3688    
3689     // make sure sample tree is updated when user changes the
3690     // sample name in sample properties window
3691     sampleProps.signal_name_changed().connect(
3692     sigc::bind(
3693     sigc::mem_fun(*this,
3694     &MainWindow::sample_name_changed_by_sample_props
3695     ), it
3696     )
3697     );
3698     } else {
3699     sampleProps.hide();
3700     }
3701     //NOTE: explicit boolean cast required for GTKMM4 development branch here
3702     return it ? true : false;
3703     }
3704    
3705     void MainWindow::show_sample_props()
3706     {
3707     if (sample_props_set_sample()) {
3708     sampleProps.show();
3709     sampleProps.deiconify();
3710     }
3711     }
3712    
3713     void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
3714     {
3715     Gtk::TreeModel::Row row = *it;
3716     Glib::ustring name = row[m_SamplesModel.m_col_name];
3717    
3718     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3719     Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
3720     if (gigname != name) {
3721     Gtk::TreeModel::Path path(*it);
3722     row[m_SamplesModel.m_col_name] = gigname;
3723     }
3724     }
3725    
3726 persson 2507 void MainWindow::show_midi_rules()
3727     {
3728     if (gig::Instrument* instrument = get_instrument())
3729     {
3730     midiRules.set_instrument(instrument);
3731     midiRules.show();
3732     midiRules.deiconify();
3733     }
3734     }
3735    
3736 schoenebeck 2610 void MainWindow::show_script_slots() {
3737     if (!file) return;
3738 schoenebeck 3808
3739 schoenebeck 2610 // get selected instrument
3740 schoenebeck 3808 gig::Instrument* instrument = get_instrument();
3741 schoenebeck 2610 if (!instrument) return;
3742    
3743     ScriptSlots* window = new ScriptSlots;
3744     window->setInstrument(instrument);
3745 schoenebeck 3197 window->signal_script_slots_changed().connect(
3746     sigc::mem_fun(*this, &MainWindow::onScriptSlotsModified)
3747     );
3748 schoenebeck 2610 //window->reparent(*this);
3749     window->show();
3750     }
3751    
3752 schoenebeck 3197 void MainWindow::onScriptSlotsModified(gig::Instrument* pInstrument) {
3753     if (!pInstrument) return;
3754     const int iScriptSlots = pInstrument->ScriptSlotCount();
3755    
3756 schoenebeck 3806 //NOTE: This is a big mess! Sometimes GTK requires m_TreeViewInstruments.get_model(), here we need m_refInstrumentsModelFilter->get_model(), otherwise accessing children below causes an error!
3757     //Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
3758     Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
3759 schoenebeck 3340
3760 schoenebeck 3197 for (int i = 0; i < model->children().size(); ++i) {
3761     Gtk::TreeModel::Row row = model->children()[i];
3762 schoenebeck 3806 if (row[m_InstrumentsModel.m_col_instr] != pInstrument) continue;
3763     row[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3764     row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(pInstrument, i);
3765 schoenebeck 3197 break;
3766     }
3767 schoenebeck 3339
3768     // causes the sampler to reload the instrument with the new script
3769     on_sel_change();
3770 schoenebeck 3750
3771     // force script 'patch' variables editor ("Script" tab) to be refreshed
3772     dimreg_edit.scriptVars.setInstrument(pInstrument, true/*force update*/);
3773 schoenebeck 3197 }
3774    
3775 schoenebeck 3339 void MainWindow::assignScript(gig::Script* pScript) {
3776     if (!pScript) {
3777     printf("assignScript() : !script\n");
3778     return;
3779     }
3780     printf("assignScript('%s')\n", pScript->Name.c_str());
3781    
3782     gig::Instrument* pInstrument = get_instrument();
3783     if (!pInstrument) {
3784     printf("!instrument\n");
3785     return;
3786     }
3787    
3788     pInstrument->AddScriptSlot(pScript);
3789    
3790     onScriptSlotsModified(pInstrument);
3791     }
3792    
3793 schoenebeck 3419 void MainWindow::dropAllScriptSlots() {
3794     gig::Instrument* pInstrument = get_instrument();
3795     if (!pInstrument) {
3796     printf("!instrument\n");
3797     return;
3798     }
3799    
3800     const int iScriptSlots = pInstrument->ScriptSlotCount();
3801     for (int i = iScriptSlots - 1; i >= 0; --i)
3802     pInstrument->RemoveScriptSlot(i);
3803    
3804     onScriptSlotsModified(pInstrument);
3805     }
3806    
3807 schoenebeck 2772 void MainWindow::on_action_refresh_all() {
3808     __refreshEntireGUI();
3809     }
3810    
3811 schoenebeck 1415 void MainWindow::on_action_view_status_bar() {
3812 schoenebeck 3364 #if USE_GLIB_ACTION
3813     bool active = false;
3814     m_actionToggleStatusBar->get_state(active);
3815     // for some reason toggle state does not change automatically
3816     active = !active;
3817     m_actionToggleStatusBar->change_state(active);
3818     if (active)
3819     m_StatusBar.show();
3820     else
3821     m_StatusBar.hide();
3822     #else
3823 schoenebeck 1415 Gtk::CheckMenuItem* item =
3824     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
3825     if (!item) {
3826     std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
3827     return;
3828     }
3829     if (item->get_active()) m_StatusBar.show();
3830     else m_StatusBar.hide();
3831 schoenebeck 3364 #endif
3832 schoenebeck 1415 }
3833    
3834 schoenebeck 2918 void MainWindow::on_auto_restore_win_dim() {
3835 schoenebeck 3364 #if USE_GLIB_ACTION
3836     bool active = false;
3837     m_actionToggleRestoreWinDim->get_state(active);
3838     // for some reason toggle state does not change automatically
3839     active = !active;
3840     m_actionToggleRestoreWinDim->change_state(active);
3841     Settings::singleton()->autoRestoreWindowDimension = active;
3842     #else
3843 schoenebeck 2918 Gtk::CheckMenuItem* item =
3844     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/AutoRestoreWinDim"));
3845     if (!item) {
3846     std::cerr << "/MenuBar/MenuView/AutoRestoreWinDim == NULL\n";
3847     return;
3848     }
3849     Settings::singleton()->autoRestoreWindowDimension = item->get_active();
3850 schoenebeck 3364 #endif
3851 schoenebeck 2918 }
3852    
3853 schoenebeck 3711 void MainWindow::on_instr_double_click_opens_props() {
3854     #if USE_GLIB_ACTION
3855     bool active = false;
3856     m_actionInstrDoubleClickOpensProps->get_state(active);
3857     // for some reason toggle state does not change automatically
3858     active = !active;
3859     m_actionInstrDoubleClickOpensProps->change_state(active);
3860     Settings::singleton()->instrumentDoubleClickOpensProps = active;
3861     #else
3862     Gtk::CheckMenuItem* item =
3863     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
3864     if (!item) {
3865     std::cerr << "/MenuBar/MenuView/OpenInstrPropsByDoubleClick == NULL\n";
3866     return;
3867     }
3868     Settings::singleton()->instrumentDoubleClickOpensProps = item->get_active();
3869     #endif
3870     }
3871    
3872 schoenebeck 2967 void MainWindow::on_save_with_temporary_file() {
3873 schoenebeck 3364 #if USE_GLIB_ACTION
3874     bool active = false;
3875     m_actionToggleSaveWithTempFile->get_state(active);
3876     // for some reason toggle state does not change automatically
3877     active = !active;
3878     m_actionToggleSaveWithTempFile->change_state(active);
3879     Settings::singleton()->saveWithTemporaryFile = active;
3880     #else
3881 schoenebeck 2967 Gtk::CheckMenuItem* item =
3882     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuSettings/SaveWithTemporaryFile"));
3883     if (!item) {
3884     std::cerr << "/MenuBar/MenuSettings/SaveWithTemporaryFile == NULL\n";
3885     return;
3886     }
3887     Settings::singleton()->saveWithTemporaryFile = item->get_active();
3888 schoenebeck 3364 #endif
3889 schoenebeck 2967 }
3890    
3891 schoenebeck 2464 bool MainWindow::is_copy_samples_unity_note_enabled() const {
3892 schoenebeck 3364 #if USE_GLIB_ACTION
3893     bool active = false;
3894     m_actionToggleCopySampleUnity->get_state(active);
3895     return active;
3896     #else
3897 schoenebeck 2464 Gtk::CheckMenuItem* item =
3898     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleUnity"));
3899     if (!item) {
3900     std::cerr << "/MenuBar/MenuEdit/CopySampleUnity == NULL\n";
3901     return true;
3902     }
3903     return item->get_active();
3904 schoenebeck 3364 #endif
3905 schoenebeck 2464 }
3906    
3907     bool MainWindow::is_copy_samples_fine_tune_enabled() const {
3908 schoenebeck 3364 #if USE_GLIB_ACTION
3909     bool active = false;
3910     m_actionToggleCopySampleTune->get_state(active);
3911     return active;
3912     #else
3913 schoenebeck 2464 Gtk::CheckMenuItem* item =
3914     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleTune"));
3915     if (!item) {
3916     std::cerr << "/MenuBar/MenuEdit/CopySampleTune == NULL\n";
3917     return true;
3918     }
3919     return item->get_active();
3920 schoenebeck 3364 #endif
3921 schoenebeck 2464 }
3922    
3923     bool MainWindow::is_copy_samples_loop_enabled() const {
3924 schoenebeck 3364 #if USE_GLIB_ACTION
3925     bool active = false;
3926     m_actionToggleCopySampleLoop->get_state(active);
3927     return active;
3928     #else
3929 schoenebeck 2464 Gtk::CheckMenuItem* item =
3930     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));
3931     if (!item) {
3932     std::cerr << "/MenuBar/MenuEdit/CopySampleLoop == NULL\n";
3933     return true;
3934     }
3935     return item->get_active();
3936 schoenebeck 3364 #endif
3937 schoenebeck 2464 }
3938    
3939 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
3940     bool MainWindow::on_button_release(Gdk::EventButton& _button) {
3941     GdkEventButton* button = _button.gobj();
3942     #else
3943     void MainWindow::on_button_release(GdkEventButton* button) {
3944     #endif
3945 schoenebeck 1225 if (button->type == GDK_2BUTTON_PRESS) {
3946 schoenebeck 3711 if (Settings::singleton()->instrumentDoubleClickOpensProps)
3947     show_instr_props();
3948 schoenebeck 1225 } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3949 persson 2507 // gig v2 files have no midi rules
3950 schoenebeck 2625 const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
3951 schoenebeck 3364 #if USE_GTKMM_BUILDER
3952     m_actionMIDIRules->property_enabled() = bEnabled;
3953     #else
3954 persson 2507 static_cast<Gtk::MenuItem*>(
3955 schoenebeck 2625 uiManager->get_widget("/MenuBar/MenuInstrument/MidiRules"))->set_sensitive(
3956     bEnabled
3957     );
3958     static_cast<Gtk::MenuItem*>(
3959 persson 2507 uiManager->get_widget("/PopupMenu/MidiRules"))->set_sensitive(
3960 schoenebeck 2625 bEnabled
3961     );
3962 schoenebeck 3364 #endif
3963 schoenebeck 1225 popup_menu->popup(button->button, button->time);
3964     }
3965 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
3966     return false;
3967     #endif
3968 schoenebeck 1225 }
3969    
3970 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3971 persson 2442 void MainWindow::on_instrument_selection_change(Gtk::RadioMenuItem* item) {
3972     if (item->get_active()) {
3973     const std::vector<Gtk::Widget*> children =
3974     instrument_menu->get_children();
3975     std::vector<Gtk::Widget*>::const_iterator it =
3976     find(children.begin(), children.end(), item);
3977     if (it != children.end()) {
3978     int index = it - children.begin();
3979 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(Gtk::TreePath(ToString(index)));
3980 persson 2442
3981     m_RegionChooser.set_instrument(file->GetInstrument(index));
3982     }
3983     }
3984 schoenebeck 1225 }
3985 schoenebeck 3364 #endif
3986 schoenebeck 1225
3987 schoenebeck 3712 void MainWindow::on_action_move_instr() {
3988     gig::Instrument* instr = get_instrument();
3989     if (!instr) return;
3990    
3991     int currentIndex = getIndexOf(instr);
3992    
3993     Gtk::Dialog dialog(_("Move Instrument"), true /*modal*/);
3994     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
3995     Gtk::Adjustment adjustment(
3996     currentIndex,
3997     0 /*min*/, file->CountInstruments() - 1 /*max*/
3998     );
3999     Gtk::SpinButton spinBox(adjustment);
4000     #else
4001     Gtk::SpinButton spinBox(
4002     Gtk::Adjustment::create(
4003     currentIndex,
4004     0 /*min*/, file->CountInstruments() - 1 /*max*/
4005     )
4006     );
4007     #endif
4008     #if USE_GTKMM_BOX
4009     dialog.get_content_area()->pack_start(spinBox);
4010     #else
4011     dialog.get_vbox()->pack_start(spinBox);
4012     #endif
4013     #if HAS_GTKMM_STOCK
4014     Gtk::Button* okButton = dialog.add_button(Gtk::Stock::OK, 0);
4015     dialog.add_button(Gtk::Stock::CANCEL, 1);
4016     #else
4017     Gtk::Button* okButton = dialog.add_button(_("_OK"), 0);
4018     dialog.add_button(_("_Cancel"), 1);
4019     #endif
4020     okButton->set_sensitive(false);
4021     // show the dialog at a reasonable screen position
4022     dialog.set_position(Gtk::WIN_POS_MOUSE);
4023     // only enable the 'OK' button if entered new index is not instrument's
4024     // current index already
4025     spinBox.signal_value_changed().connect([&]{
4026     okButton->set_sensitive( spinBox.get_value_as_int() != currentIndex );
4027     });
4028     // usability acceleration: if user hits enter key on the text entry field
4029     // then auto trigger the 'OK' button
4030     spinBox.signal_activate().connect([&]{
4031     if (okButton->get_sensitive())
4032     okButton->clicked();
4033     });
4034     #if HAS_GTKMM_SHOW_ALL_CHILDREN
4035     dialog.show_all_children();
4036     #endif
4037     if (!dialog.run()) { // 'OK' selected ...
4038     int newIndex = spinBox.get_value_as_int();
4039     printf("MOVE TO %d\n", newIndex);
4040     gig::Instrument* dst = file->GetInstrument(newIndex);
4041     instr->MoveTo(dst);
4042     __refreshEntireGUI();
4043     select_instrument(instr);
4044     }
4045     }
4046    
4047 schoenebeck 2701 void MainWindow::select_instrument(gig::Instrument* instrument) {
4048     if (!instrument) return;
4049    
4050 schoenebeck 3806 //NOTE: This is a big mess! Sometimes GTK requires m_refInstrumentsModelFilter->get_model(), here we need m_TreeViewInstruments.get_model(), otherwise treeview selection below causes an error!
4051     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
4052     //Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
4053 schoenebeck 3340
4054 schoenebeck 2701 for (int i = 0; i < model->children().size(); ++i) {
4055     Gtk::TreeModel::Row row = model->children()[i];
4056 schoenebeck 3806 if (row[m_InstrumentsModel.m_col_instr] == instrument) {
4057 schoenebeck 2701 // select and show the respective instrument in the list view
4058     show_intruments_tab();
4059 schoenebeck 3806 m_TreeViewInstruments.get_selection()->unselect_all();
4060 schoenebeck 3364
4061 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4062 schoenebeck 3364 auto iterSel = model->children()[i].get_iter();
4063 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(iterSel);
4064 schoenebeck 3364 #else
4065 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(model->children()[i]);
4066 schoenebeck 3364 #endif
4067 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4068 schoenebeck 3806 m_TreeViewInstruments.get_selection()->get_selected_rows();
4069 schoenebeck 2994 if (!rows.empty())
4070 schoenebeck 3806 m_TreeViewInstruments.scroll_to_row(rows[0]);
4071 schoenebeck 2701 on_sel_change(); // the regular instrument selection change callback
4072     }
4073     }
4074     }
4075    
4076 schoenebeck 2695 /// Returns true if requested dimension region was successfully selected and scrolled to in the list view, false on error.
4077     bool MainWindow::select_dimension_region(gig::DimensionRegion* dimRgn) {
4078     gig::Region* pRegion = (gig::Region*) dimRgn->GetParent();
4079     gig::Instrument* pInstrument = (gig::Instrument*) pRegion->GetParent();
4080    
4081 schoenebeck 3806 //NOTE: This is a big mess! Sometimes GTK requires m_refInstrumentsModelFilter->get_model(), here we need m_TreeViewInstruments.get_model(), otherwise treeview selection below causes an error!
4082     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewInstruments.get_model();
4083     //Glib::RefPtr<Gtk::TreeModel> model = m_refInstrumentsModelFilter->get_model();
4084 schoenebeck 3340
4085 schoenebeck 2695 for (int i = 0; i < model->children().size(); ++i) {
4086     Gtk::TreeModel::Row row = model->children()[i];
4087 schoenebeck 3806 if (row[m_InstrumentsModel.m_col_instr] == pInstrument) {
4088 schoenebeck 2695 // select and show the respective instrument in the list view
4089     show_intruments_tab();
4090 schoenebeck 3806 m_TreeViewInstruments.get_selection()->unselect_all();
4091 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4092 schoenebeck 3364 auto iterSel = model->children()[i].get_iter();
4093 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(iterSel);
4094 schoenebeck 3364 #else
4095 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(model->children()[i]);
4096 schoenebeck 3364 #endif
4097 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4098 schoenebeck 3806 m_TreeViewInstruments.get_selection()->get_selected_rows();
4099 schoenebeck 2994 if (!rows.empty())
4100 schoenebeck 3806 m_TreeViewInstruments.scroll_to_row(rows[0]);
4101 schoenebeck 2695 on_sel_change(); // the regular instrument selection change callback
4102    
4103     // select respective region in the region selector
4104     m_RegionChooser.set_region(pRegion);
4105    
4106     // select and show the respective dimension region in the editor
4107     //update_dimregs();
4108     if (!m_DimRegionChooser.select_dimregion(dimRgn)) return false;
4109     //dimreg_edit.set_dim_region(dimRgn);
4110    
4111     return true;
4112     }
4113     }
4114    
4115     return false;
4116     }
4117    
4118 schoenebeck 2691 void MainWindow::select_sample(gig::Sample* sample) {
4119     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewSamples.get_model();
4120     for (int g = 0; g < model->children().size(); ++g) {
4121     Gtk::TreeModel::Row rowGroup = model->children()[g];
4122     for (int s = 0; s < rowGroup.children().size(); ++s) {
4123     Gtk::TreeModel::Row rowSample = rowGroup.children()[s];
4124     if (rowSample[m_SamplesModel.m_col_sample] == sample) {
4125     show_samples_tab();
4126 schoenebeck 2994 m_TreeViewSamples.get_selection()->unselect_all();
4127 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4128 schoenebeck 3364 auto iterSel = rowGroup.children()[s].get_iter();
4129     m_TreeViewSamples.get_selection()->select(iterSel);
4130     #else
4131 schoenebeck 2691 m_TreeViewSamples.get_selection()->select(rowGroup.children()[s]);
4132 schoenebeck 3364 #endif
4133 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4134     m_TreeViewSamples.get_selection()->get_selected_rows();
4135     if (rows.empty()) return;
4136     m_TreeViewSamples.scroll_to_row(rows[0]);
4137 schoenebeck 2691 return;
4138     }
4139     }
4140     }
4141     }
4142    
4143 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
4144     bool MainWindow::on_sample_treeview_button_release(Gdk::EventButton& _button) {
4145     GdkEventButton* button = _button.gobj();
4146     #else
4147 schoenebeck 1225 void MainWindow::on_sample_treeview_button_release(GdkEventButton* button) {
4148 schoenebeck 3364 #endif
4149 schoenebeck 1225 if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
4150 schoenebeck 2994 // by default if Ctrl keys is pressed down, then a mouse right-click
4151     // does not select the respective row, so we must assure this
4152     // programmatically ...
4153     /*{
4154     Gtk::TreeModel::Path path;
4155     Gtk::TreeViewColumn* pColumn = NULL;
4156     int cellX, cellY;
4157     bool bSuccess = m_TreeViewSamples.get_path_at_pos(
4158     (int)button->x, (int)button->y,
4159     path, pColumn, cellX, cellY
4160     );
4161     if (bSuccess) {
4162     if (m_TreeViewSamples.get_selection()->count_selected_rows() <= 0) {
4163     printf("not selected !!!\n");
4164     m_TreeViewSamples.get_selection()->select(path);
4165     }
4166     }
4167     }*/
4168    
4169 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4170 schoenebeck 1225 Gtk::Menu* sample_popup =
4171     dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/SamplePopupMenu"));
4172 schoenebeck 3364 #endif
4173    
4174 schoenebeck 1225 // update enabled/disabled state of sample popup items
4175     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4176 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4177     const int n = rows.size();
4178     int nGroups = 0;
4179     int nSamples = 0;
4180     for (int r = 0; r < n; ++r) {
4181     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4182     if (!it) continue;
4183 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4184 schoenebeck 2994 if (row[m_SamplesModel.m_col_group]) nGroups++;
4185     if (row[m_SamplesModel.m_col_sample]) nSamples++;
4186 schoenebeck 1225 }
4187 schoenebeck 2994
4188 schoenebeck 3364 #if USE_GTKMM_BUILDER
4189     m_actionSampleProperties->property_enabled() = (n == 1);
4190     m_actionAddSample->property_enabled() = (n);
4191     m_actionAddSampleGroup->property_enabled() = (file);
4192     m_actionViewSampleRefs->property_enabled() = (nSamples == 1);
4193     m_actionRemoveSample->property_enabled() = (n);
4194     m_actionReplaceSample->property_enabled() = (nSamples == 1);
4195     #else
4196 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/SampleProperties"))->
4197 schoenebeck 2994 set_sensitive(n == 1);
4198 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddSample"))->
4199 schoenebeck 2994 set_sensitive(n);
4200 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddGroup"))->
4201     set_sensitive(file);
4202 schoenebeck 2624 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/ShowSampleRefs"))->
4203 schoenebeck 2994 set_sensitive(nSamples == 1);
4204 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/RemoveSample"))->
4205 schoenebeck 2994 set_sensitive(n);
4206 schoenebeck 3364 #endif
4207 schoenebeck 1225 // show sample popup
4208     sample_popup->popup(button->button, button->time);
4209 schoenebeck 2625
4210 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4211 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/SampleProperties"))->
4212 schoenebeck 2994 set_sensitive(n == 1);
4213 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddSample"))->
4214 schoenebeck 2994 set_sensitive(n);
4215 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddGroup"))->
4216     set_sensitive(file);
4217     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/ShowSampleRefs"))->
4218 schoenebeck 2994 set_sensitive(nSamples == 1);
4219 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/RemoveSample"))->
4220 schoenebeck 2994 set_sensitive(n);
4221 schoenebeck 3364 #endif
4222 schoenebeck 1225 }
4223 schoenebeck 3364
4224     #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
4225     return false;
4226     #endif
4227 schoenebeck 1225 }
4228    
4229 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
4230     bool MainWindow::on_script_treeview_button_release(Gdk::EventButton& _button) {
4231     GdkEventButton* button = _button.gobj();
4232     #else
4233 schoenebeck 2604 void MainWindow::on_script_treeview_button_release(GdkEventButton* button) {
4234 schoenebeck 3364 #endif
4235 schoenebeck 2604 if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
4236 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4237 schoenebeck 2604 Gtk::Menu* script_popup =
4238     dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/ScriptPopupMenu"));
4239 schoenebeck 3364 #endif
4240 schoenebeck 2604 // update enabled/disabled state of sample popup items
4241     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4242     Gtk::TreeModel::iterator it = sel->get_selected();
4243     bool group_selected = false;
4244     bool script_selected = false;
4245     if (it) {
4246     Gtk::TreeModel::Row row = *it;
4247     group_selected = row[m_ScriptsModel.m_col_group];
4248     script_selected = row[m_ScriptsModel.m_col_script];
4249     }
4250 schoenebeck 3364 #if USE_GTKMM_BUILDER
4251     m_actionAddScript->property_enabled() = (group_selected || script_selected);
4252     m_actionAddScriptGroup->property_enabled() = (file);
4253     m_actionEditScript->property_enabled() = (script_selected);
4254     m_actionRemoveScript->property_enabled() = (group_selected || script_selected);
4255     #else
4256 schoenebeck 2604 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScript"))->
4257     set_sensitive(group_selected || script_selected);
4258     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScriptGroup"))->
4259     set_sensitive(file);
4260     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/EditScript"))->
4261     set_sensitive(script_selected);
4262     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/RemoveScript"))->
4263     set_sensitive(group_selected || script_selected);
4264 schoenebeck 3364 #endif
4265 schoenebeck 2604 // show sample popup
4266     script_popup->popup(button->button, button->time);
4267 schoenebeck 2625
4268 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4269 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScript"))->
4270     set_sensitive(group_selected || script_selected);
4271     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScriptGroup"))->
4272     set_sensitive(file);
4273     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/EditScript"))->
4274     set_sensitive(script_selected);
4275     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/RemoveScript"))->
4276     set_sensitive(group_selected || script_selected);
4277 schoenebeck 3364 #endif
4278 schoenebeck 2604 }
4279 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
4280     return false;
4281     #endif
4282 schoenebeck 2604 }
4283 persson 2442
4284 schoenebeck 3339 void MainWindow::updateScriptListOfMenu() {
4285     // remove all entries from "Assign Script" menu
4286     {
4287     const std::vector<Gtk::Widget*> children = assign_scripts_menu->get_children();
4288     for (int i = 0; i < children.size(); ++i) {
4289     Gtk::Widget* child = children[i];
4290     assign_scripts_menu->remove(*child);
4291     delete child;
4292     }
4293     }
4294    
4295     int iTotalScripts = 0;
4296    
4297     if (!file) goto noScripts;
4298    
4299     // add all configured macros as menu items to the "Macro" menu
4300     for (int iGroup = 0; file->GetScriptGroup(iGroup); ++iGroup) {
4301     gig::ScriptGroup* pGroup = file->GetScriptGroup(iGroup);
4302     for (int iScript = 0; pGroup->GetScript(iScript); ++iScript, ++iTotalScripts) {
4303     gig::Script* pScript = pGroup->GetScript(iScript);
4304     std::string name = pScript->Name;
4305    
4306     Gtk::MenuItem* item = new Gtk::MenuItem(name);
4307     item->signal_activate().connect(
4308     sigc::bind(
4309     sigc::mem_fun(*this, &MainWindow::assignScript), pScript
4310     )
4311     );
4312     assign_scripts_menu->append(*item);
4313     item->set_accel_path("<Scripts>/script_" + ToString(iTotalScripts));
4314     //item->set_tooltip_text(comment);
4315     }
4316     }
4317    
4318     noScripts:
4319    
4320     // if there are no macros configured at all, then show a dummy entry instead
4321     if (!iTotalScripts) {
4322     Gtk::MenuItem* item = new Gtk::MenuItem(_("No Scripts"));
4323     item->set_sensitive(false);
4324     assign_scripts_menu->append(*item);
4325     }
4326    
4327 schoenebeck 3419 // add separator line to menu
4328     assign_scripts_menu->append(*new Gtk::SeparatorMenuItem);
4329    
4330     {
4331     Gtk::MenuItem* item = new Gtk::MenuItem(_("Unassign All Scripts"));
4332     item->signal_activate().connect(
4333     sigc::mem_fun(*this, &MainWindow::dropAllScriptSlots)
4334     );
4335     assign_scripts_menu->append(*item);
4336     item->set_accel_path("<Scripts>/DropAllScriptSlots");
4337     }
4338    
4339 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
4340 schoenebeck 3339 assign_scripts_menu->show_all_children();
4341 schoenebeck 3364 #endif
4342 schoenebeck 3339 }
4343    
4344 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4345 persson 2442 Gtk::RadioMenuItem* MainWindow::add_instrument_to_menu(
4346     const Glib::ustring& name, int position) {
4347    
4348     Gtk::RadioMenuItem::Group instrument_group;
4349     const std::vector<Gtk::Widget*> children = instrument_menu->get_children();
4350     if (!children.empty()) {
4351     instrument_group =
4352     static_cast<Gtk::RadioMenuItem*>(children[0])->get_group();
4353     }
4354     Gtk::RadioMenuItem* item =
4355     new Gtk::RadioMenuItem(instrument_group, name);
4356     if (position < 0) {
4357     instrument_menu->append(*item);
4358     } else {
4359     instrument_menu->insert(*item, position);
4360     }
4361     item->show();
4362     item->signal_activate().connect(
4363     sigc::bind(
4364     sigc::mem_fun(*this, &MainWindow::on_instrument_selection_change),
4365     item));
4366     return item;
4367     }
4368 schoenebeck 3364 #endif
4369 persson 2442
4370 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4371 persson 2442 void MainWindow::remove_instrument_from_menu(int index) {
4372     const std::vector<Gtk::Widget*> children =
4373     instrument_menu->get_children();
4374     Gtk::Widget* child = children[index];
4375     instrument_menu->remove(*child);
4376     delete child;
4377     }
4378 schoenebeck 3364 #endif
4379 persson 2442
4380     void MainWindow::add_instrument(gig::Instrument* instrument) {
4381 persson 2446 const Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
4382 persson 2442
4383     // update instrument tree view
4384     instrument_name_connection.block();
4385 schoenebeck 3806 Gtk::TreeModel::iterator iterInstr = m_refInstrumentsTreeModel->append();
4386 persson 2442 Gtk::TreeModel::Row rowInstr = *iterInstr;
4387 schoenebeck 3806 const int index = m_refInstrumentsTreeModel->children().size() - 1;
4388 schoenebeck 3800 const int iScriptSlots = instrument->ScriptSlotCount();
4389 schoenebeck 3806 rowInstr[m_InstrumentsModel.m_col_nr] = index;
4390     rowInstr[m_InstrumentsModel.m_col_name] = name;
4391     rowInstr[m_InstrumentsModel.m_col_instr] = instrument;
4392     rowInstr[m_InstrumentsModel.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
4393     rowInstr[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
4394 persson 2442 instrument_name_connection.unblock();
4395    
4396 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4397 persson 2442 add_instrument_to_menu(name);
4398 schoenebeck 3364 #endif
4399 schoenebeck 3339 select_instrument(instrument);
4400 persson 2442 file_changed();
4401     }
4402    
4403 schoenebeck 1225 void MainWindow::on_action_add_instrument() {
4404     static int __instrument_indexer = 0;
4405     if (!file) return;
4406     gig::Instrument* instrument = file->AddInstrument();
4407     __instrument_indexer++;
4408 persson 2446 instrument->pInfo->Name = gig_from_utf8(_("Unnamed Instrument ") +
4409     ToString(__instrument_indexer));
4410 persson 2442
4411     add_instrument(instrument);
4412 schoenebeck 1225 }
4413    
4414 schoenebeck 2395 void MainWindow::on_action_duplicate_instrument() {
4415     if (!file) return;
4416 persson 2442
4417 schoenebeck 2395 // retrieve the currently selected instrument
4418     // (being the original instrument to be duplicated)
4419 schoenebeck 3806 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
4420 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4421     for (int r = 0; r < rows.size(); ++r) {
4422 schoenebeck 3811 // convert index of visual selection (i.e. if filtered) to index of model
4423     Gtk::TreeModel::Path path = m_refInstrumentsModelFilter->convert_path_to_child_path(rows[r]);
4424     Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(path);
4425 schoenebeck 2994 if (it) {
4426     Gtk::TreeModel::Row row = *it;
4427 schoenebeck 3806 gig::Instrument* instrOrig = row[m_InstrumentsModel.m_col_instr];
4428 schoenebeck 2994 if (instrOrig) {
4429     // duplicate the orginal instrument
4430     gig::Instrument* instrNew = file->AddDuplicateInstrument(instrOrig);
4431     instrNew->pInfo->Name =
4432     instrOrig->pInfo->Name +
4433     gig_from_utf8(Glib::ustring(" (") + _("Copy") + ")");
4434 persson 2442
4435 schoenebeck 2994 add_instrument(instrNew);
4436     }
4437     }
4438     }
4439 schoenebeck 2395 }
4440    
4441 schoenebeck 1225 void MainWindow::on_action_remove_instrument() {
4442     if (!file) return;
4443 schoenebeck 1382 if (file_is_shared) {
4444     Gtk::MessageDialog msg(
4445     *this,
4446     _("You cannot delete an instrument from this file, since it's "
4447     "currently used by the sampler."),
4448     false, Gtk::MESSAGE_INFO
4449     );
4450     msg.run();
4451     return;
4452     }
4453    
4454 schoenebeck 3806 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
4455 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4456     for (int r = rows.size() - 1; r >= 0; --r) {
4457 schoenebeck 3806 Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(rows[r]);
4458 schoenebeck 2994 if (!it) continue;
4459 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4460 schoenebeck 3806 gig::Instrument* instr = row[m_InstrumentsModel.m_col_instr];
4461 schoenebeck 1225 try {
4462 persson 2442 Gtk::TreePath path(it);
4463     int index = path[0];
4464    
4465 schoenebeck 1225 // remove instrument from the gig file
4466     if (instr) file->DeleteInstrument(instr);
4467 persson 1261 file_changed();
4468 persson 2423
4469 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4470 persson 2442 remove_instrument_from_menu(index);
4471 schoenebeck 3364 #endif
4472 persson 2442
4473     // remove row from instruments tree view
4474 schoenebeck 3806 m_refInstrumentsTreeModel->erase(it);
4475 schoenebeck 2994 // update "Nr" column of all instrument rows
4476     {
4477     int index = 0;
4478 schoenebeck 3806 for (Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->children().begin();
4479     it != m_refInstrumentsTreeModel->children().end(); ++it, ++index)
4480 schoenebeck 2994 {
4481     Gtk::TreeModel::Row row = *it;
4482 schoenebeck 3806 gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
4483     row[m_InstrumentsModel.m_col_nr] = index;
4484     row[m_InstrumentsModel.m_col_tooltip] = scriptTooltipFor(instrument, index);
4485 schoenebeck 2994 }
4486     }
4487 persson 2442
4488     #if GTKMM_MAJOR_VERSION < 3
4489     // select another instrument (in gtk3 this is done
4490     // automatically)
4491 schoenebeck 3806 if (!m_refInstrumentsTreeModel->children().empty()) {
4492     if (index == m_refInstrumentsTreeModel->children().size()) {
4493 persson 2442 index--;
4494     }
4495 schoenebeck 3806 m_TreeViewInstruments.get_selection()->select(
4496 persson 2442 Gtk::TreePath(ToString(index)));
4497     }
4498     #endif
4499 persson 2445 instr_props_set_instrument();
4500 persson 2507 instr = get_instrument();
4501     if (instr) {
4502     midiRules.set_instrument(instr);
4503     } else {
4504     midiRules.hide();
4505     }
4506 schoenebeck 1225 } catch (RIFF::Exception e) {
4507     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
4508     msg.run();
4509     }
4510     }
4511     }
4512    
4513     void MainWindow::on_action_sample_properties() {
4514 schoenebeck 3637 show_sample_props();
4515 schoenebeck 1225 }
4516    
4517 schoenebeck 2604 void MainWindow::on_action_add_script_group() {
4518     static int __script_indexer = 0;
4519     if (!file) return;
4520     gig::ScriptGroup* group = file->AddScriptGroup();
4521     group->Name = gig_from_utf8(_("Unnamed Group"));
4522     if (__script_indexer) group->Name += " " + ToString(__script_indexer);
4523     __script_indexer++;
4524     // update sample tree view
4525     Gtk::TreeModel::iterator iterGroup = m_refScriptsTreeModel->append();
4526     Gtk::TreeModel::Row rowGroup = *iterGroup;
4527     rowGroup[m_ScriptsModel.m_col_name] = gig_to_utf8(group->Name);
4528     rowGroup[m_ScriptsModel.m_col_script] = NULL;
4529     rowGroup[m_ScriptsModel.m_col_group] = group;
4530     file_changed();
4531     }
4532    
4533     void MainWindow::on_action_add_script() {
4534     if (!file) return;
4535     // get selected group
4536     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4537     Gtk::TreeModel::iterator it = sel->get_selected();
4538     if (!it) return;
4539     Gtk::TreeModel::Row row = *it;
4540     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
4541     if (!group) { // not a group, but a script is selected (probably)
4542     gig::Script* script = row[m_ScriptsModel.m_col_script];
4543     if (!script) return;
4544     it = row.parent(); // resolve parent (that is the script's group)
4545     if (!it) return;
4546     row = *it;
4547     group = row[m_ScriptsModel.m_col_group];
4548     if (!group) return;
4549     }
4550    
4551     // add a new script to the .gig file
4552     gig::Script* script = group->AddScript();
4553     Glib::ustring name = _("Unnamed Script");
4554     script->Name = gig_from_utf8(name);
4555    
4556     // add script to the tree view
4557     Gtk::TreeModel::iterator iterScript =
4558     m_refScriptsTreeModel->append(row.children());
4559     Gtk::TreeModel::Row rowScript = *iterScript;
4560     rowScript[m_ScriptsModel.m_col_name] = name;
4561     rowScript[m_ScriptsModel.m_col_script] = script;
4562     rowScript[m_ScriptsModel.m_col_group] = NULL;
4563    
4564     // unfold group of new script item in treeview
4565     Gtk::TreeModel::Path path(iterScript);
4566     m_TreeViewScripts.expand_to_path(path);
4567     }
4568    
4569     void MainWindow::on_action_edit_script() {
4570     if (!file) return;
4571     // get selected script
4572     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4573     Gtk::TreeModel::iterator it = sel->get_selected();
4574     if (!it) return;
4575     Gtk::TreeModel::Row row = *it;
4576     gig::Script* script = row[m_ScriptsModel.m_col_script];
4577 schoenebeck 3749 editScript(script);
4578     }
4579    
4580     void MainWindow::editScript(gig::Script* script) {
4581 schoenebeck 2604 if (!script) return;
4582     ScriptEditor* editor = new ScriptEditor;
4583 schoenebeck 2903 editor->signal_script_to_be_changed.connect(
4584     signal_script_to_be_changed.make_slot()
4585     );
4586 schoenebeck 3750 editor->signal_script_changed.connect([this](gig::Script* script) {
4587     // signal to sampler (which will reload the script due to this)
4588     signal_script_changed.emit(script);
4589     // force script 'patch' variables editor ("Script" tab) to be refreshed
4590     gig::Instrument* instr = get_instrument();
4591     dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
4592     });
4593 schoenebeck 2604 editor->setScript(script);
4594     //editor->reparent(*this);
4595     editor->show();
4596     }
4597    
4598     void MainWindow::on_action_remove_script() {
4599     if (!file) return;
4600     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4601     Gtk::TreeModel::iterator it = sel->get_selected();
4602     if (it) {
4603     Gtk::TreeModel::Row row = *it;
4604     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
4605     gig::Script* script = row[m_ScriptsModel.m_col_script];
4606     Glib::ustring name = row[m_ScriptsModel.m_col_name];
4607     try {
4608     // remove script group or script from the gig file
4609     if (group) {
4610     // notify everybody that we're going to remove these samples
4611     //TODO: scripts_to_be_removed_signal.emit(members);
4612     // delete the group in the .gig file including the
4613     // samples that belong to the group
4614     file->DeleteScriptGroup(group);
4615     // notify that we're done with removal
4616     //TODO: scripts_removed_signal.emit();
4617     file_changed();
4618     } else if (script) {
4619     // notify everybody that we're going to remove this sample
4620     //TODO: std::list<gig::Script*> lscripts;
4621     //TODO: lscripts.push_back(script);
4622     //TODO: scripts_to_be_removed_signal.emit(lscripts);
4623     // remove sample from the .gig file
4624     script->GetGroup()->DeleteScript(script);
4625     // notify that we're done with removal
4626     //TODO: scripts_removed_signal.emit();
4627     dimreg_changed();
4628     file_changed();
4629     }
4630     // remove respective row(s) from samples tree view
4631     m_refScriptsTreeModel->erase(it);
4632     } catch (RIFF::Exception e) {
4633     // pretend we're done with removal (i.e. to avoid dead locks)
4634     //TODO: scripts_removed_signal.emit();
4635     // show error message
4636     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
4637     msg.run();
4638     }
4639     }
4640     }
4641    
4642 schoenebeck 1225 void MainWindow::on_action_add_group() {
4643     static int __sample_indexer = 0;
4644     if (!file) return;
4645     gig::Group* group = file->AddGroup();
4646 persson 2446 group->Name = gig_from_utf8(_("Unnamed Group"));
4647 schoenebeck 1225 if (__sample_indexer) group->Name += " " + ToString(__sample_indexer);
4648     __sample_indexer++;
4649     // update sample tree view
4650     Gtk::TreeModel::iterator iterGroup = m_refSamplesTreeModel->append();
4651     Gtk::TreeModel::Row rowGroup = *iterGroup;
4652 persson 2446 rowGroup[m_SamplesModel.m_col_name] = gig_to_utf8(group->Name);
4653 schoenebeck 1225 rowGroup[m_SamplesModel.m_col_sample] = NULL;
4654     rowGroup[m_SamplesModel.m_col_group] = group;
4655 persson 1261 file_changed();
4656 schoenebeck 1225 }
4657    
4658 schoenebeck 2715 void MainWindow::on_action_replace_sample() {
4659     add_or_replace_sample(true);
4660     }
4661    
4662 schoenebeck 1225 void MainWindow::on_action_add_sample() {
4663 schoenebeck 2715 add_or_replace_sample(false);
4664     }
4665    
4666     void MainWindow::add_or_replace_sample(bool replace) {
4667 schoenebeck 1225 if (!file) return;
4668 schoenebeck 2715
4669     // get selected group (and probably selected sample)
4670 schoenebeck 1225 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4671 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4672     if (rows.empty()) return;
4673     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
4674 schoenebeck 1225 if (!it) return;
4675     Gtk::TreeModel::Row row = *it;
4676 schoenebeck 2715 gig::Sample* sample = NULL;
4677 schoenebeck 1225 gig::Group* group = row[m_SamplesModel.m_col_group];
4678     if (!group) { // not a group, but a sample is selected (probably)
4679 schoenebeck 2715 if (replace) sample = row[m_SamplesModel.m_col_sample];
4680     if (!row[m_SamplesModel.m_col_sample]) return;
4681 schoenebeck 1225 it = row.parent(); // resolve parent (that is the sample's group)
4682     if (!it) return;
4683 schoenebeck 2715 if (!replace) row = *it;
4684     group = (*it)[m_SamplesModel.m_col_group];
4685 schoenebeck 1225 if (!group) return;
4686     }
4687 schoenebeck 2715 if (replace && !sample) return;
4688    
4689 schoenebeck 1225 // show 'browse for file' dialog
4690 schoenebeck 2715 Gtk::FileChooserDialog dialog(*this, replace ? _("Replace Sample with") : _("Add Sample(s)"));
4691 schoenebeck 3364 #if HAS_GTKMM_STOCK
4692 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4693     dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
4694 schoenebeck 3364 #else
4695     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4696     dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
4697     #endif
4698 schoenebeck 2715 dialog.set_select_multiple(!replace); // allow multi audio file selection only when adding new samples, does not make sense when replacing a specific sample
4699 persson 2169
4700     // matches all file types supported by libsndfile
4701     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
4702     Gtk::FileFilter soundfilter;
4703     #else
4704     Glib::RefPtr<Gtk::FileFilter> soundfilter = Gtk::FileFilter::create();
4705     #endif
4706 persson 1262 const char* const supportedFileTypes[] = {
4707 schoenebeck 1225 "*.wav", "*.WAV", "*.aiff", "*.AIFF", "*.aifc", "*.AIFC", "*.snd",
4708     "*.SND", "*.au", "*.AU", "*.paf", "*.PAF", "*.iff", "*.IFF",
4709     "*.svx", "*.SVX", "*.sf", "*.SF", "*.voc", "*.VOC", "*.w64",
4710     "*.W64", "*.pvf", "*.PVF", "*.xi", "*.XI", "*.htk", "*.HTK",
4711     "*.caf", "*.CAF", NULL
4712     };
4713 persson 2169 const char* soundfiles = _("Sound Files");
4714     const char* allfiles = _("All Files");
4715     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
4716 schoenebeck 1225 for (int i = 0; supportedFileTypes[i]; i++)
4717     soundfilter.add_pattern(supportedFileTypes[i]);
4718 persson 2169 soundfilter.set_name(soundfiles);
4719    
4720     // matches every file
4721     Gtk::FileFilter allpassfilter;
4722 schoenebeck 1225 allpassfilter.add_pattern("*.*");
4723 persson 2169 allpassfilter.set_name(allfiles);
4724     #else
4725     for (int i = 0; supportedFileTypes[i]; i++)
4726     soundfilter->add_pattern(supportedFileTypes[i]);
4727     soundfilter->set_name(soundfiles);
4728    
4729     // matches every file
4730     Glib::RefPtr<Gtk::FileFilter> allpassfilter = Gtk::FileFilter::create();
4731     allpassfilter->add_pattern("*.*");
4732     allpassfilter->set_name(allfiles);
4733     #endif
4734 schoenebeck 1225 dialog.add_filter(soundfilter);
4735     dialog.add_filter(allpassfilter);
4736 persson 1725 if (current_sample_dir != "") {
4737     dialog.set_current_folder(current_sample_dir);
4738     }
4739 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
4740 persson 3477 dialog.hide();
4741 persson 1725 current_sample_dir = dialog.get_current_folder();
4742 schoenebeck 1225 Glib::ustring error_files;
4743 persson 2169 std::vector<std::string> filenames = dialog.get_filenames();
4744     for (std::vector<std::string>::iterator iter = filenames.begin();
4745 schoenebeck 1225 iter != filenames.end(); ++iter) {
4746     printf("Adding sample %s\n",(*iter).c_str());
4747 schoenebeck 3408 // use libsndfile to retrieve file information
4748 schoenebeck 1225 SF_INFO info;
4749     info.format = 0;
4750     SNDFILE* hFile = sf_open((*iter).c_str(), SFM_READ, &info);
4751     try {
4752 persson 1831 if (!hFile) throw std::string(_("could not open file"));
4753 schoenebeck 1225 int bitdepth;
4754     switch (info.format & 0xff) {
4755     case SF_FORMAT_PCM_S8:
4756     case SF_FORMAT_PCM_16:
4757 persson 1265 case SF_FORMAT_PCM_U8:
4758 schoenebeck 1225 bitdepth = 16;
4759     break;
4760     case SF_FORMAT_PCM_24:
4761     case SF_FORMAT_PCM_32:
4762     case SF_FORMAT_FLOAT:
4763     case SF_FORMAT_DOUBLE:
4764 persson 1265 bitdepth = 24;
4765 schoenebeck 1225 break;
4766     default:
4767     sf_close(hFile); // close sound file
4768 persson 1831 throw std::string(_("format not supported")); // unsupported subformat (yet?)
4769 schoenebeck 1225 }
4770 schoenebeck 2715 // add a new sample to the .gig file (if adding is requested actually)
4771     if (!replace) sample = file->AddSample();
4772 schoenebeck 1225 // file name without path
4773 persson 1262 Glib::ustring filename = Glib::filename_display_basename(*iter);
4774     // remove file extension if there is one
4775     for (int i = 0; supportedFileTypes[i]; i++) {
4776     if (Glib::str_has_suffix(filename, supportedFileTypes[i] + 1)) {
4777     filename.erase(filename.length() - strlen(supportedFileTypes[i] + 1));
4778     break;
4779     }
4780     }
4781 persson 2446 sample->pInfo->Name = gig_from_utf8(filename);
4782 schoenebeck 1225 sample->Channels = info.channels;
4783     sample->BitDepth = bitdepth;
4784     sample->FrameSize = bitdepth / 8/*1 byte are 8 bits*/ * info.channels;
4785     sample->SamplesPerSecond = info.samplerate;
4786 persson 1265 sample->AverageBytesPerSecond = sample->FrameSize * sample->SamplesPerSecond;
4787     sample->BlockAlign = sample->FrameSize;
4788     sample->SamplesTotal = info.frames;
4789    
4790     SF_INSTRUMENT instrument;
4791     if (sf_command(hFile, SFC_GET_INSTRUMENT,
4792     &instrument, sizeof(instrument)) != SF_FALSE)
4793     {
4794     sample->MIDIUnityNote = instrument.basenote;
4795 schoenebeck 2466 sample->FineTune = instrument.detune;
4796 persson 1265
4797     if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {
4798     sample->Loops = 1;
4799    
4800     switch (instrument.loops[0].mode) {
4801     case SF_LOOP_FORWARD:
4802     sample->LoopType = gig::loop_type_normal;
4803     break;
4804     case SF_LOOP_BACKWARD:
4805     sample->LoopType = gig::loop_type_backward;
4806     break;
4807     case SF_LOOP_ALTERNATING:
4808     sample->LoopType = gig::loop_type_bidirectional;
4809     break;
4810     }
4811     sample->LoopStart = instrument.loops[0].start;
4812     sample->LoopEnd = instrument.loops[0].end;
4813     sample->LoopPlayCount = instrument.loops[0].count;
4814     sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;
4815     }
4816     }
4817    
4818 schoenebeck 1225 // schedule resizing the sample (which will be done
4819     // physically when File::Save() is called)
4820     sample->Resize(info.frames);
4821     // make sure sample is part of the selected group
4822 schoenebeck 2715 if (!replace) group->AddSample(sample);
4823 schoenebeck 1225 // schedule that physical resize and sample import
4824     // (data copying), performed when "Save" is requested
4825     SampleImportItem sched_item;
4826     sched_item.gig_sample = sample;
4827     sched_item.sample_path = *iter;
4828 schoenebeck 3116 m_SampleImportQueue[sample] = sched_item;
4829 schoenebeck 1225 // add sample to the tree view
4830 schoenebeck 2715 if (replace) {
4831     row[m_SamplesModel.m_col_name] = gig_to_utf8(sample->pInfo->Name);
4832     } else {
4833     Gtk::TreeModel::iterator iterSample =
4834     m_refSamplesTreeModel->append(row.children());
4835     Gtk::TreeModel::Row rowSample = *iterSample;
4836     rowSample[m_SamplesModel.m_col_name] =
4837     gig_to_utf8(sample->pInfo->Name);
4838     rowSample[m_SamplesModel.m_col_sample] = sample;
4839     rowSample[m_SamplesModel.m_col_group] = NULL;
4840     }
4841 schoenebeck 1225 // close sound file
4842     sf_close(hFile);
4843 persson 1261 file_changed();
4844 schoenebeck 1225 } catch (std::string what) { // remember the files that made trouble (and their cause)
4845 persson 2442 if (!error_files.empty()) error_files += "\n";
4846 schoenebeck 1225 error_files += *iter += " (" + what + ")";
4847     }
4848     }
4849     // show error message box when some file(s) could not be opened / added
4850 persson 2442 if (!error_files.empty()) {
4851 schoenebeck 2715 Glib::ustring txt =
4852     (replace
4853     ? _("Failed to replace sample with:\n")
4854     : _("Could not add the following sample(s):\n"))
4855     + error_files;
4856 schoenebeck 1225 Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
4857     msg.run();
4858     }
4859     }
4860     }
4861    
4862 schoenebeck 1673 void MainWindow::on_action_replace_all_samples_in_all_groups()
4863     {
4864     if (!file) return;
4865     Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
4866     Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
4867 persson 2442 const char* str =
4868 schoenebeck 1673 _("This is a very specific function. It tries to replace all samples "
4869 persson 1799 "in the current gig file by samples located in the chosen "
4870     "directory.\n\n"
4871     "It works like this: For each sample in the gig file, it tries to "
4872 schoenebeck 1673 "find a sample file in the selected directory with the same name as "
4873 persson 1799 "the sample in the gig file. Optionally, you can add a filename "
4874     "extension below, which will be added to the filename expected to be "
4875 schoenebeck 1673 "found. That is, assume you have a gig file with a sample called "
4876     "'Snare', if you enter '.wav' below (like it's done by default), it "
4877 persson 1799 "expects to find a sample file called 'Snare.wav' and will replace "
4878     "the sample in the gig file accordingly. If you don't need an "
4879     "extension, blank the field below. Any gig sample where no "
4880     "appropriate sample file could be found will be reported and left "
4881 persson 2344 "untouched.\n");
4882     #if GTKMM_MAJOR_VERSION < 3
4883     view::WrapLabel description(str);
4884     #else
4885     Gtk::Label description(str);
4886     description.set_line_wrap();
4887     #endif
4888 schoenebeck 3364 HBox entryArea;
4889 persson 2169 Gtk::Label entryLabel( _("Add filename extension: "), Gtk::ALIGN_START);
4890 schoenebeck 1673 Gtk::Entry postfixEntryBox;
4891     postfixEntryBox.set_text(".wav");
4892     entryArea.pack_start(entryLabel);
4893     entryArea.pack_start(postfixEntryBox);
4894 schoenebeck 3364 #if USE_GTKMM_BOX
4895     dialog.get_content_area()->pack_start(description, Gtk::PACK_SHRINK);
4896     dialog.get_content_area()->pack_start(entryArea, Gtk::PACK_SHRINK);
4897     #else
4898 schoenebeck 1673 dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
4899     dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
4900 schoenebeck 3364 #endif
4901 schoenebeck 1673 description.show();
4902 schoenebeck 3364
4903     #if HAS_GTKMM_SHOW_ALL_CHILDREN
4904 persson 1799 entryArea.show_all();
4905 schoenebeck 3364 #else
4906     entryArea.show();
4907     #endif
4908    
4909     #if HAS_GTKMM_STOCK
4910 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4911 schoenebeck 3364 #else
4912     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4913     #endif
4914 schoenebeck 1673 dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
4915     dialog.set_select_multiple(false);
4916 persson 1725 if (current_sample_dir != "") {
4917     dialog.set_current_folder(current_sample_dir);
4918     }
4919 schoenebeck 1673 if (dialog.run() == Gtk::RESPONSE_OK)
4920     {
4921 persson 3477 dialog.hide();
4922 persson 1725 current_sample_dir = dialog.get_current_folder();
4923 schoenebeck 1673 Glib::ustring error_files;
4924 persson 2169 std::string folder = dialog.get_filename();
4925 schoenebeck 1673 for (gig::Sample* sample = file->GetFirstSample();
4926     sample; sample = file->GetNextSample())
4927     {
4928     std::string filename =
4929 persson 2446 folder + G_DIR_SEPARATOR_S +
4930     Glib::filename_from_utf8(gig_to_utf8(sample->pInfo->Name) +
4931     postfixEntryBox.get_text());
4932 schoenebeck 1673 SF_INFO info;
4933     info.format = 0;
4934     SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
4935     try
4936     {
4937 persson 1831 if (!hFile) throw std::string(_("could not open file"));
4938 schoenebeck 1673 switch (info.format & 0xff) {
4939     case SF_FORMAT_PCM_S8:
4940     case SF_FORMAT_PCM_16:
4941     case SF_FORMAT_PCM_U8:
4942     case SF_FORMAT_PCM_24:
4943     case SF_FORMAT_PCM_32:
4944     case SF_FORMAT_FLOAT:
4945     case SF_FORMAT_DOUBLE:
4946     break;
4947     default:
4948     sf_close(hFile);
4949 persson 1831 throw std::string(_("format not supported"));
4950 schoenebeck 1673 }
4951     SampleImportItem sched_item;
4952     sched_item.gig_sample = sample;
4953     sched_item.sample_path = filename;
4954 schoenebeck 3116 m_SampleImportQueue[sample] = sched_item;
4955 schoenebeck 1673 sf_close(hFile);
4956     file_changed();
4957     }
4958     catch (std::string what)
4959     {
4960 persson 2442 if (!error_files.empty()) error_files += "\n";
4961 persson 2446 error_files += Glib::filename_to_utf8(filename) +
4962     " (" + what + ")";
4963 schoenebeck 1673 }
4964     }
4965     // show error message box when some file(s) could not be opened / added
4966 persson 2442 if (!error_files.empty()) {
4967 schoenebeck 1673 Glib::ustring txt =
4968     _("Could not replace the following sample(s):\n") + error_files;
4969     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
4970     msg.run();
4971     }
4972     }
4973     }
4974    
4975 schoenebeck 1225 void MainWindow::on_action_remove_sample() {
4976     if (!file) return;
4977     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4978 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4979     for (int r = rows.size() - 1; r >= 0; --r) {
4980     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4981     if (!it) continue;
4982 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4983     gig::Group* group = row[m_SamplesModel.m_col_group];
4984     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
4985     Glib::ustring name = row[m_SamplesModel.m_col_name];
4986     try {
4987     // remove group or sample from the gig file
4988     if (group) {
4989 persson 2446 // temporarily remember the samples that belong to
4990 schoenebeck 1225 // that group (we need that to clean the queue)
4991     std::list<gig::Sample*> members;
4992     for (gig::Sample* pSample = group->GetFirstSample();
4993     pSample; pSample = group->GetNextSample()) {
4994     members.push_back(pSample);
4995     }
4996 schoenebeck 1322 // notify everybody that we're going to remove these samples
4997     samples_to_be_removed_signal.emit(members);
4998 schoenebeck 1225 // delete the group in the .gig file including the
4999     // samples that belong to the group
5000     file->DeleteGroup(group);
5001 schoenebeck 1322 // notify that we're done with removal
5002     samples_removed_signal.emit();
5003 schoenebeck 1225 // if sample(s) were just previously added, remove
5004     // them from the import queue
5005     for (std::list<gig::Sample*>::iterator member = members.begin();
5006 schoenebeck 3116 member != members.end(); ++member)
5007     {
5008     if (m_SampleImportQueue.count(*member)) {
5009     printf("Removing previously added sample '%s' from group '%s'\n",
5010     m_SampleImportQueue[sample].sample_path.c_str(), name.c_str());
5011     m_SampleImportQueue.erase(*member);
5012 schoenebeck 1225 }
5013     }
5014 persson 1261 file_changed();
5015 schoenebeck 1225 } else if (sample) {
5016 schoenebeck 1322 // notify everybody that we're going to remove this sample
5017     std::list<gig::Sample*> lsamples;
5018     lsamples.push_back(sample);
5019     samples_to_be_removed_signal.emit(lsamples);
5020 schoenebeck 1225 // remove sample from the .gig file
5021     file->DeleteSample(sample);
5022 schoenebeck 1322 // notify that we're done with removal
5023     samples_removed_signal.emit();
5024 schoenebeck 1225 // if sample was just previously added, remove it from
5025     // the import queue
5026 schoenebeck 3116 if (m_SampleImportQueue.count(sample)) {
5027     printf("Removing previously added sample '%s'\n",
5028     m_SampleImportQueue[sample].sample_path.c_str());
5029     m_SampleImportQueue.erase(sample);
5030 schoenebeck 1225 }
5031 persson 1303 dimreg_changed();
5032 persson 1261 file_changed();
5033 schoenebeck 1225 }
5034     // remove respective row(s) from samples tree view
5035     m_refSamplesTreeModel->erase(it);
5036     } catch (RIFF::Exception e) {
5037 schoenebeck 1322 // pretend we're done with removal (i.e. to avoid dead locks)
5038     samples_removed_signal.emit();
5039     // show error message
5040 schoenebeck 1225 Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
5041     msg.run();
5042     }
5043     }
5044     }
5045    
5046 schoenebeck 2772 void MainWindow::on_action_remove_unused_samples() {
5047     if (!file) return;
5048    
5049     // collect all samples that are not referenced by any instrument
5050     std::list<gig::Sample*> lsamples;
5051     for (int iSample = 0; file->GetSample(iSample); ++iSample) {
5052     gig::Sample* sample = file->GetSample(iSample);
5053     bool isUsed = false;
5054     for (gig::Instrument* instrument = file->GetFirstInstrument(); instrument;
5055     instrument = file->GetNextInstrument())
5056     {
5057     for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
5058     rgn = instrument->GetNextRegion())
5059     {
5060     for (int i = 0; i < 256; ++i) {
5061     if (!rgn->pDimensionRegions[i]) continue;
5062     if (rgn->pDimensionRegions[i]->pSample != sample) continue;
5063     isUsed = true;
5064     goto endOfRefSearch;
5065     }
5066     }
5067     }
5068     endOfRefSearch:
5069     if (!isUsed) lsamples.push_back(sample);
5070     }
5071    
5072     if (lsamples.empty()) return;
5073    
5074     // notify everybody that we're going to remove these samples
5075     samples_to_be_removed_signal.emit(lsamples);
5076    
5077     // remove collected samples
5078     try {
5079     for (std::list<gig::Sample*>::iterator itSample = lsamples.begin();
5080     itSample != lsamples.end(); ++itSample)
5081     {
5082     gig::Sample* sample = *itSample;
5083     // remove sample from the .gig file
5084     file->DeleteSample(sample);
5085 schoenebeck 3116 // if sample was just previously added, remove it from the import queue
5086     if (m_SampleImportQueue.count(sample)) {
5087     printf("Removing previously added sample '%s'\n",
5088     m_SampleImportQueue[sample].sample_path.c_str());
5089     m_SampleImportQueue.erase(sample);
5090 schoenebeck 2772 }
5091     }
5092     } catch (RIFF::Exception e) {
5093     // show error message
5094     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
5095     msg.run();
5096     }
5097    
5098     // notify everybody that we're done with removal
5099     samples_removed_signal.emit();
5100    
5101     dimreg_changed();
5102     file_changed();
5103     __refreshEntireGUI();
5104     }
5105    
5106 schoenebeck 2610 // see comment on on_sample_treeview_drag_begin()
5107     void MainWindow::on_scripts_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5108     {
5109     first_call_to_drag_data_get = true;
5110     }
5111    
5112     void MainWindow::on_scripts_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5113     Gtk::SelectionData& selection_data, guint, guint)
5114     {
5115     if (!first_call_to_drag_data_get) return;
5116     first_call_to_drag_data_get = false;
5117    
5118     // get selected script
5119     gig::Script* script = NULL;
5120     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
5121     Gtk::TreeModel::iterator it = sel->get_selected();
5122     if (it) {
5123     Gtk::TreeModel::Row row = *it;
5124     script = row[m_ScriptsModel.m_col_script];
5125     }
5126     // pass the gig::Script as pointer
5127     selection_data.set(selection_data.get_target(), 0/*unused*/,
5128     (const guchar*)&script,
5129     sizeof(script)/*length of data in bytes*/);
5130     }
5131    
5132 schoenebeck 2701 // see comment on on_sample_treeview_drag_begin()
5133     void MainWindow::on_instruments_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5134     {
5135     first_call_to_drag_data_get = true;
5136     }
5137    
5138     void MainWindow::on_instruments_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5139     Gtk::SelectionData& selection_data, guint, guint)
5140     {
5141     if (!first_call_to_drag_data_get) return;
5142     first_call_to_drag_data_get = false;
5143    
5144     // get selected source instrument
5145     gig::Instrument* src = NULL;
5146     {
5147 schoenebeck 3806 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
5148 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5149     if (!rows.empty()) {
5150 schoenebeck 3806 Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(rows[0]);
5151 schoenebeck 2994 if (it) {
5152     Gtk::TreeModel::Row row = *it;
5153 schoenebeck 3806 src = row[m_InstrumentsModel.m_col_instr];
5154 schoenebeck 2994 }
5155 schoenebeck 2701 }
5156     }
5157     if (!src) return;
5158    
5159     // pass the source gig::Instrument as pointer
5160     selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&src,
5161     sizeof(src)/*length of data in bytes*/);
5162     }
5163    
5164     void MainWindow::on_instruments_treeview_drop_drag_data_received(
5165     const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
5166     const Gtk::SelectionData& selection_data, guint, guint time)
5167     {
5168     gig::Instrument* src = *((gig::Instrument**) selection_data.get_data());
5169     if (!src || selection_data.get_length() != sizeof(gig::Instrument*))
5170     return;
5171    
5172     gig::Instrument* dst = NULL;
5173     {
5174     Gtk::TreeModel::Path path;
5175 schoenebeck 3806 const bool found = m_TreeViewInstruments.get_path_at_pos(x, y, path);
5176 schoenebeck 2701 if (!found) return;
5177    
5178 schoenebeck 3806 Gtk::TreeModel::iterator iter = m_refInstrumentsTreeModel->get_iter(path);
5179 schoenebeck 2701 if (!iter) return;
5180     Gtk::TreeModel::Row row = *iter;
5181 schoenebeck 3806 dst = row[m_InstrumentsModel.m_col_instr];
5182 schoenebeck 2701 }
5183     if (!dst) return;
5184    
5185     //printf("dragdrop received src=%s dst=%s\n", src->pInfo->Name.c_str(), dst->pInfo->Name.c_str());
5186     src->MoveTo(dst);
5187     __refreshEntireGUI();
5188     select_instrument(src);
5189     }
5190    
5191 persson 1303 // For some reason drag_data_get gets called two times for each
5192     // drag'n'drop (at least when target is an Entry). This work-around
5193     // makes sure the code in drag_data_get and drop_drag_data_received is
5194     // only executed once, as drag_begin only gets called once.
5195     void MainWindow::on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5196     {
5197     first_call_to_drag_data_get = true;
5198     }
5199    
5200 schoenebeck 1225 void MainWindow::on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5201     Gtk::SelectionData& selection_data, guint, guint)
5202     {
5203 persson 1303 if (!first_call_to_drag_data_get) return;
5204     first_call_to_drag_data_get = false;
5205    
5206 schoenebeck 1225 // get selected sample
5207     gig::Sample* sample = NULL;
5208     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5209 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5210     if (!rows.empty()) {
5211     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5212     if (it) {
5213     Gtk::TreeModel::Row row = *it;
5214     sample = row[m_SamplesModel.m_col_sample];
5215     }
5216 schoenebeck 1225 }
5217     // pass the gig::Sample as pointer
5218     selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&sample,
5219     sizeof(sample)/*length of data in bytes*/);
5220     }
5221    
5222     void MainWindow::on_sample_label_drop_drag_data_received(
5223     const Glib::RefPtr<Gdk::DragContext>& context, int, int,
5224     const Gtk::SelectionData& selection_data, guint, guint time)
5225     {
5226     gig::Sample* sample = *((gig::Sample**) selection_data.get_data());
5227    
5228 persson 1265 if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {
5229 persson 1303 std::cout << "Drop received sample \"" <<
5230     sample->pInfo->Name << "\"" << std::endl;
5231     // drop success
5232     context->drop_reply(true, time);
5233    
5234 schoenebeck 1322 //TODO: we should better move most of the following code to DimRegionEdit::set_sample()
5235    
5236     // notify everybody that we're going to alter the region
5237     gig::Region* region = m_RegionChooser.get_region();
5238     region_to_be_changed_signal.emit(region);
5239    
5240 persson 1303 // find the samplechannel dimension
5241     gig::dimension_def_t* stereo_dimension = 0;
5242     for (int i = 0 ; i < region->Dimensions ; i++) {
5243     if (region->pDimensionDefinitions[i].dimension ==
5244     gig::dimension_samplechannel) {
5245     stereo_dimension = &region->pDimensionDefinitions[i];
5246     break;
5247     }
5248 schoenebeck 1225 }
5249 persson 1303 bool channels_changed = false;
5250     if (sample->Channels == 1 && stereo_dimension) {
5251     // remove the samplechannel dimension
5252 schoenebeck 2550 /* commented out, because it makes it impossible building up an instrument from scratch using two separate L/R samples
5253 persson 1303 region->DeleteDimension(stereo_dimension);
5254     channels_changed = true;
5255     region_changed();
5256 schoenebeck 2550 */
5257 persson 1303 }
5258 schoenebeck 2464 dimreg_edit.set_sample(
5259     sample,
5260     is_copy_samples_unity_note_enabled(),
5261     is_copy_samples_fine_tune_enabled(),
5262     is_copy_samples_loop_enabled()
5263     );
5264 persson 1303
5265     if (sample->Channels == 2 && !stereo_dimension) {
5266     // add samplechannel dimension
5267     gig::dimension_def_t dim;
5268     dim.dimension = gig::dimension_samplechannel;
5269     dim.bits = 1;
5270     dim.zones = 2;
5271     region->AddDimension(&dim);
5272     channels_changed = true;
5273     region_changed();
5274     }
5275     if (channels_changed) {
5276     // unmap all samples with wrong number of channels
5277     // TODO: maybe there should be a warning dialog for this
5278     for (int i = 0 ; i < region->DimensionRegions ; i++) {
5279     gig::DimensionRegion* d = region->pDimensionRegions[i];
5280     if (d->pSample && d->pSample->Channels != sample->Channels) {
5281 schoenebeck 1322 gig::Sample* oldref = d->pSample;
5282     d->pSample = NULL;
5283     sample_ref_changed_signal.emit(oldref, NULL);
5284 persson 1303 }
5285     }
5286     }
5287    
5288 schoenebeck 1322 // notify we're done with altering
5289     region_changed_signal.emit(region);
5290    
5291 persson 1460 file_changed();
5292    
5293 persson 1303 return;
5294 schoenebeck 1225 }
5295     // drop failed
5296     context->drop_reply(false, time);
5297     }
5298    
5299     void MainWindow::sample_name_changed(const Gtk::TreeModel::Path& path,
5300     const Gtk::TreeModel::iterator& iter) {
5301     if (!iter) return;
5302     Gtk::TreeModel::Row row = *iter;
5303     Glib::ustring name = row[m_SamplesModel.m_col_name];
5304     gig::Group* group = row[m_SamplesModel.m_col_group];
5305     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
5306 persson 2446 gig::String gigname(gig_from_utf8(name));
5307 schoenebeck 1225 if (group) {
5308 persson 2446 if (group->Name != gigname) {
5309     group->Name = gigname;
5310 persson 1261 printf("group name changed\n");
5311     file_changed();
5312     }
5313 schoenebeck 1225 } else if (sample) {
5314 persson 2446 if (sample->pInfo->Name != gigname) {
5315     sample->pInfo->Name = gigname;
5316 persson 1261 printf("sample name changed\n");
5317     file_changed();
5318     }
5319 schoenebeck 1225 }
5320 schoenebeck 3637 // change name in the sample properties window
5321     if (sampleProps.get_sample() == sample && sample) {
5322     sampleProps.set_sample(sample);
5323     }
5324 schoenebeck 1225 }
5325    
5326 schoenebeck 2604 void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
5327     const Gtk::TreeModel::iterator& iter) {
5328     if (!iter) return;
5329     Gtk::TreeModel::Row row = *iter;
5330     Glib::ustring name = row[m_ScriptsModel.m_col_name];
5331     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
5332     gig::Script* script = row[m_ScriptsModel.m_col_script];
5333     gig::String gigname(gig_from_utf8(name));
5334     if (group) {
5335     if (group->Name != gigname) {
5336     group->Name = gigname;
5337     printf("script group name changed\n");
5338     file_changed();
5339     }
5340     } else if (script) {
5341     if (script->Name != gigname) {
5342     script->Name = gigname;
5343     printf("script name changed\n");
5344     file_changed();
5345     }
5346     }
5347     }
5348    
5349 schoenebeck 2644 void MainWindow::script_double_clicked(const Gtk::TreeModel::Path& path,
5350     Gtk::TreeViewColumn* column)
5351     {
5352     Gtk::TreeModel::iterator iter = m_refScriptsTreeModel->get_iter(path);
5353     if (!iter) return;
5354     Gtk::TreeModel::Row row = *iter;
5355     gig::Script* script = row[m_ScriptsModel.m_col_script];
5356 schoenebeck 3750 editScript(script);
5357 schoenebeck 2644 }
5358    
5359 schoenebeck 1225 void MainWindow::instrument_name_changed(const Gtk::TreeModel::Path& path,
5360     const Gtk::TreeModel::iterator& iter) {
5361     if (!iter) return;
5362     Gtk::TreeModel::Row row = *iter;
5363 schoenebeck 3806 Glib::ustring name = row[m_InstrumentsModel.m_col_name];
5364 persson 2442
5365 schoenebeck 3364 #if !USE_GTKMM_BUILDER
5366 persson 2442 // change name in instrument menu
5367     int index = path[0];
5368     const std::vector<Gtk::Widget*> children = instrument_menu->get_children();
5369     if (index < children.size()) {
5370     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 16) || GTKMM_MAJOR_VERSION > 2
5371     static_cast<Gtk::RadioMenuItem*>(children[index])->set_label(name);
5372     #else
5373     remove_instrument_from_menu(index);
5374     Gtk::RadioMenuItem* item = add_instrument_to_menu(name, index);
5375     item->set_active();
5376     #endif
5377     }
5378 schoenebeck 3364 #endif
5379 persson 2442
5380     // change name in gig
5381 schoenebeck 3806 gig::Instrument* instrument = row[m_InstrumentsModel.m_col_instr];
5382 persson 2446 gig::String gigname(gig_from_utf8(name));
5383     if (instrument && instrument->pInfo->Name != gigname) {
5384     instrument->pInfo->Name = gigname;
5385 persson 2445
5386     // change name in the instrument properties window
5387     if (instrumentProps.get_instrument() == instrument) {
5388     instrumentProps.update_name();
5389     }
5390    
5391 persson 1261 file_changed();
5392     }
5393 schoenebeck 1225 }
5394 schoenebeck 1322
5395 schoenebeck 3340 bool MainWindow::instrument_row_visible(const Gtk::TreeModel::const_iterator& iter) {
5396     if (!iter)
5397     return true;
5398    
5399     Glib::ustring pattern = m_searchText.get_text().lowercase();
5400     trim(pattern);
5401     if (pattern.empty()) return true;
5402    
5403 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
5404 schoenebeck 3364 //HACK: on GTKMM4 development branch const_iterator cannot be easily converted to iterator, probably going to be fixed before final GTKMM4 release though.
5405     Gtk::TreeModel::Row row = **(Gtk::TreeModel::iterator*)(&iter);
5406     #else
5407 schoenebeck 3340 Gtk::TreeModel::Row row = *iter;
5408 schoenebeck 3364 #endif
5409 schoenebeck 3806 Glib::ustring name = row[m_InstrumentsModel.m_col_name];
5410 schoenebeck 3340 name = name.lowercase();
5411    
5412     std::vector<Glib::ustring> tokens = Glib::Regex::split_simple(" ", pattern);
5413     for (int t = 0; t < tokens.size(); ++t)
5414     if (name.find(tokens[t]) == Glib::ustring::npos)
5415     return false;
5416    
5417     return true;
5418     }
5419    
5420 schoenebeck 2548 void MainWindow::on_action_combine_instruments() {
5421     CombineInstrumentsDialog* d = new CombineInstrumentsDialog(*this, file);
5422 schoenebeck 3299
5423     // take over selection from instruments list view for the combine dialog's
5424     // list view as pre-selection
5425     std::set<int> indeces;
5426     {
5427 schoenebeck 3806 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewInstruments.get_selection();
5428 schoenebeck 3299 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5429     for (int r = 0; r < rows.size(); ++r) {
5430 schoenebeck 3806 Gtk::TreeModel::iterator it = m_refInstrumentsTreeModel->get_iter(rows[r]);
5431 schoenebeck 3299 if (it) {
5432     Gtk::TreeModel::Row row = *it;
5433 schoenebeck 3806 int index = row[m_InstrumentsModel.m_col_nr];
5434 schoenebeck 3299 indeces.insert(index);
5435     }
5436     }
5437     }
5438     d->setSelectedInstruments(indeces);
5439    
5440 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5441 schoenebeck 2548 d->show_all();
5442 schoenebeck 3364 #else
5443     d->show();
5444     #endif
5445 schoenebeck 2548 d->run();
5446     if (d->fileWasChanged()) {
5447     // update GUI with new instrument just created
5448     add_instrument(d->newCombinedInstrument());
5449     }
5450     delete d;
5451     }
5452    
5453 schoenebeck 2624 void MainWindow::on_action_view_references() {
5454     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5455 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5456     if (rows.empty()) return;
5457     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5458 schoenebeck 2624 if (!it) return;
5459     Gtk::TreeModel::Row row = *it;
5460     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
5461     if (!sample) return;
5462    
5463     ReferencesView* d = new ReferencesView(*this);
5464     d->setSample(sample);
5465 schoenebeck 2695 d->dimension_region_selected.connect(
5466     sigc::mem_fun(*this, &MainWindow::select_dimension_region)
5467     );
5468 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5469 schoenebeck 2624 d->show_all();
5470 schoenebeck 3364 #else
5471     d->show();
5472     #endif
5473 schoenebeck 2624 d->resize(500, 400);
5474     d->run();
5475     delete d;
5476     }
5477    
5478 schoenebeck 2553 void MainWindow::mergeFiles(const std::vector<std::string>& filenames) {
5479     struct _Source {
5480     std::vector<RIFF::File*> riffs;
5481     std::vector<gig::File*> gigs;
5482    
5483     ~_Source() {
5484     for (int k = 0; k < gigs.size(); ++k) delete gigs[k];
5485     for (int k = 0; k < riffs.size(); ++k) delete riffs[k];
5486     riffs.clear();
5487     gigs.clear();
5488     }
5489     } sources;
5490    
5491     if (filenames.empty())
5492     throw RIFF::Exception(_("No files selected, so nothing done."));
5493    
5494     // first open all input files (to avoid output file corruption)
5495     int i;
5496     try {
5497     for (i = 0; i < filenames.size(); ++i) {
5498     const std::string& filename = filenames[i];
5499     printf("opening file=%s\n", filename.c_str());
5500    
5501     RIFF::File* riff = new RIFF::File(filename);
5502     sources.riffs.push_back(riff);
5503    
5504     gig::File* gig = new gig::File(riff);
5505     sources.gigs.push_back(gig);
5506     }
5507     } catch (RIFF::Exception e) {
5508     throw RIFF::Exception(
5509     _("Error occurred while opening '") +
5510     filenames[i] +
5511     "': " +
5512     e.Message
5513     );
5514     } catch (...) {
5515     throw RIFF::Exception(
5516     _("Unknown exception occurred while opening '") +
5517     filenames[i] + "'"
5518     );
5519     }
5520    
5521     // now merge the opened .gig files to the main .gig file currently being
5522     // open in gigedit
5523     try {
5524     for (i = 0; i < filenames.size(); ++i) {
5525     const std::string& filename = filenames[i];
5526     printf("merging file=%s\n", filename.c_str());
5527     assert(i < sources.gigs.size());
5528    
5529     this->file->AddContentOf(sources.gigs[i]);
5530     }
5531     } catch (RIFF::Exception e) {
5532     throw RIFF::Exception(
5533     _("Error occurred while merging '") +
5534     filenames[i] +
5535     "': " +
5536     e.Message
5537     );
5538     } catch (...) {
5539     throw RIFF::Exception(
5540     _("Unknown exception occurred while merging '") +
5541     filenames[i] + "'"
5542     );
5543     }
5544    
5545 schoenebeck 2683 // Finally save gig file persistently to disk ...
5546     //NOTE: requires that this gig file already has a filename !
5547     {
5548     std::cout << "Saving file\n" << std::flush;
5549     file_structure_to_be_changed_signal.emit(this->file);
5550    
5551     progress_dialog = new ProgressDialog( //FIXME: memory leak!
5552     _("Saving") + Glib::ustring(" '") +
5553     Glib::filename_display_basename(this->filename) + "' ...",
5554     *this
5555     );
5556 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5557 schoenebeck 2683 progress_dialog->show_all();
5558 schoenebeck 3364 #else
5559     progress_dialog->show();
5560     #endif
5561 schoenebeck 2683 saver = new Saver(this->file); //FIXME: memory leak!
5562     saver->signal_progress().connect(
5563     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
5564     saver->signal_finished().connect(
5565     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
5566     saver->signal_error().connect(
5567     sigc::mem_fun(*this, &MainWindow::on_saver_error));
5568     saver->launch();
5569     }
5570 schoenebeck 2553 }
5571    
5572     void MainWindow::on_action_merge_files() {
5573     if (this->file->GetFileName().empty()) {
5574     Glib::ustring txt = _(
5575     "You seem to have a new .gig file open that has not been saved "
5576     "yet. You must save it somewhere before starting to merge it with "
5577     "other .gig files though, because during the merge operation the "
5578     "other files' sample data must be written on file level to the "
5579     "target .gig file."
5580     );
5581     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
5582     msg.run();
5583     return;
5584     }
5585    
5586     Gtk::FileChooserDialog dialog(*this, _("Merge .gig files"));
5587 schoenebeck 3364 #if HAS_GTKMM_STOCK
5588 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
5589 schoenebeck 3364 #else
5590     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
5591     #endif
5592 schoenebeck 2553 dialog.add_button(_("Merge"), Gtk::RESPONSE_OK);
5593     dialog.set_default_response(Gtk::RESPONSE_CANCEL);
5594     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
5595     Gtk::FileFilter filter;
5596     filter.add_pattern("*.gig");
5597     #else
5598     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
5599     filter->add_pattern("*.gig");
5600     #endif
5601     dialog.set_filter(filter);
5602     if (current_gig_dir != "") {
5603     dialog.set_current_folder(current_gig_dir);
5604     }
5605     dialog.set_select_multiple(true);
5606    
5607     // show warning in the file picker dialog
5608 schoenebeck 3364 HBox descriptionArea;
5609 schoenebeck 2553 descriptionArea.set_spacing(15);
5610 persson 2845 Gtk::Image warningIcon;
5611     warningIcon.set_from_icon_name("dialog-warning",
5612     Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
5613 schoenebeck 2553 descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
5614     #if GTKMM_MAJOR_VERSION < 3
5615     view::WrapLabel description;
5616     #else
5617     Gtk::Label description;
5618     description.set_line_wrap();
5619     #endif
5620     description.set_markup(_(
5621     "\nSelect at least one .gig file that shall be merged to the .gig file "
5622     "currently being open in gigedit.\n\n"
5623     "<b>Please Note:</b> Merging with other files will modify your "
5624     "currently open .gig file on file level! And be aware that the current "
5625     "merge algorithm does not detect duplicate samples yet. So if you are "
5626     "merging files which are using equivalent sample data, those "
5627     "equivalent samples will currently be treated as separate samples and "
5628     "will accordingly be stored separately in the target .gig file!"
5629     ));
5630     descriptionArea.pack_start(description);
5631 schoenebeck 3364 #if USE_GTKMM_BOX
5632     # warning No description area implemented for dialog on GTKMM 3
5633     #else
5634 schoenebeck 2553 dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
5635 schoenebeck 3364 #endif
5636     #if HAS_GTKMM_SHOW_ALL_CHILDREN
5637 schoenebeck 2553 descriptionArea.show_all();
5638 schoenebeck 3364 #else
5639     descriptionArea.show();
5640     #endif
5641 schoenebeck 2553
5642     if (dialog.run() == Gtk::RESPONSE_OK) {
5643 persson 3477 dialog.hide();
5644 persson 3472 #ifdef GLIB_THREADS
5645 persson 2841 printf("on_action_merge_files self=%p\n",
5646     static_cast<void*>(Glib::Threads::Thread::self()));
5647 persson 3472 #else
5648     std::cout << "on_action_merge_files self=" <<
5649     std::this_thread::get_id() << "\n";
5650     #endif
5651 schoenebeck 2553 std::vector<std::string> filenames = dialog.get_filenames();
5652    
5653     // merge the selected files to the currently open .gig file
5654     try {
5655     mergeFiles(filenames);
5656     } catch (RIFF::Exception e) {
5657     Gtk::MessageDialog msg(*this, e.Message, false, Gtk::MESSAGE_ERROR);
5658     msg.run();
5659     }
5660    
5661     // update GUI
5662 schoenebeck 2772 __refreshEntireGUI();
5663 schoenebeck 2553 }
5664     }
5665    
5666 schoenebeck 1411 void MainWindow::set_file_is_shared(bool b) {
5667     this->file_is_shared = b;
5668    
5669     if (file_is_shared) {
5670     m_AttachedStateLabel.set_label(_("live-mode"));
5671     m_AttachedStateImage.set(
5672     Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
5673     );
5674     } else {
5675     m_AttachedStateLabel.set_label(_("stand-alone"));
5676     m_AttachedStateImage.set(
5677     Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
5678     );
5679     }
5680 schoenebeck 2689
5681     {
5682 schoenebeck 3364 #if USE_GTKMM_BUILDER
5683     m_actionToggleSyncSamplerSelection->property_enabled() = b;
5684     #else
5685 schoenebeck 2689 Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
5686     uiManager->get_widget("/MenuBar/MenuSettings/SyncSamplerInstrumentSelection"));
5687     if (item) item->set_sensitive(b);
5688 schoenebeck 3364 #endif
5689 schoenebeck 2689 }
5690 schoenebeck 1411 }
5691    
5692 schoenebeck 2621 void MainWindow::on_sample_ref_count_incremented(gig::Sample* sample, int offset) {
5693     if (!sample) return;
5694     sample_ref_count[sample] += offset;
5695     const int refcount = sample_ref_count[sample];
5696    
5697     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewSamples.get_model();
5698     for (int g = 0; g < model->children().size(); ++g) {
5699     Gtk::TreeModel::Row rowGroup = model->children()[g];
5700     for (int s = 0; s < rowGroup.children().size(); ++s) {
5701     Gtk::TreeModel::Row rowSample = rowGroup.children()[s];
5702     if (rowSample[m_SamplesModel.m_col_sample] != sample) continue;
5703     rowSample[m_SamplesModel.m_col_refcount] = ToString(refcount) + " " + _("Refs.");
5704 schoenebeck 2625 rowSample[m_SamplesModel.m_color] = refcount ? "black" : "red";
5705 schoenebeck 2621 }
5706     }
5707     }
5708    
5709     void MainWindow::on_sample_ref_changed(gig::Sample* oldSample, gig::Sample* newSample) {
5710     on_sample_ref_count_incremented(oldSample, -1);
5711     on_sample_ref_count_incremented(newSample, +1);
5712     }
5713    
5714     void MainWindow::on_samples_to_be_removed(std::list<gig::Sample*> samples) {
5715     // just in case a new sample is added later with exactly the same memory
5716     // address, which would lead to incorrect refcount if not deleted here
5717     for (std::list<gig::Sample*>::const_iterator it = samples.begin();
5718 schoenebeck 2666 it != samples.end(); ++it)
5719 schoenebeck 2621 {
5720     sample_ref_count.erase(*it);
5721     }
5722     }
5723    
5724 schoenebeck 2625 void MainWindow::show_samples_tab() {
5725     m_TreeViewNotebook.set_current_page(0);
5726     }
5727    
5728     void MainWindow::show_intruments_tab() {
5729     m_TreeViewNotebook.set_current_page(1);
5730     }
5731    
5732     void MainWindow::show_scripts_tab() {
5733     m_TreeViewNotebook.set_current_page(2);
5734     }
5735    
5736 schoenebeck 3339 void MainWindow::select_instrument_by_dir(int dir) {
5737     if (!file) return;
5738     gig::Instrument* pInstrument = get_instrument();
5739     if (!pInstrument) {
5740     select_instrument( file->GetInstrument(0) );
5741     return;
5742     }
5743     for (int i = 0; file->GetInstrument(i); ++i) {
5744     if (file->GetInstrument(i) == pInstrument) {
5745     select_instrument( file->GetInstrument(i + dir) );
5746     return;
5747     }
5748     }
5749     }
5750    
5751     void MainWindow::select_prev_instrument() {
5752     select_instrument_by_dir(-1);
5753     }
5754    
5755     void MainWindow::select_next_instrument() {
5756     select_instrument_by_dir(1);
5757     }
5758    
5759 schoenebeck 3123 void MainWindow::select_prev_region() {
5760     m_RegionChooser.select_prev_region();
5761     }
5762    
5763     void MainWindow::select_next_region() {
5764     m_RegionChooser.select_next_region();
5765     }
5766    
5767     void MainWindow::select_next_dim_rgn_zone() {
5768     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5769     m_DimRegionChooser.select_next_dimzone();
5770     }
5771    
5772     void MainWindow::select_prev_dim_rgn_zone() {
5773     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5774     m_DimRegionChooser.select_prev_dimzone();
5775     }
5776    
5777 schoenebeck 3134 void MainWindow::select_add_next_dim_rgn_zone() {
5778     m_DimRegionChooser.select_next_dimzone(true);
5779     }
5780    
5781     void MainWindow::select_add_prev_dim_rgn_zone() {
5782     m_DimRegionChooser.select_prev_dimzone(true);
5783     }
5784    
5785 schoenebeck 3123 void MainWindow::select_prev_dimension() {
5786     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5787     m_DimRegionChooser.select_prev_dimension();
5788     }
5789    
5790     void MainWindow::select_next_dimension() {
5791     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5792     m_DimRegionChooser.select_next_dimension();
5793     }
5794    
5795 schoenebeck 3144 #define CLIPBOARD_DIMENSIONREGION_TARGET \
5796     ("libgig.DimensionRegion." + m_serializationArchive.rawDataFormat())
5797    
5798     void MainWindow::copy_selected_dimrgn() {
5799     gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5800     if (!pDimRgn) {
5801     updateClipboardPasteAvailable();
5802     updateClipboardCopyAvailable();
5803     return;
5804     }
5805    
5806     std::vector<Gtk::TargetEntry> targets;
5807     targets.push_back( Gtk::TargetEntry(CLIPBOARD_DIMENSIONREGION_TARGET) );
5808    
5809     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5810     clipboard->set(
5811     targets,
5812     sigc::mem_fun(*this, &MainWindow::on_clipboard_get),
5813     sigc::mem_fun(*this, &MainWindow::on_clipboard_clear)
5814     );
5815    
5816     m_serializationArchive.serialize(pDimRgn);
5817    
5818     updateClipboardPasteAvailable();
5819     }
5820    
5821     void MainWindow::paste_copied_dimrgn() {
5822     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5823     clipboard->request_contents(
5824     CLIPBOARD_DIMENSIONREGION_TARGET,
5825     sigc::mem_fun(*this, &MainWindow::on_clipboard_received)
5826     );
5827     updateClipboardPasteAvailable();
5828     }
5829    
5830 schoenebeck 3151 void MainWindow::adjust_clipboard_content() {
5831 schoenebeck 3155 MacroEditor* editor = new MacroEditor();
5832 schoenebeck 3162 editor->setMacro(&m_serializationArchive, true);
5833 schoenebeck 3151 editor->show();
5834     }
5835    
5836 schoenebeck 3144 void MainWindow::updateClipboardPasteAvailable() {
5837     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5838     clipboard->request_targets(
5839     sigc::mem_fun(*this, &MainWindow::on_clipboard_received_targets)
5840     );
5841     }
5842    
5843     void MainWindow::updateClipboardCopyAvailable() {
5844     bool bDimensionRegionCopyIsPossible = m_DimRegionChooser.get_main_dimregion();
5845 schoenebeck 3364 #if USE_GTKMM_BUILDER
5846     m_actionCopyDimRgn->property_enabled() = bDimensionRegionCopyIsPossible;
5847     #else
5848 schoenebeck 3144 static_cast<Gtk::MenuItem*>(
5849     uiManager->get_widget("/MenuBar/MenuEdit/CopyDimRgn")
5850     )->set_sensitive(bDimensionRegionCopyIsPossible);
5851 schoenebeck 3364 #endif
5852 schoenebeck 3144 }
5853    
5854 schoenebeck 3364 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && (GTKMM_MINOR_VERSION > 91 || (GTKMM_MINOR_VERSION == 91 && GTKMM_MICRO_VERSION >= 2))) // GTKMM >= 3.91.2
5855     void MainWindow::on_clipboard_owner_change(Gdk::EventOwnerChange& event) {
5856     #else
5857 schoenebeck 3144 void MainWindow::on_clipboard_owner_change(GdkEventOwnerChange* event) {
5858 schoenebeck 3364 #endif
5859 schoenebeck 3144 updateClipboardPasteAvailable();
5860     }
5861    
5862     void MainWindow::on_clipboard_get(Gtk::SelectionData& selection_data, guint /*info*/) {
5863     const std::string target = selection_data.get_target();
5864     if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5865     selection_data.set(
5866     CLIPBOARD_DIMENSIONREGION_TARGET, 8 /* "format": probably unused*/,
5867     &m_serializationArchive.rawData()[0],
5868     m_serializationArchive.rawData().size()
5869     );
5870     } else {
5871     std::cerr << "Clipboard: content for unknown target '" << target << "' requested\n";
5872     }
5873     }
5874    
5875     void MainWindow::on_clipboard_clear() {
5876     m_serializationArchive.clear();
5877     updateClipboardPasteAvailable();
5878     updateClipboardCopyAvailable();
5879     }
5880    
5881 schoenebeck 3157 //NOTE: Might throw exception !!!
5882     void MainWindow::applyMacro(Serialization::Archive& macro) {
5883     gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5884     if (!pDimRgn) return;
5885    
5886     for (std::set<gig::DimensionRegion*>::iterator itDimReg = dimreg_edit.dimregs.begin();
5887     itDimReg != dimreg_edit.dimregs.end(); ++itDimReg)
5888     {
5889     gig::DimensionRegion* pDimRgn = *itDimReg;
5890 schoenebeck 3177 DimRegionChangeGuard(this, pDimRgn);
5891 schoenebeck 3160 macro.deserialize(pDimRgn);
5892 schoenebeck 3157 }
5893     //region_changed()
5894     file_changed();
5895     dimreg_changed();
5896     }
5897    
5898 schoenebeck 3144 void MainWindow::on_clipboard_received(const Gtk::SelectionData& selection_data) {
5899     const std::string target = selection_data.get_target();
5900     if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5901     Glib::ustring errorText;
5902     try {
5903     m_serializationArchive.decode(
5904     selection_data.get_data(), selection_data.get_length()
5905     );
5906 schoenebeck 3157 applyMacro(m_serializationArchive);
5907 schoenebeck 3144 } catch (Serialization::Exception e) {
5908     errorText = e.Message;
5909     } catch (...) {
5910 schoenebeck 3157 errorText = _("Unknown exception while pasting DimensionRegion");
5911 schoenebeck 3144 }
5912     if (!errorText.empty()) {
5913     Glib::ustring txt = _("Pasting DimensionRegion failed:\n") + errorText;
5914     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
5915     msg.run();
5916     }
5917     }
5918     }
5919    
5920     void MainWindow::on_clipboard_received_targets(const std::vector<Glib::ustring>& targets) {
5921     const bool bDimensionRegionPasteIsPossible =
5922     std::find(targets.begin(), targets.end(),
5923     CLIPBOARD_DIMENSIONREGION_TARGET) != targets.end();
5924    
5925 schoenebeck 3364 #if USE_GTKMM_BUILDER
5926     m_actionPasteDimRgn->property_enabled() = bDimensionRegionPasteIsPossible;
5927     m_actionAdjustClipboard->property_enabled() = bDimensionRegionPasteIsPossible;
5928     #else
5929 schoenebeck 3144 static_cast<Gtk::MenuItem*>(
5930     uiManager->get_widget("/MenuBar/MenuEdit/PasteDimRgn")
5931     )->set_sensitive(bDimensionRegionPasteIsPossible);
5932 schoenebeck 3151
5933     static_cast<Gtk::MenuItem*>(
5934     uiManager->get_widget("/MenuBar/MenuEdit/AdjustClipboard")
5935     )->set_sensitive(bDimensionRegionPasteIsPossible);
5936 schoenebeck 3364 #endif
5937 schoenebeck 3144 }
5938    
5939 schoenebeck 1339 sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
5940 schoenebeck 1322 return file_structure_to_be_changed_signal;
5941     }
5942    
5943 schoenebeck 1339 sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
5944 schoenebeck 1322 return file_structure_changed_signal;
5945     }
5946    
5947 schoenebeck 1339 sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
5948 schoenebeck 1322 return samples_to_be_removed_signal;
5949     }
5950    
5951 schoenebeck 1339 sigc::signal<void>& MainWindow::signal_samples_removed() {
5952 schoenebeck 1322 return samples_removed_signal;
5953     }
5954    
5955 schoenebeck 1339 sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
5956 schoenebeck 1322 return region_to_be_changed_signal;
5957     }
5958    
5959 schoenebeck 1339 sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
5960 schoenebeck 1322 return region_changed_signal;
5961     }
5962    
5963 schoenebeck 1853 sigc::signal<void, gig::Sample*>& MainWindow::signal_sample_changed() {
5964     return sample_changed_signal;
5965     }
5966    
5967 schoenebeck 1339 sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
5968 schoenebeck 1322 return sample_ref_changed_signal;
5969     }
5970    
5971 schoenebeck 1339 sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
5972 schoenebeck 1322 return dimreg_to_be_changed_signal;
5973     }
5974    
5975 schoenebeck 1339 sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
5976 schoenebeck 1322 return dimreg_changed_signal;
5977     }
5978 schoenebeck 1654
5979     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
5980     return note_on_signal;
5981     }
5982    
5983     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
5984     return note_off_signal;
5985     }
5986 schoenebeck 1660
5987     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
5988     return m_RegionChooser.signal_keyboard_key_hit();
5989     }
5990    
5991     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
5992     return m_RegionChooser.signal_keyboard_key_released();
5993     }
5994 schoenebeck 2689
5995     sigc::signal<void, gig::Instrument*>& MainWindow::signal_switch_sampler_instrument() {
5996     return switch_sampler_instrument_signal;
5997     }

  ViewVC Help
Powered by ViewVC