/[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 3800 - (hide annotations) (download)
Sun Jul 26 13:27:16 2020 UTC (3 years, 8 months ago) by schoenebeck
File size: 231582 byte(s)
* Fixed instrument list's 'script count' column not being updated after
  having duplicated an instrument.

* Bumped version (1.1.1.svn22).

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 persson 2442 m_TreeView.get_selection()->signal_changed().connect(
110 schoenebeck 1225 sigc::mem_fun(*this, &MainWindow::on_sel_change));
111    
112     // m_TreeView.set_reorderable();
113    
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     m_TreeView.signal_button_press_event().connect(
116     sigc::mem_fun(*this, &MainWindow::on_button_release));
117     #else
118 schoenebeck 1225 m_TreeView.signal_button_press_event().connect_notify(
119     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     m_ScrolledWindow.add(m_TreeView);
124     // 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     m_refTreeModel = Gtk::ListStore::create(m_Columns);
1387 schoenebeck 3340 m_refTreeModelFilter = Gtk::TreeModelFilter::create(m_refTreeModel);
1388     m_refTreeModelFilter->set_visible_func(
1389     sigc::mem_fun(*this, &MainWindow::instrument_row_visible)
1390     );
1391     m_TreeView.set_model(m_refTreeModelFilter);
1392    
1393 schoenebeck 2994 m_TreeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1394 schoenebeck 3418 m_TreeView.set_has_tooltip(true);
1395     m_TreeView.signal_query_tooltip().connect(
1396     sigc::mem_fun(*this, &MainWindow::onQueryTreeViewTooltip)
1397     );
1398 persson 2442 instrument_name_connection = m_refTreeModel->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 2994 m_TreeView.append_column(_("Nr"), m_Columns.m_col_nr);
1404     m_TreeView.append_column_editable(_("Instrument"), m_Columns.m_col_name);
1405 schoenebeck 3197 m_TreeView.append_column(_("Scripts"), m_Columns.m_col_scripts);
1406 schoenebeck 2994 m_TreeView.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     m_TreeView.drag_source_set(drag_target_instrument);
1414     m_TreeView.drag_dest_set(drag_target_instrument);
1415     m_TreeView.signal_drag_begin().connect(
1416     sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_begin)
1417     );
1418     m_TreeView.signal_drag_data_get().connect(
1419     sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_data_get)
1420     );
1421     m_TreeView.signal_drag_data_received().connect(
1422     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 persson 3461 sigc::mem_fun(*m_refTreeModelFilter.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 persson 1533 gig::Instrument* instrument = 0;
1868 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
1869     if (rows.empty()) return NULL;
1870 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.
1871     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
1872 schoenebeck 1225 if (it) {
1873     Gtk::TreeModel::Row row = *it;
1874 persson 1533 instrument = row[m_Columns.m_col_instr];
1875     }
1876     return instrument;
1877     }
1878 schoenebeck 1225
1879 persson 1533 void MainWindow::add_region_to_dimregs(gig::Region* region, bool stereo, bool all_dimregs)
1880     {
1881     if (all_dimregs) {
1882     for (int i = 0 ; i < region->DimensionRegions ; i++) {
1883     if (region->pDimensionRegions[i]) {
1884     dimreg_edit.dimregs.insert(region->pDimensionRegions[i]);
1885     }
1886     }
1887 schoenebeck 1225 } else {
1888 persson 1533 m_DimRegionChooser.get_dimregions(region, stereo, dimreg_edit.dimregs);
1889 schoenebeck 1225 }
1890     }
1891    
1892 persson 1533 void MainWindow::update_dimregs()
1893     {
1894     dimreg_edit.dimregs.clear();
1895     bool all_regions = dimreg_all_regions.get_active();
1896     bool stereo = dimreg_stereo.get_active();
1897     bool all_dimregs = dimreg_all_dimregs.get_active();
1898    
1899     if (all_regions) {
1900     gig::Instrument* instrument = get_instrument();
1901     if (instrument) {
1902     for (gig::Region* region = instrument->GetFirstRegion() ;
1903     region ;
1904     region = instrument->GetNextRegion()) {
1905     add_region_to_dimregs(region, stereo, all_dimregs);
1906     }
1907     }
1908     } else {
1909     gig::Region* region = m_RegionChooser.get_region();
1910     if (region) {
1911     add_region_to_dimregs(region, stereo, all_dimregs);
1912     }
1913     }
1914 schoenebeck 3089
1915 schoenebeck 3148 m_RegionChooser.setModifyAllRegions(all_regions);
1916 schoenebeck 3089 m_DimRegionChooser.setModifyAllRegions(all_regions);
1917     m_DimRegionChooser.setModifyAllDimensionRegions(all_dimregs);
1918     m_DimRegionChooser.setModifyBothChannels(stereo);
1919 schoenebeck 3144
1920     updateClipboardCopyAvailable();
1921 persson 1533 }
1922    
1923     void MainWindow::dimreg_all_dimregs_toggled()
1924     {
1925     dimreg_stereo.set_sensitive(!dimreg_all_dimregs.get_active());
1926     update_dimregs();
1927     }
1928    
1929     void MainWindow::dimreg_changed()
1930     {
1931     update_dimregs();
1932 schoenebeck 2626 dimreg_edit.set_dim_region(m_DimRegionChooser.get_main_dimregion());
1933 persson 1533 }
1934    
1935     void MainWindow::on_sel_change()
1936     {
1937 schoenebeck 3364 #if !USE_GTKMM_BUILDER
1938 persson 2442 // select item in instrument menu
1939 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
1940     if (!rows.empty()) {
1941     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
1942     if (it) {
1943     Gtk::TreePath path(it);
1944     int index = path[0];
1945     const std::vector<Gtk::Widget*> children =
1946     instrument_menu->get_children();
1947     static_cast<Gtk::RadioMenuItem*>(children[index])->set_active();
1948     }
1949 persson 2442 }
1950 schoenebeck 3364 #endif
1951 persson 2442
1952 schoenebeck 3339 updateScriptListOfMenu();
1953    
1954 schoenebeck 3737 gig::Instrument* instr = get_instrument();
1955 schoenebeck 2689
1956 schoenebeck 3737 m_RegionChooser.set_instrument(instr);
1957     dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
1958    
1959 schoenebeck 2689 if (Settings::singleton()->syncSamplerInstrumentSelection) {
1960     switch_sampler_instrument_signal.emit(get_instrument());
1961     }
1962 persson 1533 }
1963    
1964 persson 3470
1965     LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
1966 persson 3472 filename(filename), gig(gig),
1967     #ifdef GLIB_THREADS
1968     thread(0),
1969     #endif
1970     progress(0.f)
1971 persson 3470 {
1972     }
1973    
1974 schoenebeck 1225 void loader_progress_callback(gig::progress_t* progress)
1975     {
1976 persson 3470 LoaderSaverBase* loader = static_cast<LoaderSaverBase*>(progress->custom);
1977 schoenebeck 1225 loader->progress_callback(progress->factor);
1978     }
1979    
1980 persson 3470 void LoaderSaverBase::progress_callback(float fraction)
1981 schoenebeck 1225 {
1982     {
1983 persson 3472 #ifdef GLIB_THREADS
1984 persson 2325 Glib::Threads::Mutex::Lock lock(progressMutex);
1985 persson 3472 #else
1986     std::lock_guard<std::mutex> lock(progressMutex);
1987     #endif
1988 schoenebeck 1225 progress = fraction;
1989     }
1990     progress_dispatcher();
1991     }
1992    
1993 persson 3021 #if defined(WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
1994     // make sure stack is 16-byte aligned for SSE instructions
1995     __attribute__((force_align_arg_pointer))
1996     #endif
1997 persson 3470 void LoaderSaverBase::thread_function()
1998 schoenebeck 1225 {
1999 persson 3472 #ifdef GLIB_THREADS
2000 persson 2841 printf("thread_function self=%p\n",
2001     static_cast<void*>(Glib::Threads::Thread::self()));
2002 persson 3472 #else
2003     std::cout << "thread_function self=" << std::this_thread::get_id() << "\n";
2004     #endif
2005 schoenebeck 2683 printf("Start %s\n", filename.c_str());
2006     try {
2007     gig::progress_t progress;
2008     progress.callback = loader_progress_callback;
2009     progress.custom = this;
2010 schoenebeck 1225
2011 persson 3470 thread_function_sub(progress);
2012 schoenebeck 2683 printf("End\n");
2013     finished_dispatcher();
2014     } catch (RIFF::Exception e) {
2015     error_message = e.Message;
2016     error_dispatcher.emit();
2017     } catch (...) {
2018     error_message = _("Unknown exception occurred");
2019     error_dispatcher.emit();
2020     }
2021 schoenebeck 1225 }
2022    
2023 persson 3470 void LoaderSaverBase::launch()
2024 schoenebeck 1225 {
2025 persson 3472 #ifdef GLIB_THREADS
2026 persson 2332 #ifdef OLD_THREADS
2027 persson 3470 thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
2028 persson 2332 #else
2029 persson 3470 thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
2030 persson 2332 #endif
2031 persson 2841 printf("launch thread=%p\n", static_cast<void*>(thread));
2032 persson 3472 #else
2033     thread = std::thread([this](){ thread_function(); });
2034     std::cout << "launch thread=" << thread.get_id() << "\n";
2035     #endif
2036 schoenebeck 1225 }
2037    
2038 persson 3470 float LoaderSaverBase::get_progress()
2039 schoenebeck 1225 {
2040 persson 3472 #ifdef GLIB_THREADS
2041 persson 3470 Glib::Threads::Mutex::Lock lock(progressMutex);
2042 persson 3472 #else
2043     std::lock_guard<std::mutex> lock(progressMutex);
2044     #endif
2045 persson 3470 return progress;
2046 schoenebeck 1225 }
2047    
2048 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_progress()
2049 schoenebeck 1225 {
2050     return progress_dispatcher;
2051     }
2052    
2053 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_finished()
2054 schoenebeck 1225 {
2055     return finished_dispatcher;
2056     }
2057    
2058 persson 3470 Glib::Dispatcher& LoaderSaverBase::signal_error()
2059 schoenebeck 2683 {
2060     return error_dispatcher;
2061     }
2062    
2063 persson 3471 void LoaderSaverBase::join() {
2064 persson 3472 #ifdef GLIB_THREADS
2065 persson 3471 thread->join();
2066 persson 3472 #else
2067     thread.join();
2068     #endif
2069 persson 3471 }
2070 schoenebeck 2683
2071 persson 3471
2072 persson 3470 Loader::Loader(const char* filename) :
2073     LoaderSaverBase(filename, 0)
2074 schoenebeck 2683 {
2075     }
2076    
2077 persson 3470 void Loader::thread_function_sub(gig::progress_t& progress)
2078 schoenebeck 2683 {
2079 persson 3470 RIFF::File* riff = new RIFF::File(filename);
2080     gig = new gig::File(riff);
2081 schoenebeck 2683
2082 persson 3470 gig->GetInstrument(0, &progress);
2083 schoenebeck 2683 }
2084    
2085 persson 3470
2086     Saver::Saver(gig::File* file, Glib::ustring filename) :
2087     LoaderSaverBase(filename, file)
2088 schoenebeck 2683 {
2089     }
2090    
2091 persson 3470 void Saver::thread_function_sub(gig::progress_t& progress)
2092 schoenebeck 2683 {
2093 persson 3470 // if no filename was provided, that means "save", if filename was provided means "save as"
2094     if (filename.empty()) {
2095     if (!Settings::singleton()->saveWithTemporaryFile) {
2096     // save directly over the existing .gig file
2097     // (requires less disk space than solution below
2098     // but may be slower)
2099     gig->Save(&progress);
2100     } else {
2101     // save the file as separate temporary file first,
2102     // then move the saved file over the old file
2103     // (may result in performance speedup during save)
2104     gig::String tmpname = filename + ".TMP";
2105     gig->Save(tmpname, &progress);
2106     #if defined(WIN32)
2107     if (!DeleteFile(filename.c_str())) {
2108     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file).");
2109     }
2110     #else // POSIX ...
2111     if (unlink(filename.c_str())) {
2112     throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file): " + gig::String(strerror(errno)));
2113     }
2114     #endif
2115     if (rename(tmpname.c_str(), filename.c_str())) {
2116     #if defined(WIN32)
2117     throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file).");
2118 schoenebeck 2683 #else
2119 persson 3470 throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file): " + gig::String(strerror(errno)));
2120 schoenebeck 2683 #endif
2121 persson 3470 }
2122     }
2123     } else {
2124     gig->Save(filename, &progress);
2125 schoenebeck 2683 }
2126     }
2127    
2128    
2129     ProgressDialog::ProgressDialog(const Glib::ustring& title, Gtk::Window& parent)
2130 schoenebeck 1225 : Gtk::Dialog(title, parent, true)
2131     {
2132 schoenebeck 3364 #if USE_GTKMM_BOX
2133     get_content_area()->pack_start(progressBar);
2134     #else
2135 schoenebeck 1225 get_vbox()->pack_start(progressBar);
2136 schoenebeck 3364 #endif
2137     #if HAS_GTKMM_SHOW_ALL_CHILDREN
2138 schoenebeck 1225 show_all_children();
2139 schoenebeck 3364 #endif
2140 schoenebeck 2683 resize(600,50);
2141 schoenebeck 1225 }
2142    
2143     // Clear all GUI elements / controls. This method is typically called
2144     // before a new .gig file is to be created or to be loaded.
2145     void MainWindow::__clear() {
2146     // forget all samples that ought to be imported
2147     m_SampleImportQueue.clear();
2148     // clear the samples and instruments tree views
2149     m_refTreeModel->clear();
2150     m_refSamplesTreeModel->clear();
2151 schoenebeck 2615 m_refScriptsTreeModel->clear();
2152 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2153 persson 2442 // remove all entries from "Instrument" menu
2154     while (!instrument_menu->get_children().empty()) {
2155     remove_instrument_from_menu(0);
2156     }
2157 schoenebeck 3364 #endif
2158 schoenebeck 1225 // free libgig's gig::File instance
2159 schoenebeck 1382 if (file && !file_is_shared) delete file;
2160     file = NULL;
2161 schoenebeck 1411 set_file_is_shared(false);
2162 schoenebeck 1225 }
2163    
2164 schoenebeck 2553 void MainWindow::__refreshEntireGUI() {
2165     // clear the samples and instruments tree views
2166     m_refTreeModel->clear();
2167     m_refSamplesTreeModel->clear();
2168 schoenebeck 2615 m_refScriptsTreeModel->clear();
2169 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2170 schoenebeck 2553 // remove all entries from "Instrument" menu
2171     while (!instrument_menu->get_children().empty()) {
2172     remove_instrument_from_menu(0);
2173     }
2174 schoenebeck 3364 #endif
2175 schoenebeck 2553
2176     if (!this->file) return;
2177    
2178     load_gig(
2179     this->file, this->file->pInfo->Name.c_str(), this->file_is_shared
2180     );
2181     }
2182    
2183 schoenebeck 1225 void MainWindow::on_action_file_new()
2184     {
2185 schoenebeck 1382 if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
2186 persson 1261
2187 schoenebeck 1382 if (file_is_shared && !leaving_shared_mode_dialog()) return;
2188    
2189 schoenebeck 1225 // clear all GUI elements
2190     __clear();
2191     // create a new .gig file (virtually yet)
2192     gig::File* pFile = new gig::File;
2193     // already add one new instrument by default
2194     gig::Instrument* pInstrument = pFile->AddInstrument();
2195 persson 2446 pInstrument->pInfo->Name = gig_from_utf8(_("Unnamed Instrument"));
2196 schoenebeck 1225 // update GUI with that new gig::File
2197 persson 1261 load_gig(pFile, 0 /*no file name yet*/);
2198 schoenebeck 1225 }
2199    
2200 persson 1261 bool MainWindow::close_confirmation_dialog()
2201     {
2202     gchar* msg = g_strdup_printf(_("Save changes to \"%s\" before closing?"),
2203     Glib::filename_display_basename(filename).c_str());
2204     Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
2205     g_free(msg);
2206     dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));
2207     dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);
2208 schoenebeck 3364 #if HAS_GTKMM_STOCK
2209 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2210     dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);
2211 schoenebeck 3364 #else
2212     dialog.add_button(_("_OK"), Gtk::RESPONSE_OK);
2213     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2214     #endif
2215 persson 1261 dialog.set_default_response(Gtk::RESPONSE_YES);
2216     int response = dialog.run();
2217 persson 1303 dialog.hide();
2218 schoenebeck 2683
2219 schoenebeck 2694 // user decided to exit app without saving
2220     if (response == Gtk::RESPONSE_NO) return true;
2221    
2222     // user cancelled dialog, thus don't close app
2223     if (response == Gtk::RESPONSE_CANCEL) return false;
2224    
2225 schoenebeck 2683 // TODO: the following return valid is disabled and hard coded instead for
2226     // now, due to the fact that saving with progress bar is now implemented
2227     // asynchronously, as a result the app does not close automatically anymore
2228     // after saving the file has completed
2229     //
2230     // if (response == Gtk::RESPONSE_YES) return file_save();
2231     // return response != Gtk::RESPONSE_CANCEL;
2232     //
2233     if (response == Gtk::RESPONSE_YES) file_save();
2234     return false; // always prevent closing the app for now (see comment above)
2235 persson 1261 }
2236    
2237 schoenebeck 1382 bool MainWindow::leaving_shared_mode_dialog() {
2238     Glib::ustring msg = _("Detach from sampler and proceed working stand-alone?");
2239     Gtk::MessageDialog dialog(*this, msg, false, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_NONE);
2240     dialog.set_secondary_text(
2241     _("If you proceed to work on another instrument file, it won't be "
2242     "used by the sampler until you tell the sampler explicitly to "
2243 persson 2151 "load it."));
2244 schoenebeck 1382 dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
2245 schoenebeck 3364 #if HAS_GTKMM_STOCK
2246 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2247 schoenebeck 3364 #else
2248     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2249     #endif
2250 schoenebeck 1382 dialog.set_default_response(Gtk::RESPONSE_CANCEL);
2251     int response = dialog.run();
2252     dialog.hide();
2253     return response == Gtk::RESPONSE_YES;
2254     }
2255    
2256 schoenebeck 1225 void MainWindow::on_action_file_open()
2257     {
2258 schoenebeck 1382 if (!file_is_shared && file_is_changed && !close_confirmation_dialog()) return;
2259 persson 1261
2260 schoenebeck 1382 if (file_is_shared && !leaving_shared_mode_dialog()) return;
2261    
2262 schoenebeck 1225 Gtk::FileChooserDialog dialog(*this, _("Open file"));
2263 schoenebeck 3364 #if HAS_GTKMM_STOCK
2264 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2265     dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
2266 schoenebeck 3364 #else
2267     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2268     dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
2269     #endif
2270 persson 1261 dialog.set_default_response(Gtk::RESPONSE_OK);
2271 persson 2169 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
2272 schoenebeck 1225 Gtk::FileFilter filter;
2273     filter.add_pattern("*.gig");
2274 persson 2169 #else
2275     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
2276     filter->add_pattern("*.gig");
2277     #endif
2278 schoenebeck 1225 dialog.set_filter(filter);
2279 persson 1725 if (current_gig_dir != "") {
2280     dialog.set_current_folder(current_gig_dir);
2281 persson 1261 }
2282 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
2283 persson 3477 dialog.hide();
2284 persson 1261 std::string filename = dialog.get_filename();
2285     printf("filename=%s\n", filename.c_str());
2286 persson 3472 #ifdef GLIB_THREADS
2287 persson 2841 printf("on_action_file_open self=%p\n",
2288     static_cast<void*>(Glib::Threads::Thread::self()));
2289 persson 3472 #else
2290     std::cout << "on_action_file_open self=" <<
2291     std::this_thread::get_id() << "\n";
2292     #endif
2293 persson 1261 load_file(filename.c_str());
2294 persson 1725 current_gig_dir = Glib::path_get_dirname(filename);
2295 schoenebeck 1225 }
2296     }
2297    
2298     void MainWindow::load_file(const char* name)
2299     {
2300 persson 1303 __clear();
2301 schoenebeck 2683
2302     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2303     _("Loading") + Glib::ustring(" '") +
2304     Glib::filename_display_basename(name) + "' ...",
2305     *this
2306     );
2307 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2308 schoenebeck 2683 progress_dialog->show_all();
2309 schoenebeck 3364 #endif
2310 schoenebeck 2683 loader = new Loader(name); //FIXME: memory leak!
2311 schoenebeck 1225 loader->signal_progress().connect(
2312     sigc::mem_fun(*this, &MainWindow::on_loader_progress));
2313     loader->signal_finished().connect(
2314     sigc::mem_fun(*this, &MainWindow::on_loader_finished));
2315 schoenebeck 2683 loader->signal_error().connect(
2316     sigc::mem_fun(*this, &MainWindow::on_loader_error));
2317 schoenebeck 1225 loader->launch();
2318     }
2319    
2320     void MainWindow::load_instrument(gig::Instrument* instr) {
2321     if (!instr) {
2322     Glib::ustring txt = "Provided instrument is NULL!\n";
2323     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2324     msg.run();
2325     Gtk::Main::quit();
2326     }
2327 schoenebeck 1328 // clear all GUI elements
2328     __clear();
2329     // load the instrument
2330 schoenebeck 1225 gig::File* pFile = (gig::File*) instr->GetParent();
2331 schoenebeck 1382 load_gig(pFile, 0 /*file name*/, true /*shared instrument*/);
2332 schoenebeck 2664 // automatically select the given instrument
2333     int i = 0;
2334     for (gig::Instrument* instrument = pFile->GetFirstInstrument(); instrument;
2335     instrument = pFile->GetNextInstrument(), ++i)
2336     {
2337     if (instrument == instr) {
2338     // select item in "instruments" tree view
2339     m_TreeView.get_selection()->select(Gtk::TreePath(ToString(i)));
2340     // make sure the selected item in the "instruments" tree view is
2341     // visible (scroll to it)
2342     m_TreeView.scroll_to_row(Gtk::TreePath(ToString(i)));
2343 schoenebeck 3364 #if !USE_GTKMM_BUILDER
2344 schoenebeck 2664 // select item in instrument menu
2345     {
2346     const std::vector<Gtk::Widget*> children =
2347     instrument_menu->get_children();
2348     static_cast<Gtk::RadioMenuItem*>(children[i])->set_active();
2349     }
2350 schoenebeck 3364 #endif
2351 schoenebeck 2664 // update region chooser and dimension region chooser
2352     m_RegionChooser.set_instrument(instr);
2353     break;
2354     }
2355     }
2356 schoenebeck 1225 }
2357    
2358     void MainWindow::on_loader_progress()
2359     {
2360 schoenebeck 2683 progress_dialog->set_fraction(loader->get_progress());
2361 schoenebeck 1225 }
2362    
2363     void MainWindow::on_loader_finished()
2364     {
2365 persson 3471 loader->join();
2366 schoenebeck 1225 printf("Loader finished!\n");
2367 persson 3472 #ifdef GLIB_THREADS
2368 persson 2841 printf("on_loader_finished self=%p\n",
2369     static_cast<void*>(Glib::Threads::Thread::self()));
2370 persson 3472 #else
2371     std::cout << "on_loader_finished self=" <<
2372     std::this_thread::get_id() << "\n";
2373     #endif
2374 schoenebeck 2683 load_gig(loader->gig, loader->filename.c_str());
2375     progress_dialog->hide();
2376 schoenebeck 1225 }
2377    
2378 schoenebeck 2683 void MainWindow::on_loader_error()
2379     {
2380 persson 3471 loader->join();
2381 schoenebeck 2683 Glib::ustring txt = _("Could not load file: ") + loader->error_message;
2382     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2383     msg.run();
2384     progress_dialog->hide();
2385     }
2386    
2387 schoenebeck 1225 void MainWindow::on_action_file_save()
2388     {
2389 persson 1261 file_save();
2390     }
2391    
2392 persson 1303 bool MainWindow::check_if_savable()
2393     {
2394     if (!file) return false;
2395    
2396     if (!file->GetFirstSample()) {
2397     Gtk::MessageDialog(*this, _("The file could not be saved "
2398     "because it contains no samples"),
2399     false, Gtk::MESSAGE_ERROR).run();
2400     return false;
2401     }
2402    
2403     for (gig::Instrument* instrument = file->GetFirstInstrument() ; instrument ;
2404     instrument = file->GetNextInstrument()) {
2405     if (!instrument->GetFirstRegion()) {
2406     Gtk::MessageDialog(*this, _("The file could not be saved "
2407     "because there are instruments "
2408     "that have no regions"),
2409     false, Gtk::MESSAGE_ERROR).run();
2410     return false;
2411     }
2412     }
2413     return true;
2414     }
2415    
2416 persson 1261 bool MainWindow::file_save()
2417     {
2418 persson 1303 if (!check_if_savable()) return false;
2419 schoenebeck 1382 if (!file_is_shared && !file_has_name) return file_save_as();
2420 persson 1261
2421 schoenebeck 1225 std::cout << "Saving file\n" << std::flush;
2422 schoenebeck 1322 file_structure_to_be_changed_signal.emit(this->file);
2423 schoenebeck 2683
2424     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2425     _("Saving") + Glib::ustring(" '") +
2426     Glib::filename_display_basename(this->filename) + "' ...",
2427     *this
2428     );
2429 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2430 schoenebeck 2683 progress_dialog->show_all();
2431 schoenebeck 3364 #endif
2432 schoenebeck 2683 saver = new Saver(this->file); //FIXME: memory leak!
2433     saver->signal_progress().connect(
2434     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2435     saver->signal_finished().connect(
2436     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2437     saver->signal_error().connect(
2438     sigc::mem_fun(*this, &MainWindow::on_saver_error));
2439     saver->launch();
2440    
2441     return true;
2442     }
2443    
2444     void MainWindow::on_saver_progress()
2445     {
2446     progress_dialog->set_fraction(saver->get_progress());
2447     }
2448    
2449     void MainWindow::on_saver_error()
2450     {
2451 persson 3471 saver->join();
2452 schoenebeck 2683 file_structure_changed_signal.emit(this->file);
2453     Glib::ustring txt = _("Could not save file: ") + saver->error_message;
2454     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2455     msg.run();
2456     }
2457    
2458     void MainWindow::on_saver_finished()
2459     {
2460 persson 3471 saver->join();
2461 schoenebeck 2683 this->file = saver->gig;
2462     this->filename = saver->filename;
2463     current_gig_dir = Glib::path_get_dirname(filename);
2464     set_title(Glib::filename_display_basename(filename));
2465     file_has_name = true;
2466     file_is_changed = false;
2467     std::cout << "Saving file done. Importing queued samples now ...\n" << std::flush;
2468 schoenebeck 1225 __import_queued_samples();
2469 schoenebeck 2683 std::cout << "Importing queued samples done.\n" << std::flush;
2470    
2471 schoenebeck 1322 file_structure_changed_signal.emit(this->file);
2472 schoenebeck 2683
2473 schoenebeck 2697 __refreshEntireGUI();
2474 schoenebeck 2683 progress_dialog->hide();
2475 schoenebeck 1225 }
2476    
2477     void MainWindow::on_action_file_save_as()
2478     {
2479 persson 1303 if (!check_if_savable()) return;
2480 persson 1261 file_save_as();
2481     }
2482    
2483     bool MainWindow::file_save_as()
2484     {
2485 schoenebeck 3158 Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);
2486 schoenebeck 3364 #if HAS_GTKMM_STOCK
2487 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2488     dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
2489 schoenebeck 3364 #else
2490     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2491     dialog.add_button(_("_Save"), Gtk::RESPONSE_OK);
2492     #endif
2493 persson 1261 dialog.set_default_response(Gtk::RESPONSE_OK);
2494 persson 2151 dialog.set_do_overwrite_confirmation();
2495 persson 1261
2496 persson 2169 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
2497 schoenebeck 1225 Gtk::FileFilter filter;
2498     filter.add_pattern("*.gig");
2499 persson 2169 #else
2500     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
2501     filter->add_pattern("*.gig");
2502     #endif
2503 schoenebeck 1225 dialog.set_filter(filter);
2504 persson 1261
2505 schoenebeck 1679 // set initial dir and filename of the Save As dialog
2506     // and prepare that initial filename as a copy of the gig
2507     {
2508     std::string basename = Glib::path_get_basename(filename);
2509     std::string dir = Glib::path_get_dirname(filename);
2510 persson 1831 basename = std::string(_("copy_of_")) + basename;
2511 schoenebeck 1679 Glib::ustring copyFileName = Glib::build_filename(dir, basename);
2512     if (Glib::path_is_absolute(filename)) {
2513     dialog.set_filename(copyFileName);
2514     } else {
2515 persson 1725 if (current_gig_dir != "") dialog.set_current_folder(current_gig_dir);
2516 schoenebeck 1679 }
2517     dialog.set_current_name(Glib::filename_display_basename(copyFileName));
2518 persson 1261 }
2519    
2520 schoenebeck 1679 // show warning in the dialog
2521 schoenebeck 3364 HBox descriptionArea;
2522 schoenebeck 1679 descriptionArea.set_spacing(15);
2523 persson 2845 Gtk::Image warningIcon;
2524     warningIcon.set_from_icon_name("dialog-warning",
2525     Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
2526 schoenebeck 1679 descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
2527 persson 2344 #if GTKMM_MAJOR_VERSION < 3
2528 persson 1799 view::WrapLabel description;
2529 persson 2344 #else
2530     Gtk::Label description;
2531     description.set_line_wrap();
2532     #endif
2533 schoenebeck 1679 description.set_markup(
2534     _("\n<b>CAUTION:</b> You <b>MUST</b> use the "
2535     "<span style=\"italic\">\"Save\"</span> dialog instead of "
2536     "<span style=\"italic\">\"Save As...\"</span> if you want to save "
2537     "to the same .gig file. Using "
2538     "<span style=\"italic\">\"Save As...\"</span> for writing to the "
2539     "same .gig file will end up in corrupted sample wave data!\n")
2540     );
2541 persson 1799 descriptionArea.pack_start(description);
2542 schoenebeck 3364 #if USE_GTKMM_BOX
2543     dialog.get_content_area()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2544     #else
2545 schoenebeck 1679 dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2546 schoenebeck 3364 #endif
2547     #if HAS_GTKMM_SHOW_ALL_CHILDREN
2548 persson 1799 descriptionArea.show_all();
2549 schoenebeck 3364 #endif
2550 schoenebeck 1679
2551 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
2552 persson 3477 dialog.hide();
2553 schoenebeck 2683 std::string filename = dialog.get_filename();
2554     if (!Glib::str_has_suffix(filename, ".gig")) {
2555     filename += ".gig";
2556 schoenebeck 1225 }
2557 schoenebeck 2683 printf("filename=%s\n", filename.c_str());
2558    
2559     progress_dialog = new ProgressDialog( //FIXME: memory leak!
2560     _("Saving") + Glib::ustring(" '") +
2561     Glib::filename_display_basename(filename) + "' ...",
2562     *this
2563     );
2564 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2565 schoenebeck 2683 progress_dialog->show_all();
2566 schoenebeck 3364 #endif
2567 schoenebeck 2683
2568     saver = new Saver(file, filename); //FIXME: memory leak!
2569     saver->signal_progress().connect(
2570     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2571     saver->signal_finished().connect(
2572     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2573     saver->signal_error().connect(
2574     sigc::mem_fun(*this, &MainWindow::on_saver_error));
2575     saver->launch();
2576    
2577 persson 1261 return true;
2578 schoenebeck 1225 }
2579 persson 1261 return false;
2580 schoenebeck 1225 }
2581    
2582     // actually write the sample(s)' data to the gig file
2583     void MainWindow::__import_queued_samples() {
2584     std::cout << "Starting sample import\n" << std::flush;
2585     Glib::ustring error_files;
2586 persson 2841 printf("Samples to import: %d\n", int(m_SampleImportQueue.size()));
2587 schoenebeck 3116 for (std::map<gig::Sample*, SampleImportItem>::iterator iter = m_SampleImportQueue.begin();
2588 schoenebeck 1225 iter != m_SampleImportQueue.end(); ) {
2589 schoenebeck 3116 printf("Importing sample %s\n",iter->second.sample_path.c_str());
2590 schoenebeck 1225 SF_INFO info;
2591     info.format = 0;
2592 schoenebeck 3116 SNDFILE* hFile = sf_open(iter->second.sample_path.c_str(), SFM_READ, &info);
2593 persson 2398 sf_command(hFile, SFC_SET_SCALE_FLOAT_INT_READ, 0, SF_TRUE);
2594 schoenebeck 1225 try {
2595 persson 1831 if (!hFile) throw std::string(_("could not open file"));
2596 schoenebeck 1225 // determine sample's bit depth
2597     int bitdepth;
2598     switch (info.format & 0xff) {
2599     case SF_FORMAT_PCM_S8:
2600     case SF_FORMAT_PCM_16:
2601 persson 1265 case SF_FORMAT_PCM_U8:
2602 schoenebeck 1225 bitdepth = 16;
2603     break;
2604     case SF_FORMAT_PCM_24:
2605     case SF_FORMAT_PCM_32:
2606     case SF_FORMAT_FLOAT:
2607     case SF_FORMAT_DOUBLE:
2608 persson 1265 bitdepth = 24;
2609 schoenebeck 1225 break;
2610     default:
2611     sf_close(hFile); // close sound file
2612 persson 1831 throw std::string(_("format not supported")); // unsupported subformat (yet?)
2613 schoenebeck 1225 }
2614 persson 1265
2615 schoenebeck 3116 // reset write position for sample
2616     iter->first->SetPos(0);
2617    
2618 persson 1265 const int bufsize = 10000;
2619 schoenebeck 1225 switch (bitdepth) {
2620 persson 1265 case 16: {
2621     short* buffer = new short[bufsize * info.channels];
2622     sf_count_t cnt = info.frames;
2623     while (cnt) {
2624     // libsndfile does the conversion for us (if needed)
2625     int n = sf_readf_short(hFile, buffer, bufsize);
2626     // write from buffer directly (physically) into .gig file
2627 schoenebeck 3116 iter->first->Write(buffer, n);
2628 persson 1265 cnt -= n;
2629     }
2630     delete[] buffer;
2631 schoenebeck 1225 break;
2632 persson 1265 }
2633     case 24: {
2634     int* srcbuf = new int[bufsize * info.channels];
2635     uint8_t* dstbuf = new uint8_t[bufsize * 3 * info.channels];
2636     sf_count_t cnt = info.frames;
2637     while (cnt) {
2638     // libsndfile returns 32 bits, convert to 24
2639     int n = sf_readf_int(hFile, srcbuf, bufsize);
2640     int j = 0;
2641     for (int i = 0 ; i < n * info.channels ; i++) {
2642     dstbuf[j++] = srcbuf[i] >> 8;
2643     dstbuf[j++] = srcbuf[i] >> 16;
2644     dstbuf[j++] = srcbuf[i] >> 24;
2645     }
2646     // write from buffer directly (physically) into .gig file
2647 schoenebeck 3116 iter->first->Write(dstbuf, n);
2648 persson 1265 cnt -= n;
2649     }
2650     delete[] srcbuf;
2651     delete[] dstbuf;
2652 schoenebeck 1225 break;
2653 persson 1265 }
2654 schoenebeck 1225 }
2655     // cleanup
2656     sf_close(hFile);
2657 schoenebeck 1853 // let the sampler re-cache the sample if needed
2658 schoenebeck 3116 sample_changed_signal.emit(iter->first);
2659 schoenebeck 1225 // on success we remove the sample from the import queue,
2660     // otherwise keep it, maybe it works the next time ?
2661 schoenebeck 3116 std::map<gig::Sample*, SampleImportItem>::iterator cur = iter;
2662 schoenebeck 1225 ++iter;
2663     m_SampleImportQueue.erase(cur);
2664     } catch (std::string what) {
2665     // remember the files that made trouble (and their cause)
2666 persson 2442 if (!error_files.empty()) error_files += "\n";
2667 schoenebeck 3116 error_files += iter->second.sample_path += " (" + what + ")";
2668 schoenebeck 1225 ++iter;
2669     }
2670     }
2671     // show error message box when some sample(s) could not be imported
2672 persson 2442 if (!error_files.empty()) {
2673 schoenebeck 1382 Glib::ustring txt = _("Could not import the following sample(s):\n") + error_files;
2674 schoenebeck 1225 Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2675     msg.run();
2676     }
2677     }
2678    
2679     void MainWindow::on_action_file_properties()
2680     {
2681 schoenebeck 3636 fileProps.show();
2682     fileProps.deiconify();
2683 schoenebeck 1225 }
2684    
2685 schoenebeck 2541 void MainWindow::on_action_warn_user_on_extensions() {
2686     Settings::singleton()->warnUserOnExtensions =
2687     !Settings::singleton()->warnUserOnExtensions;
2688     }
2689    
2690 schoenebeck 3409 void MainWindow::on_action_show_tooltips() {
2691     Settings::singleton()->showTooltips =
2692     !Settings::singleton()->showTooltips;
2693    
2694     on_show_tooltips_changed();
2695     }
2696    
2697     void MainWindow::on_show_tooltips_changed() {
2698     const bool b = Settings::singleton()->showTooltips;
2699    
2700     dimreg_label.set_has_tooltip(b);
2701     dimreg_all_regions.set_has_tooltip(b);
2702     dimreg_all_dimregs.set_has_tooltip(b);
2703     dimreg_stereo.set_has_tooltip(b);
2704 schoenebeck 3418
2705     // Not doing this here, we let onQueryTreeViewTooltip() handle this per cell
2706     //m_TreeView.set_has_tooltip(b);
2707    
2708 schoenebeck 3409 m_TreeViewSamples.set_has_tooltip(b);
2709     m_TreeViewScripts.set_has_tooltip(b);
2710    
2711     set_has_tooltip(b);
2712     }
2713    
2714 schoenebeck 2689 void MainWindow::on_action_sync_sampler_instrument_selection() {
2715     Settings::singleton()->syncSamplerInstrumentSelection =
2716     !Settings::singleton()->syncSamplerInstrumentSelection;
2717     }
2718    
2719 schoenebeck 2773 void MainWindow::on_action_move_root_note_with_region_moved() {
2720     Settings::singleton()->moveRootNoteWithRegionMoved =
2721     !Settings::singleton()->moveRootNoteWithRegionMoved;
2722     }
2723    
2724 schoenebeck 1225 void MainWindow::on_action_help_about()
2725     {
2726     Gtk::AboutDialog dialog;
2727 persson 1959 #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 12) || GTKMM_MAJOR_VERSION > 2
2728     dialog.set_program_name("Gigedit");
2729     #else
2730     dialog.set_name("Gigedit");
2731     #endif
2732 schoenebeck 1225 dialog.set_version(VERSION);
2733 persson 3456 dialog.set_copyright("Copyright (C) 2006-2019 Andreas Persson");
2734 schoenebeck 2476 const std::string sComment =
2735     _("Built " __DATE__ "\nUsing ") +
2736     ::gig::libraryName() + " " + ::gig::libraryVersion() + "\n\n" +
2737     _(
2738     "Gigedit is released under the GNU General Public License.\n"
2739     "\n"
2740 schoenebeck 2627 "This program is distributed WITHOUT ANY WARRANTY; So better "
2741     "backup your Gigasampler/GigaStudio files before editing them with "
2742 schoenebeck 2476 "this application.\n"
2743     "\n"
2744 schoenebeck 3540 "Please report bugs to: https://bugs.linuxsampler.org"
2745 schoenebeck 2476 );
2746     dialog.set_comments(sComment.c_str());
2747 schoenebeck 3540 dialog.set_website("https://www.linuxsampler.org");
2748     dialog.set_website_label("https://www.linuxsampler.org");
2749 schoenebeck 3225 dialog.set_position(Gtk::WIN_POS_CENTER);
2750 schoenebeck 1225 dialog.run();
2751     }
2752    
2753 schoenebeck 3636 FilePropDialog::FilePropDialog()
2754 schoenebeck 2560 : eFileFormat(_("File Format")),
2755     eName(_("Name")),
2756 persson 1831 eCreationDate(_("Creation date")),
2757     eComments(_("Comments")),
2758     eProduct(_("Product")),
2759     eCopyright(_("Copyright")),
2760     eArtists(_("Artists")),
2761     eGenre(_("Genre")),
2762     eKeywords(_("Keywords")),
2763     eEngineer(_("Engineer")),
2764     eTechnician(_("Technician")),
2765     eSoftware(_("Software")),
2766     eMedium(_("Medium")),
2767     eSource(_("Source")),
2768     eSourceForm(_("Source form")),
2769     eCommissioned(_("Commissioned")),
2770     eSubject(_("Subject")),
2771 schoenebeck 3364 #if HAS_GTKMM_STOCK
2772 schoenebeck 3158 quitButton(Gtk::Stock::CLOSE),
2773 schoenebeck 3364 #else
2774     quitButton(_("_Close")),
2775     #endif
2776 schoenebeck 2560 table(2, 1),
2777     m_file(NULL)
2778 schoenebeck 1225 {
2779 schoenebeck 3225 if (!Settings::singleton()->autoRestoreWindowDimension) {
2780     set_default_size(470, 390);
2781     set_position(Gtk::WIN_POS_MOUSE);
2782     }
2783    
2784 persson 1831 set_title(_("File Properties"));
2785 persson 1582 eName.set_width_chars(50);
2786    
2787 schoenebeck 3636 connect(eFileFormat, &FilePropDialog::set_FileFormat);
2788 persson 1582 connect(eName, &DLS::Info::Name);
2789     connect(eCreationDate, &DLS::Info::CreationDate);
2790     connect(eComments, &DLS::Info::Comments);
2791     connect(eProduct, &DLS::Info::Product);
2792     connect(eCopyright, &DLS::Info::Copyright);
2793     connect(eArtists, &DLS::Info::Artists);
2794     connect(eGenre, &DLS::Info::Genre);
2795     connect(eKeywords, &DLS::Info::Keywords);
2796     connect(eEngineer, &DLS::Info::Engineer);
2797     connect(eTechnician, &DLS::Info::Technician);
2798     connect(eSoftware, &DLS::Info::Software);
2799     connect(eMedium, &DLS::Info::Medium);
2800     connect(eSource, &DLS::Info::Source);
2801     connect(eSourceForm, &DLS::Info::SourceForm);
2802     connect(eCommissioned, &DLS::Info::Commissioned);
2803     connect(eSubject, &DLS::Info::Subject);
2804    
2805 schoenebeck 2560 table.add(eFileFormat);
2806 persson 1582 table.add(eName);
2807     table.add(eCreationDate);
2808     table.add(eComments);
2809     table.add(eProduct);
2810     table.add(eCopyright);
2811     table.add(eArtists);
2812     table.add(eGenre);
2813     table.add(eKeywords);
2814     table.add(eEngineer);
2815     table.add(eTechnician);
2816     table.add(eSoftware);
2817     table.add(eMedium);
2818     table.add(eSource);
2819     table.add(eSourceForm);
2820     table.add(eCommissioned);
2821     table.add(eSubject);
2822    
2823 schoenebeck 3364 #if USE_GTKMM_GRID
2824     table.set_column_spacing(5);
2825     #else
2826 schoenebeck 1225 table.set_col_spacings(5);
2827 schoenebeck 3364 #endif
2828    
2829 persson 1582 add(vbox);
2830 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2831 schoenebeck 3364 table.set_margin(5);
2832     #else
2833 persson 1582 table.set_border_width(5);
2834 schoenebeck 3364 #endif
2835 persson 1582 vbox.add(table);
2836     vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
2837     buttonBox.set_layout(Gtk::BUTTONBOX_END);
2838 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2839 schoenebeck 3364 buttonBox.set_margin(5);
2840     #else
2841 persson 1582 buttonBox.set_border_width(5);
2842 schoenebeck 3364 #endif
2843 persson 1582 buttonBox.show();
2844     buttonBox.pack_start(quitButton);
2845 persson 2151 quitButton.set_can_default();
2846 persson 1582 quitButton.grab_focus();
2847     quitButton.signal_clicked().connect(
2848 schoenebeck 3636 sigc::mem_fun(*this, &FilePropDialog::hide));
2849 schoenebeck 1225
2850 persson 1582 quitButton.show();
2851     vbox.show();
2852 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
2853 schoenebeck 1225 show_all_children();
2854 schoenebeck 3364 #endif
2855 schoenebeck 1225 }
2856    
2857 schoenebeck 3636 void FilePropDialog::set_file(gig::File* file)
2858 schoenebeck 2560 {
2859     m_file = file;
2860 persson 3469 update(file->pInfo);
2861 schoenebeck 2560
2862     // update file format version combo box
2863     const std::string sGiga = "Gigasampler/GigaStudio v";
2864     const int major = file->pVersion->major;
2865     std::vector<std::string> txts;
2866     std::vector<int> values;
2867     txts.push_back(sGiga + "2"); values.push_back(2);
2868 schoenebeck 3441 txts.push_back(sGiga + "3"); values.push_back(3);
2869     txts.push_back(sGiga + "4"); values.push_back(4);
2870     if (major < 2 || major > 4) {
2871 schoenebeck 2560 txts.push_back(sGiga + ToString(major)); values.push_back(major);
2872     }
2873     std::vector<const char*> texts;
2874     for (int i = 0; i < txts.size(); ++i) texts.push_back(txts[i].c_str());
2875 persson 2579 texts.push_back(NULL); values.push_back(0);
2876 persson 3469
2877     update_model++;
2878 schoenebeck 2560 eFileFormat.set_choices(&texts[0], &values[0]);
2879     eFileFormat.set_value(major);
2880 persson 3469 update_model--;
2881 schoenebeck 2560 }
2882    
2883 schoenebeck 3636 void FilePropDialog::set_FileFormat(int value)
2884 schoenebeck 1225 {
2885 persson 3469 m_file->pVersion->major = value;
2886 schoenebeck 1225 }
2887    
2888 persson 1582
2889 persson 2445 void InstrumentProps::set_Name(const gig::String& name)
2890     {
2891     m->pInfo->Name = name;
2892     }
2893    
2894     void InstrumentProps::update_name()
2895     {
2896     update_model++;
2897     eName.set_value(m->pInfo->Name);
2898     update_model--;
2899     }
2900    
2901 persson 1460 void InstrumentProps::set_IsDrum(bool value)
2902     {
2903 persson 2423 m->IsDrum = value;
2904 persson 1460 }
2905    
2906     void InstrumentProps::set_MIDIBank(uint16_t value)
2907     {
2908 persson 2423 m->MIDIBank = value;
2909 persson 1460 }
2910    
2911     void InstrumentProps::set_MIDIProgram(uint32_t value)
2912     {
2913 persson 2423 m->MIDIProgram = value;
2914 persson 1460 }
2915    
2916 persson 2423 InstrumentProps::InstrumentProps() :
2917 schoenebeck 3364 #if HAS_GTKMM_STOCK
2918 schoenebeck 3158 quitButton(Gtk::Stock::CLOSE),
2919 schoenebeck 3364 #else
2920     quitButton(_("_Close")),
2921     #endif
2922 persson 2423 table(2,1),
2923     eName(_("Name")),
2924     eIsDrum(_("Is drum")),
2925     eMIDIBank(_("MIDI bank"), 0, 16383),
2926     eMIDIProgram(_("MIDI program")),
2927 schoenebeck 3643 eAttenuation(_("Attenuation (dB)"), -96, +96, 0, 1),
2928 persson 2423 eEffectSend(_("Effect send"), 0, 65535),
2929     eFineTune(_("Fine tune"), -8400, 8400),
2930 schoenebeck 3643 ePitchbendRange(_("Pitchbend range (halftones)"), 0, 48),
2931 persson 2423 ePianoReleaseMode(_("Piano release mode")),
2932     eDimensionKeyRangeLow(_("Keyswitching range low")),
2933 schoenebeck 3635 eDimensionKeyRangeHigh(_("Keyswitching range high")),
2934     table2(2,1),
2935     eName2(_("Name")),
2936     eCreationDate(_("Creation date")),
2937     eComments(_("Comments")),
2938     eProduct(_("Product")),
2939     eCopyright(_("Copyright")),
2940     eArtists(_("Artists")),
2941     eGenre(_("Genre")),
2942     eKeywords(_("Keywords")),
2943     eEngineer(_("Engineer")),
2944     eTechnician(_("Technician")),
2945     eSoftware(_("Software")),
2946     eMedium(_("Medium")),
2947     eSource(_("Source")),
2948     eSourceForm(_("Source form")),
2949     eCommissioned(_("Commissioned")),
2950     eSubject(_("Subject"))
2951 persson 1460 {
2952 schoenebeck 3225 if (!Settings::singleton()->autoRestoreWindowDimension) {
2953     //set_default_size(470, 390);
2954     set_position(Gtk::WIN_POS_MOUSE);
2955     }
2956    
2957 persson 1831 set_title(_("Instrument Properties"));
2958 schoenebeck 1225
2959 schoenebeck 3635 tabs.append_page(vbox[1], _("Settings"));
2960     tabs.append_page(vbox[2], _("Info"));
2961    
2962 schoenebeck 1656 eDimensionKeyRangeLow.set_tip(
2963     _("start of the keyboard area which should switch the "
2964     "\"keyswitching\" dimension")
2965     );
2966     eDimensionKeyRangeHigh.set_tip(
2967     _("end of the keyboard area which should switch the "
2968     "\"keyswitching\" dimension")
2969     );
2970    
2971 persson 2445 connect(eName, &InstrumentProps::set_Name);
2972 persson 1460 connect(eIsDrum, &InstrumentProps::set_IsDrum);
2973     connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
2974     connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
2975     connect(eAttenuation, &gig::Instrument::Attenuation);
2976     connect(eEffectSend, &gig::Instrument::EffectSend);
2977     connect(eFineTune, &gig::Instrument::FineTune);
2978     connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
2979     connect(ePianoReleaseMode, &gig::Instrument::PianoReleaseMode);
2980 persson 2423 connect(eDimensionKeyRangeLow, eDimensionKeyRangeHigh,
2981     &gig::Instrument::DimensionKeyRange);
2982 persson 1460
2983 persson 2445 eName.signal_value_changed().connect(sig_name_changed.make_slot());
2984    
2985 schoenebeck 3635 connect(eName2, &InstrumentProps::set_Name);
2986     connectLambda(eCreationDate, [this](gig::String s) {
2987     m->pInfo->CreationDate = s;
2988     });
2989     connectLambda(eComments, [this](gig::String s) {
2990     m->pInfo->Comments = s;
2991     });
2992     connectLambda(eProduct, [this](gig::String s) {
2993     m->pInfo->Product = s;
2994     });
2995     connectLambda(eCopyright, [this](gig::String s) {
2996     m->pInfo->Copyright = s;
2997     });
2998     connectLambda(eArtists, [this](gig::String s) {
2999     m->pInfo->Artists = s;
3000     });
3001     connectLambda(eGenre, [this](gig::String s) {
3002     m->pInfo->Genre = s;
3003     });
3004     connectLambda(eKeywords, [this](gig::String s) {
3005     m->pInfo->Keywords = s;
3006     });
3007     connectLambda(eEngineer, [this](gig::String s) {
3008     m->pInfo->Engineer = s;
3009     });
3010     connectLambda(eTechnician, [this](gig::String s) {
3011     m->pInfo->Technician = s;
3012     });
3013     connectLambda(eSoftware, [this](gig::String s) {
3014     m->pInfo->Software = s;
3015     });
3016     connectLambda(eMedium, [this](gig::String s) {
3017     m->pInfo->Medium = s;
3018     });
3019     connectLambda(eSource, [this](gig::String s) {
3020     m->pInfo->Source = s;
3021     });
3022     connectLambda(eSourceForm, [this](gig::String s) {
3023     m->pInfo->SourceForm = s;
3024     });
3025     connectLambda(eCommissioned, [this](gig::String s) {
3026     m->pInfo->Commissioned = s;
3027     });
3028     connectLambda(eSubject, [this](gig::String s) {
3029     m->pInfo->Subject = s;
3030     });
3031    
3032     // tab 1
3033 schoenebeck 3364 #if USE_GTKMM_GRID
3034     table.set_column_spacing(5);
3035     #else
3036 schoenebeck 1225 table.set_col_spacings(5);
3037 schoenebeck 3364 #endif
3038 persson 1582 table.add(eName);
3039     table.add(eIsDrum);
3040     table.add(eMIDIBank);
3041     table.add(eMIDIProgram);
3042     table.add(eAttenuation);
3043     table.add(eEffectSend);
3044     table.add(eFineTune);
3045     table.add(ePitchbendRange);
3046     table.add(ePianoReleaseMode);
3047     table.add(eDimensionKeyRangeLow);
3048     table.add(eDimensionKeyRangeHigh);
3049 schoenebeck 1225
3050 schoenebeck 3635 // tab 2
3051     #if USE_GTKMM_GRID
3052     table2.set_column_spacing(5);
3053     #else
3054     table2.set_col_spacings(5);
3055     #endif
3056     table2.add(eName2);
3057     table2.add(eCreationDate);
3058     table2.add(eComments);
3059     table2.add(eProduct);
3060     table2.add(eCopyright);
3061     table2.add(eArtists);
3062     table2.add(eGenre);
3063     table2.add(eKeywords);
3064     table2.add(eEngineer);
3065     table2.add(eTechnician);
3066     table2.add(eSoftware);
3067     table2.add(eMedium);
3068     table2.add(eSource);
3069     table2.add(eSourceForm);
3070     table2.add(eCommissioned);
3071     table2.add(eSubject);
3072    
3073     add(vbox[0]);
3074 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3075 schoenebeck 3364 table.set_margin(5);
3076     #else
3077 schoenebeck 1225 table.set_border_width(5);
3078 schoenebeck 3364 #endif
3079 schoenebeck 3635 vbox[1].pack_start(table);
3080     vbox[2].pack_start(table2);
3081 schoenebeck 1225 table.show();
3082 schoenebeck 3635 table2.show();
3083     vbox[0].pack_start(tabs);
3084     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3085 schoenebeck 1225 buttonBox.set_layout(Gtk::BUTTONBOX_END);
3086 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3087 schoenebeck 3364 buttonBox.set_margin(5);
3088     #else
3089 schoenebeck 1225 buttonBox.set_border_width(5);
3090 schoenebeck 3364 #endif
3091 schoenebeck 1225 buttonBox.show();
3092     buttonBox.pack_start(quitButton);
3093 persson 2151 quitButton.set_can_default();
3094 schoenebeck 1225 quitButton.grab_focus();
3095    
3096     quitButton.signal_clicked().connect(
3097     sigc::mem_fun(*this, &InstrumentProps::hide));
3098    
3099     quitButton.show();
3100 schoenebeck 3635 vbox[0].show();
3101 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
3102 schoenebeck 1225 show_all_children();
3103 schoenebeck 3364 #endif
3104 schoenebeck 1225 }
3105    
3106     void InstrumentProps::set_instrument(gig::Instrument* instrument)
3107     {
3108 persson 2423 update(instrument);
3109 persson 1460
3110     update_model++;
3111 schoenebeck 3635
3112     // tab 1
3113 persson 2445 eName.set_value(instrument->pInfo->Name);
3114 persson 1460 eIsDrum.set_value(instrument->IsDrum);
3115     eMIDIBank.set_value(instrument->MIDIBank);
3116     eMIDIProgram.set_value(instrument->MIDIProgram);
3117 schoenebeck 3635 // tab 2
3118     eName2.set_value(instrument->pInfo->Name);
3119     eCreationDate.set_value(instrument->pInfo->CreationDate);
3120     eComments.set_value(instrument->pInfo->Comments);
3121     eProduct.set_value(instrument->pInfo->Product);
3122     eCopyright.set_value(instrument->pInfo->Copyright);
3123     eArtists.set_value(instrument->pInfo->Artists);
3124     eGenre.set_value(instrument->pInfo->Genre);
3125     eKeywords.set_value(instrument->pInfo->Keywords);
3126     eEngineer.set_value(instrument->pInfo->Engineer);
3127     eTechnician.set_value(instrument->pInfo->Technician);
3128     eSoftware.set_value(instrument->pInfo->Software);
3129     eMedium.set_value(instrument->pInfo->Medium);
3130     eSource.set_value(instrument->pInfo->Source);
3131     eSourceForm.set_value(instrument->pInfo->SourceForm);
3132     eCommissioned.set_value(instrument->pInfo->Commissioned);
3133     eSubject.set_value(instrument->pInfo->Subject);
3134    
3135 persson 1460 update_model--;
3136 schoenebeck 1225 }
3137    
3138    
3139 schoenebeck 3637 SampleProps::SampleProps() :
3140     #if HAS_GTKMM_STOCK
3141     quitButton(Gtk::Stock::CLOSE),
3142     #else
3143     quitButton(_("_Close")),
3144     #endif
3145     table(2,1),
3146     eName(_("Name")),
3147     eUnityNote(_("Unity Note")),
3148     eSampleGroup(_("Sample Group")),
3149     eSampleFormatInfo(_("Sample Format")),
3150     eSampleID("Sample ID"),
3151     eChecksum("Wave Data CRC-32"),
3152     eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
3153     eLoopStart(_("Loop start position"), 0, 9999999),
3154     eLoopLength(_("Loop size"), 0, 9999999),
3155     eLoopType(_("Loop type")),
3156     eLoopPlayCount(_("Playback count")),
3157     table2(2,1),
3158     eName2(_("Name")),
3159     eCreationDate(_("Creation date")),
3160     eComments(_("Comments")),
3161     eProduct(_("Product")),
3162     eCopyright(_("Copyright")),
3163     eArtists(_("Artists")),
3164     eGenre(_("Genre")),
3165     eKeywords(_("Keywords")),
3166     eEngineer(_("Engineer")),
3167     eTechnician(_("Technician")),
3168     eSoftware(_("Software")),
3169     eMedium(_("Medium")),
3170     eSource(_("Source")),
3171     eSourceForm(_("Source form")),
3172     eCommissioned(_("Commissioned")),
3173     eSubject(_("Subject"))
3174     {
3175     if (!Settings::singleton()->autoRestoreWindowDimension) {
3176     //set_default_size(470, 390);
3177     set_position(Gtk::WIN_POS_MOUSE);
3178     }
3179    
3180     set_title(_("Sample Properties"));
3181    
3182     tabs.append_page(vbox[1], _("Settings"));
3183     tabs.append_page(vbox[2], _("Info"));
3184    
3185     connect(eName, &SampleProps::set_Name);
3186     connect(eUnityNote, &gig::Sample::MIDIUnityNote);
3187     connect(eLoopsCount, &gig::Sample::Loops);
3188     connectLambda(eLoopStart, [this](uint32_t start){
3189     m->LoopStart = start;
3190     m->LoopEnd = start + m->LoopSize;
3191     });
3192     connectLambda(eLoopLength, [this](uint32_t length){
3193     m->LoopSize = length;
3194     m->LoopEnd = m->LoopStart + length;
3195     });
3196     {
3197     const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
3198     static const gig::loop_type_t values[] = {
3199     gig::loop_type_normal,
3200     gig::loop_type_bidirectional,
3201     gig::loop_type_backward
3202     };
3203     eLoopType.set_choices(choices, values);
3204     }
3205     connect(eLoopType, &gig::Sample::LoopType);
3206     connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
3207    
3208     eName.signal_value_changed().connect(sig_name_changed.make_slot());
3209    
3210     connect(eName2, &SampleProps::set_Name);
3211     connectLambda(eCreationDate, [this](gig::String s) {
3212     m->pInfo->CreationDate = s;
3213     });
3214     connectLambda(eComments, [this](gig::String s) {
3215     m->pInfo->Comments = s;
3216     });
3217     connectLambda(eProduct, [this](gig::String s) {
3218     m->pInfo->Product = s;
3219     });
3220     connectLambda(eCopyright, [this](gig::String s) {
3221     m->pInfo->Copyright = s;
3222     });
3223     connectLambda(eArtists, [this](gig::String s) {
3224     m->pInfo->Artists = s;
3225     });
3226     connectLambda(eGenre, [this](gig::String s) {
3227     m->pInfo->Genre = s;
3228     });
3229     connectLambda(eKeywords, [this](gig::String s) {
3230     m->pInfo->Keywords = s;
3231     });
3232     connectLambda(eEngineer, [this](gig::String s) {
3233     m->pInfo->Engineer = s;
3234     });
3235     connectLambda(eTechnician, [this](gig::String s) {
3236     m->pInfo->Technician = s;
3237     });
3238     connectLambda(eSoftware, [this](gig::String s) {
3239     m->pInfo->Software = s;
3240     });
3241     connectLambda(eMedium, [this](gig::String s) {
3242     m->pInfo->Medium = s;
3243     });
3244     connectLambda(eSource, [this](gig::String s) {
3245     m->pInfo->Source = s;
3246     });
3247     connectLambda(eSourceForm, [this](gig::String s) {
3248     m->pInfo->SourceForm = s;
3249     });
3250     connectLambda(eCommissioned, [this](gig::String s) {
3251     m->pInfo->Commissioned = s;
3252     });
3253     connectLambda(eSubject, [this](gig::String s) {
3254     m->pInfo->Subject = s;
3255     });
3256    
3257     // tab 1
3258     #if USE_GTKMM_GRID
3259     table.set_column_spacing(5);
3260     #else
3261     table.set_col_spacings(5);
3262     #endif
3263     table.add(eName);
3264     table.add(eUnityNote);
3265     table.add(eSampleGroup);
3266     table.add(eSampleFormatInfo);
3267     table.add(eSampleID);
3268     table.add(eChecksum);
3269     table.add(eLoopsCount);
3270     table.add(eLoopStart);
3271     table.add(eLoopLength);
3272     table.add(eLoopType);
3273     table.add(eLoopPlayCount);
3274    
3275     // tab 2
3276     #if USE_GTKMM_GRID
3277     table2.set_column_spacing(5);
3278     #else
3279     table2.set_col_spacings(5);
3280     #endif
3281     table2.add(eName2);
3282     table2.add(eCreationDate);
3283     table2.add(eComments);
3284     table2.add(eProduct);
3285     table2.add(eCopyright);
3286     table2.add(eArtists);
3287     table2.add(eGenre);
3288     table2.add(eKeywords);
3289     table2.add(eEngineer);
3290     table2.add(eTechnician);
3291     table2.add(eSoftware);
3292     table2.add(eMedium);
3293     table2.add(eSource);
3294     table2.add(eSourceForm);
3295     table2.add(eCommissioned);
3296     table2.add(eSubject);
3297    
3298     add(vbox[0]);
3299     #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3300     table.set_margin(5);
3301     #else
3302     table.set_border_width(5);
3303     #endif
3304     vbox[1].pack_start(table);
3305     vbox[2].pack_start(table2);
3306     table.show();
3307     table2.show();
3308     vbox[0].pack_start(tabs);
3309     vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3310     buttonBox.set_layout(Gtk::BUTTONBOX_END);
3311     #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3312     buttonBox.set_margin(5);
3313     #else
3314     buttonBox.set_border_width(5);
3315     #endif
3316     buttonBox.show();
3317     buttonBox.pack_start(quitButton);
3318     quitButton.set_can_default();
3319     quitButton.grab_focus();
3320    
3321     quitButton.signal_clicked().connect(
3322     sigc::mem_fun(*this, &SampleProps::hide));
3323    
3324     quitButton.show();
3325     vbox[0].show();
3326     #if HAS_GTKMM_SHOW_ALL_CHILDREN
3327     show_all_children();
3328     #endif
3329     }
3330    
3331     void SampleProps::set_sample(gig::Sample* sample)
3332     {
3333     update(sample);
3334    
3335     update_model++;
3336    
3337     // tab 1
3338     eName.set_value(sample->pInfo->Name);
3339     eUnityNote.set_value(sample->MIDIUnityNote);
3340     // show sample group name
3341     {
3342     Glib::ustring s = "---";
3343     if (sample && sample->GetGroup())
3344     s = sample->GetGroup()->Name;
3345     eSampleGroup.text.set_text(s);
3346     }
3347     // assemble sample format info string
3348     {
3349     Glib::ustring s;
3350     if (sample) {
3351     switch (sample->Channels) {
3352     case 1: s = _("Mono"); break;
3353     case 2: s = _("Stereo"); break;
3354     default:
3355     s = ToString(sample->Channels) + _(" audio channels");
3356     break;
3357     }
3358     s += " " + ToString(sample->BitDepth) + " Bits";
3359     s += " " + ToString(sample->SamplesPerSecond/1000) + "."
3360     + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
3361     } else {
3362     s = _("No sample assigned to this dimension region.");
3363     }
3364     eSampleFormatInfo.text.set_text(s);
3365     }
3366     // generate sample's memory address pointer string
3367     {
3368     Glib::ustring s;
3369     if (sample) {
3370     char buf[64] = {};
3371     snprintf(buf, sizeof(buf), "%p", sample);
3372     s = buf;
3373     } else {
3374     s = "---";
3375     }
3376     eSampleID.text.set_text(s);
3377     }
3378     // generate raw wave form data CRC-32 checksum string
3379     {
3380     Glib::ustring s = "---";
3381     if (sample) {
3382     char buf[64] = {};
3383     snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
3384     s = buf;
3385     }
3386     eChecksum.text.set_text(s);
3387     }
3388     eLoopsCount.set_value(sample->Loops);
3389     eLoopStart.set_value(sample->LoopStart);
3390     eLoopLength.set_value(sample->LoopSize);
3391     eLoopType.set_value(sample->LoopType);
3392     eLoopPlayCount.set_value(sample->LoopPlayCount);
3393     // tab 2
3394     eName2.set_value(sample->pInfo->Name);
3395     eCreationDate.set_value(sample->pInfo->CreationDate);
3396     eComments.set_value(sample->pInfo->Comments);
3397     eProduct.set_value(sample->pInfo->Product);
3398     eCopyright.set_value(sample->pInfo->Copyright);
3399     eArtists.set_value(sample->pInfo->Artists);
3400     eGenre.set_value(sample->pInfo->Genre);
3401     eKeywords.set_value(sample->pInfo->Keywords);
3402     eEngineer.set_value(sample->pInfo->Engineer);
3403     eTechnician.set_value(sample->pInfo->Technician);
3404     eSoftware.set_value(sample->pInfo->Software);
3405     eMedium.set_value(sample->pInfo->Medium);
3406     eSource.set_value(sample->pInfo->Source);
3407     eSourceForm.set_value(sample->pInfo->SourceForm);
3408     eCommissioned.set_value(sample->pInfo->Commissioned);
3409     eSubject.set_value(sample->pInfo->Subject);
3410    
3411     update_model--;
3412     }
3413    
3414     void SampleProps::set_Name(const gig::String& name)
3415     {
3416     m->pInfo->Name = name;
3417     }
3418    
3419     void SampleProps::update_name()
3420     {
3421     update_model++;
3422     eName.set_value(m->pInfo->Name);
3423     update_model--;
3424     }
3425    
3426    
3427 persson 1261 void MainWindow::file_changed()
3428     {
3429     if (file && !file_is_changed) {
3430     set_title("*" + get_title());
3431     file_is_changed = true;
3432 schoenebeck 1225 }
3433 persson 1261 }
3434 schoenebeck 1225
3435 schoenebeck 2621 void MainWindow::updateSampleRefCountMap(gig::File* gig) {
3436     sample_ref_count.clear();
3437    
3438     if (!gig) return;
3439    
3440     for (gig::Instrument* instrument = gig->GetFirstInstrument(); instrument;
3441     instrument = gig->GetNextInstrument())
3442     {
3443     for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
3444     rgn = instrument->GetNextRegion())
3445     {
3446     for (int i = 0; i < 256; ++i) {
3447     if (!rgn->pDimensionRegions[i]) continue;
3448     if (rgn->pDimensionRegions[i]->pSample) {
3449     sample_ref_count[rgn->pDimensionRegions[i]->pSample]++;
3450     }
3451     }
3452     }
3453     }
3454     }
3455    
3456 schoenebeck 3418 bool MainWindow::onQueryTreeViewTooltip(int x, int y, bool keyboardTip, const Glib::RefPtr<Gtk::Tooltip>& tooltip) {
3457     Gtk::TreeModel::iterator iter;
3458 persson 3460 if (!m_TreeView.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
3459     return false;
3460     }
3461 schoenebeck 3418 Gtk::TreeModel::Path path(iter);
3462     Gtk::TreeModel::Row row = *iter;
3463     Gtk::TreeViewColumn* pointedColumn = NULL;
3464     // resolve the precise table column the mouse points to
3465     {
3466     Gtk::TreeModel::Path path; // unused
3467     int cellX, cellY; // unused
3468     m_TreeView.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
3469     }
3470     Gtk::TreeViewColumn* scriptsColumn = m_TreeView.get_column(2);
3471     if (pointedColumn == scriptsColumn) { // mouse hovers scripts column ...
3472     // show the script(s) assigned to the hovered instrument as tooltip
3473     tooltip->set_markup( row[m_Columns.m_col_tooltip] );
3474     m_TreeView.set_tooltip_cell(tooltip, &path, scriptsColumn, NULL);
3475     } else {
3476     // if beginners' tooltips is disabled then don't show the following one
3477     if (!Settings::singleton()->showTooltips)
3478     return false;
3479     // yeah, a beginners tooltip
3480     tooltip->set_text(_(
3481     "Right click here for actions on instruments & MIDI Rules. "
3482     "Drag & drop to change the order of instruments."
3483     ));
3484     m_TreeView.set_tooltip_cell(tooltip, &path, pointedColumn, NULL);
3485     }
3486     return true;
3487     }
3488    
3489     static Glib::ustring scriptTooltipFor(gig::Instrument* instrument, int index) {
3490     Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3491     const int iScriptSlots = instrument->ScriptSlotCount();
3492 persson 3460 Glib::ustring tooltip = "<u>(" + ToString(index) + ") ���" + name + "���</u>\n\n";
3493 schoenebeck 3418 if (!iScriptSlots)
3494     tooltip += "<span foreground='red'><i>No script assigned</i></span>";
3495     else {
3496     for (int i = 0; i < iScriptSlots; ++i) {
3497 persson 3460 tooltip += "��� " + ToString(i+1) + ". Script: ���<span foreground='#46DEFF'><b>" +
3498 schoenebeck 3418 instrument->GetScriptOfSlot(i)->Name + "</b></span>���";
3499     if (i + 1 < iScriptSlots) tooltip += "\n\n";
3500     }
3501     }
3502     return tooltip;
3503     }
3504    
3505 schoenebeck 1382 void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
3506 persson 1261 {
3507     file = 0;
3508 schoenebeck 1411 set_file_is_shared(isSharedInstrument);
3509 persson 1261
3510 schoenebeck 2772 this->filename =
3511     (filename && strlen(filename) > 0) ?
3512     filename : (!gig->GetFileName().empty()) ?
3513     gig->GetFileName() : _("Unsaved Gig File");
3514 persson 1261 set_title(Glib::filename_display_basename(this->filename));
3515     file_has_name = filename;
3516     file_is_changed = false;
3517    
3518 schoenebeck 3636 fileProps.set_file(gig);
3519 schoenebeck 1225
3520 persson 2442 instrument_name_connection.block();
3521 schoenebeck 2994 int index = 0;
3522 schoenebeck 1225 for (gig::Instrument* instrument = gig->GetFirstInstrument() ; instrument ;
3523 schoenebeck 2994 instrument = gig->GetNextInstrument(), ++index) {
3524 persson 2446 Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3525 schoenebeck 3197 const int iScriptSlots = instrument->ScriptSlotCount();
3526 persson 2442
3527 schoenebeck 1225 Gtk::TreeModel::iterator iter = m_refTreeModel->append();
3528     Gtk::TreeModel::Row row = *iter;
3529 schoenebeck 2994 row[m_Columns.m_col_nr] = index;
3530 persson 2442 row[m_Columns.m_col_name] = name;
3531 schoenebeck 1225 row[m_Columns.m_col_instr] = instrument;
3532 schoenebeck 3197 row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3533 schoenebeck 3418 row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
3534 persson 2442
3535 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3536 persson 2442 add_instrument_to_menu(name);
3537 schoenebeck 3364 #endif
3538 schoenebeck 1225 }
3539 persson 2442 instrument_name_connection.unblock();
3540 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3541 schoenebeck 2625 uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments")->show();
3542 schoenebeck 3364 #endif
3543 schoenebeck 1225
3544 schoenebeck 2621 updateSampleRefCountMap(gig);
3545    
3546 schoenebeck 1225 for (gig::Group* group = gig->GetFirstGroup(); group; group = gig->GetNextGroup()) {
3547     if (group->Name != "") {
3548     Gtk::TreeModel::iterator iterGroup = m_refSamplesTreeModel->append();
3549     Gtk::TreeModel::Row rowGroup = *iterGroup;
3550 persson 2446 rowGroup[m_SamplesModel.m_col_name] = gig_to_utf8(group->Name);
3551 schoenebeck 1225 rowGroup[m_SamplesModel.m_col_group] = group;
3552     rowGroup[m_SamplesModel.m_col_sample] = NULL;
3553     for (gig::Sample* sample = group->GetFirstSample();
3554     sample; sample = group->GetNextSample()) {
3555     Gtk::TreeModel::iterator iterSample =
3556     m_refSamplesTreeModel->append(rowGroup.children());
3557     Gtk::TreeModel::Row rowSample = *iterSample;
3558 persson 2446 rowSample[m_SamplesModel.m_col_name] =
3559     gig_to_utf8(sample->pInfo->Name);
3560 schoenebeck 1225 rowSample[m_SamplesModel.m_col_sample] = sample;
3561     rowSample[m_SamplesModel.m_col_group] = NULL;
3562 schoenebeck 2621 int refcount = sample_ref_count.count(sample) ? sample_ref_count[sample] : 0;
3563     rowSample[m_SamplesModel.m_col_refcount] = ToString(refcount) + " " + _("Refs.");
3564 schoenebeck 2625 rowSample[m_SamplesModel.m_color] = refcount ? "black" : "red";
3565 schoenebeck 1225 }
3566     }
3567     }
3568 schoenebeck 2604
3569     for (int i = 0; gig->GetScriptGroup(i); ++i) {
3570     gig::ScriptGroup* group = gig->GetScriptGroup(i);
3571 schoenebeck 1225
3572 schoenebeck 2604 Gtk::TreeModel::iterator iterGroup = m_refScriptsTreeModel->append();
3573     Gtk::TreeModel::Row rowGroup = *iterGroup;
3574     rowGroup[m_ScriptsModel.m_col_name] = gig_to_utf8(group->Name);
3575     rowGroup[m_ScriptsModel.m_col_group] = group;
3576     rowGroup[m_ScriptsModel.m_col_script] = NULL;
3577     for (int s = 0; group->GetScript(s); ++s) {
3578     gig::Script* script = group->GetScript(s);
3579    
3580     Gtk::TreeModel::iterator iterScript =
3581     m_refScriptsTreeModel->append(rowGroup.children());
3582     Gtk::TreeModel::Row rowScript = *iterScript;
3583     rowScript[m_ScriptsModel.m_col_name] = gig_to_utf8(script->Name);
3584     rowScript[m_ScriptsModel.m_col_script] = script;
3585     rowScript[m_ScriptsModel.m_col_group] = NULL;
3586     }
3587     }
3588 schoenebeck 2624 // unfold all sample groups & script groups by default
3589     m_TreeViewSamples.expand_all();
3590 schoenebeck 2604 m_TreeViewScripts.expand_all();
3591    
3592 persson 1261 file = gig;
3593    
3594 schoenebeck 1225 // select the first instrument
3595 persson 2442 m_TreeView.get_selection()->select(Gtk::TreePath("0"));
3596 persson 2423
3597 persson 2445 instr_props_set_instrument();
3598 persson 2507 gig::Instrument* instrument = get_instrument();
3599     if (instrument) {
3600     midiRules.set_instrument(instrument);
3601     }
3602 persson 2445 }
3603    
3604     bool MainWindow::instr_props_set_instrument()
3605     {
3606     instrumentProps.signal_name_changed().clear();
3607    
3608 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
3609     if (rows.empty()) {
3610     instrumentProps.hide();
3611     return false;
3612     }
3613 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.
3614     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
3615 persson 2445 if (it) {
3616     Gtk::TreeModel::Row row = *it;
3617     gig::Instrument* instrument = row[m_Columns.m_col_instr];
3618    
3619 persson 2423 instrumentProps.set_instrument(instrument);
3620 persson 2445
3621     // make sure instrument tree is updated when user changes the
3622     // instrument name in instrument properties window
3623     instrumentProps.signal_name_changed().connect(
3624     sigc::bind(
3625     sigc::mem_fun(*this,
3626     &MainWindow::instr_name_changed_by_instr_props),
3627     it));
3628     } else {
3629     instrumentProps.hide();
3630 persson 2423 }
3631 schoenebeck 3364 //NOTE: explicit boolean cast required for GTKMM4 development branch here
3632     return it ? true : false;
3633 schoenebeck 1225 }
3634    
3635     void MainWindow::show_instr_props()
3636     {
3637 persson 2445 if (instr_props_set_instrument()) {
3638 persson 1533 instrumentProps.show();
3639     instrumentProps.deiconify();
3640 schoenebeck 1225 }
3641     }
3642    
3643 persson 2445 void MainWindow::instr_name_changed_by_instr_props(Gtk::TreeModel::iterator& it)
3644     {
3645     Gtk::TreeModel::Row row = *it;
3646     Glib::ustring name = row[m_Columns.m_col_name];
3647    
3648     gig::Instrument* instrument = row[m_Columns.m_col_instr];
3649 persson 2446 Glib::ustring gigname(gig_to_utf8(instrument->pInfo->Name));
3650     if (gigname != name) {
3651 schoenebeck 3418 Gtk::TreeModel::Path path(*it);
3652     const int index = path[0];
3653 persson 2446 row[m_Columns.m_col_name] = gigname;
3654 schoenebeck 3418 row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
3655 persson 2445 }
3656     }
3657    
3658 schoenebeck 3637 bool MainWindow::sample_props_set_sample()
3659     {
3660     sampleProps.signal_name_changed().clear();
3661    
3662     std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
3663     if (rows.empty()) {
3664     sampleProps.hide();
3665     return false;
3666     }
3667     //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3668     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
3669     if (it) {
3670     Gtk::TreeModel::Row row = *it;
3671     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3672    
3673     sampleProps.set_sample(sample);
3674    
3675     // make sure sample tree is updated when user changes the
3676     // sample name in sample properties window
3677     sampleProps.signal_name_changed().connect(
3678     sigc::bind(
3679     sigc::mem_fun(*this,
3680     &MainWindow::sample_name_changed_by_sample_props
3681     ), it
3682     )
3683     );
3684     } else {
3685     sampleProps.hide();
3686     }
3687     //NOTE: explicit boolean cast required for GTKMM4 development branch here
3688     return it ? true : false;
3689     }
3690    
3691     void MainWindow::show_sample_props()
3692     {
3693     if (sample_props_set_sample()) {
3694     sampleProps.show();
3695     sampleProps.deiconify();
3696     }
3697     }
3698    
3699     void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
3700     {
3701     Gtk::TreeModel::Row row = *it;
3702     Glib::ustring name = row[m_SamplesModel.m_col_name];
3703    
3704     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3705     Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
3706     if (gigname != name) {
3707     Gtk::TreeModel::Path path(*it);
3708     row[m_SamplesModel.m_col_name] = gigname;
3709     }
3710     }
3711    
3712 persson 2507 void MainWindow::show_midi_rules()
3713     {
3714     if (gig::Instrument* instrument = get_instrument())
3715     {
3716     midiRules.set_instrument(instrument);
3717     midiRules.show();
3718     midiRules.deiconify();
3719     }
3720     }
3721    
3722 schoenebeck 2610 void MainWindow::show_script_slots() {
3723     if (!file) return;
3724     // get selected instrument
3725 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
3726     if (rows.empty()) return;
3727     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
3728 schoenebeck 2610 if (!it) return;
3729     Gtk::TreeModel::Row row = *it;
3730     gig::Instrument* instrument = row[m_Columns.m_col_instr];
3731     if (!instrument) return;
3732    
3733     ScriptSlots* window = new ScriptSlots;
3734     window->setInstrument(instrument);
3735 schoenebeck 3197 window->signal_script_slots_changed().connect(
3736     sigc::mem_fun(*this, &MainWindow::onScriptSlotsModified)
3737     );
3738 schoenebeck 2610 //window->reparent(*this);
3739     window->show();
3740     }
3741    
3742 schoenebeck 3197 void MainWindow::onScriptSlotsModified(gig::Instrument* pInstrument) {
3743     if (!pInstrument) return;
3744     const int iScriptSlots = pInstrument->ScriptSlotCount();
3745    
3746 schoenebeck 3340 //NOTE: This is a big mess! Sometimes GTK requires m_TreeView.get_model(), here we need m_refTreeModelFilter->get_model(), otherwise accessing children below causes an error!
3747     //Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
3748     Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
3749    
3750 schoenebeck 3197 for (int i = 0; i < model->children().size(); ++i) {
3751     Gtk::TreeModel::Row row = model->children()[i];
3752     if (row[m_Columns.m_col_instr] != pInstrument) continue;
3753     row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3754 schoenebeck 3418 row[m_Columns.m_col_tooltip] = scriptTooltipFor(pInstrument, i);
3755 schoenebeck 3197 break;
3756     }
3757 schoenebeck 3339
3758     // causes the sampler to reload the instrument with the new script
3759     on_sel_change();
3760 schoenebeck 3750
3761     // force script 'patch' variables editor ("Script" tab) to be refreshed
3762     dimreg_edit.scriptVars.setInstrument(pInstrument, true/*force update*/);
3763 schoenebeck 3197 }
3764    
3765 schoenebeck 3339 void MainWindow::assignScript(gig::Script* pScript) {
3766     if (!pScript) {
3767     printf("assignScript() : !script\n");
3768     return;
3769     }
3770     printf("assignScript('%s')\n", pScript->Name.c_str());
3771    
3772     gig::Instrument* pInstrument = get_instrument();
3773     if (!pInstrument) {
3774     printf("!instrument\n");
3775     return;
3776     }
3777    
3778     pInstrument->AddScriptSlot(pScript);
3779    
3780     onScriptSlotsModified(pInstrument);
3781     }
3782    
3783 schoenebeck 3419 void MainWindow::dropAllScriptSlots() {
3784     gig::Instrument* pInstrument = get_instrument();
3785     if (!pInstrument) {
3786     printf("!instrument\n");
3787     return;
3788     }
3789    
3790     const int iScriptSlots = pInstrument->ScriptSlotCount();
3791     for (int i = iScriptSlots - 1; i >= 0; --i)
3792     pInstrument->RemoveScriptSlot(i);
3793    
3794     onScriptSlotsModified(pInstrument);
3795     }
3796    
3797 schoenebeck 2772 void MainWindow::on_action_refresh_all() {
3798     __refreshEntireGUI();
3799     }
3800    
3801 schoenebeck 1415 void MainWindow::on_action_view_status_bar() {
3802 schoenebeck 3364 #if USE_GLIB_ACTION
3803     bool active = false;
3804     m_actionToggleStatusBar->get_state(active);
3805     // for some reason toggle state does not change automatically
3806     active = !active;
3807     m_actionToggleStatusBar->change_state(active);
3808     if (active)
3809     m_StatusBar.show();
3810     else
3811     m_StatusBar.hide();
3812     #else
3813 schoenebeck 1415 Gtk::CheckMenuItem* item =
3814     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
3815     if (!item) {
3816     std::cerr << "/MenuBar/MenuView/Statusbar == NULL\n";
3817     return;
3818     }
3819     if (item->get_active()) m_StatusBar.show();
3820     else m_StatusBar.hide();
3821 schoenebeck 3364 #endif
3822 schoenebeck 1415 }
3823    
3824 schoenebeck 2918 void MainWindow::on_auto_restore_win_dim() {
3825 schoenebeck 3364 #if USE_GLIB_ACTION
3826     bool active = false;
3827     m_actionToggleRestoreWinDim->get_state(active);
3828     // for some reason toggle state does not change automatically
3829     active = !active;
3830     m_actionToggleRestoreWinDim->change_state(active);
3831     Settings::singleton()->autoRestoreWindowDimension = active;
3832     #else
3833 schoenebeck 2918 Gtk::CheckMenuItem* item =
3834     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/AutoRestoreWinDim"));
3835     if (!item) {
3836     std::cerr << "/MenuBar/MenuView/AutoRestoreWinDim == NULL\n";
3837     return;
3838     }
3839     Settings::singleton()->autoRestoreWindowDimension = item->get_active();
3840 schoenebeck 3364 #endif
3841 schoenebeck 2918 }
3842    
3843 schoenebeck 3711 void MainWindow::on_instr_double_click_opens_props() {
3844     #if USE_GLIB_ACTION
3845     bool active = false;
3846     m_actionInstrDoubleClickOpensProps->get_state(active);
3847     // for some reason toggle state does not change automatically
3848     active = !active;
3849     m_actionInstrDoubleClickOpensProps->change_state(active);
3850     Settings::singleton()->instrumentDoubleClickOpensProps = active;
3851     #else
3852     Gtk::CheckMenuItem* item =
3853     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
3854     if (!item) {
3855     std::cerr << "/MenuBar/MenuView/OpenInstrPropsByDoubleClick == NULL\n";
3856     return;
3857     }
3858     Settings::singleton()->instrumentDoubleClickOpensProps = item->get_active();
3859     #endif
3860     }
3861    
3862 schoenebeck 2967 void MainWindow::on_save_with_temporary_file() {
3863 schoenebeck 3364 #if USE_GLIB_ACTION
3864     bool active = false;
3865     m_actionToggleSaveWithTempFile->get_state(active);
3866     // for some reason toggle state does not change automatically
3867     active = !active;
3868     m_actionToggleSaveWithTempFile->change_state(active);
3869     Settings::singleton()->saveWithTemporaryFile = active;
3870     #else
3871 schoenebeck 2967 Gtk::CheckMenuItem* item =
3872     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuSettings/SaveWithTemporaryFile"));
3873     if (!item) {
3874     std::cerr << "/MenuBar/MenuSettings/SaveWithTemporaryFile == NULL\n";
3875     return;
3876     }
3877     Settings::singleton()->saveWithTemporaryFile = item->get_active();
3878 schoenebeck 3364 #endif
3879 schoenebeck 2967 }
3880    
3881 schoenebeck 2464 bool MainWindow::is_copy_samples_unity_note_enabled() const {
3882 schoenebeck 3364 #if USE_GLIB_ACTION
3883     bool active = false;
3884     m_actionToggleCopySampleUnity->get_state(active);
3885     return active;
3886     #else
3887 schoenebeck 2464 Gtk::CheckMenuItem* item =
3888     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleUnity"));
3889     if (!item) {
3890     std::cerr << "/MenuBar/MenuEdit/CopySampleUnity == NULL\n";
3891     return true;
3892     }
3893     return item->get_active();
3894 schoenebeck 3364 #endif
3895 schoenebeck 2464 }
3896    
3897     bool MainWindow::is_copy_samples_fine_tune_enabled() const {
3898 schoenebeck 3364 #if USE_GLIB_ACTION
3899     bool active = false;
3900     m_actionToggleCopySampleTune->get_state(active);
3901     return active;
3902     #else
3903 schoenebeck 2464 Gtk::CheckMenuItem* item =
3904     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleTune"));
3905     if (!item) {
3906     std::cerr << "/MenuBar/MenuEdit/CopySampleTune == NULL\n";
3907     return true;
3908     }
3909     return item->get_active();
3910 schoenebeck 3364 #endif
3911 schoenebeck 2464 }
3912    
3913     bool MainWindow::is_copy_samples_loop_enabled() const {
3914 schoenebeck 3364 #if USE_GLIB_ACTION
3915     bool active = false;
3916     m_actionToggleCopySampleLoop->get_state(active);
3917     return active;
3918     #else
3919 schoenebeck 2464 Gtk::CheckMenuItem* item =
3920     dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));
3921     if (!item) {
3922     std::cerr << "/MenuBar/MenuEdit/CopySampleLoop == NULL\n";
3923     return true;
3924     }
3925     return item->get_active();
3926 schoenebeck 3364 #endif
3927 schoenebeck 2464 }
3928    
3929 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
3930     bool MainWindow::on_button_release(Gdk::EventButton& _button) {
3931     GdkEventButton* button = _button.gobj();
3932     #else
3933     void MainWindow::on_button_release(GdkEventButton* button) {
3934     #endif
3935 schoenebeck 1225 if (button->type == GDK_2BUTTON_PRESS) {
3936 schoenebeck 3711 if (Settings::singleton()->instrumentDoubleClickOpensProps)
3937     show_instr_props();
3938 schoenebeck 1225 } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3939 persson 2507 // gig v2 files have no midi rules
3940 schoenebeck 2625 const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
3941 schoenebeck 3364 #if USE_GTKMM_BUILDER
3942     m_actionMIDIRules->property_enabled() = bEnabled;
3943     #else
3944 persson 2507 static_cast<Gtk::MenuItem*>(
3945 schoenebeck 2625 uiManager->get_widget("/MenuBar/MenuInstrument/MidiRules"))->set_sensitive(
3946     bEnabled
3947     );
3948     static_cast<Gtk::MenuItem*>(
3949 persson 2507 uiManager->get_widget("/PopupMenu/MidiRules"))->set_sensitive(
3950 schoenebeck 2625 bEnabled
3951     );
3952 schoenebeck 3364 #endif
3953 schoenebeck 1225 popup_menu->popup(button->button, button->time);
3954     }
3955 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
3956     return false;
3957     #endif
3958 schoenebeck 1225 }
3959    
3960 schoenebeck 3364 #if !USE_GTKMM_BUILDER
3961 persson 2442 void MainWindow::on_instrument_selection_change(Gtk::RadioMenuItem* item) {
3962     if (item->get_active()) {
3963     const std::vector<Gtk::Widget*> children =
3964     instrument_menu->get_children();
3965     std::vector<Gtk::Widget*>::const_iterator it =
3966     find(children.begin(), children.end(), item);
3967     if (it != children.end()) {
3968     int index = it - children.begin();
3969     m_TreeView.get_selection()->select(Gtk::TreePath(ToString(index)));
3970    
3971     m_RegionChooser.set_instrument(file->GetInstrument(index));
3972     }
3973     }
3974 schoenebeck 1225 }
3975 schoenebeck 3364 #endif
3976 schoenebeck 1225
3977 schoenebeck 3712 void MainWindow::on_action_move_instr() {
3978     gig::Instrument* instr = get_instrument();
3979     if (!instr) return;
3980    
3981     int currentIndex = getIndexOf(instr);
3982    
3983     Gtk::Dialog dialog(_("Move Instrument"), true /*modal*/);
3984     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
3985     Gtk::Adjustment adjustment(
3986     currentIndex,
3987     0 /*min*/, file->CountInstruments() - 1 /*max*/
3988     );
3989     Gtk::SpinButton spinBox(adjustment);
3990     #else
3991     Gtk::SpinButton spinBox(
3992     Gtk::Adjustment::create(
3993     currentIndex,
3994     0 /*min*/, file->CountInstruments() - 1 /*max*/
3995     )
3996     );
3997     #endif
3998     #if USE_GTKMM_BOX
3999     dialog.get_content_area()->pack_start(spinBox);
4000     #else
4001     dialog.get_vbox()->pack_start(spinBox);
4002     #endif
4003     #if HAS_GTKMM_STOCK
4004     Gtk::Button* okButton = dialog.add_button(Gtk::Stock::OK, 0);
4005     dialog.add_button(Gtk::Stock::CANCEL, 1);
4006     #else
4007     Gtk::Button* okButton = dialog.add_button(_("_OK"), 0);
4008     dialog.add_button(_("_Cancel"), 1);
4009     #endif
4010     okButton->set_sensitive(false);
4011     // show the dialog at a reasonable screen position
4012     dialog.set_position(Gtk::WIN_POS_MOUSE);
4013     // only enable the 'OK' button if entered new index is not instrument's
4014     // current index already
4015     spinBox.signal_value_changed().connect([&]{
4016     okButton->set_sensitive( spinBox.get_value_as_int() != currentIndex );
4017     });
4018     // usability acceleration: if user hits enter key on the text entry field
4019     // then auto trigger the 'OK' button
4020     spinBox.signal_activate().connect([&]{
4021     if (okButton->get_sensitive())
4022     okButton->clicked();
4023     });
4024     #if HAS_GTKMM_SHOW_ALL_CHILDREN
4025     dialog.show_all_children();
4026     #endif
4027     if (!dialog.run()) { // 'OK' selected ...
4028     int newIndex = spinBox.get_value_as_int();
4029     printf("MOVE TO %d\n", newIndex);
4030     gig::Instrument* dst = file->GetInstrument(newIndex);
4031     instr->MoveTo(dst);
4032     __refreshEntireGUI();
4033     select_instrument(instr);
4034     }
4035     }
4036    
4037 schoenebeck 2701 void MainWindow::select_instrument(gig::Instrument* instrument) {
4038     if (!instrument) return;
4039    
4040 schoenebeck 3340 //NOTE: This is a big mess! Sometimes GTK requires m_refTreeModelFilter->get_model(), here we need m_TreeView.get_model(), otherwise treeview selection below causes an error!
4041 schoenebeck 2701 Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
4042 schoenebeck 3340 //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
4043    
4044 schoenebeck 2701 for (int i = 0; i < model->children().size(); ++i) {
4045     Gtk::TreeModel::Row row = model->children()[i];
4046     if (row[m_Columns.m_col_instr] == instrument) {
4047     // select and show the respective instrument in the list view
4048     show_intruments_tab();
4049 schoenebeck 2994 m_TreeView.get_selection()->unselect_all();
4050 schoenebeck 3364
4051 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4052 schoenebeck 3364 auto iterSel = model->children()[i].get_iter();
4053     m_TreeView.get_selection()->select(iterSel);
4054     #else
4055 schoenebeck 2701 m_TreeView.get_selection()->select(model->children()[i]);
4056 schoenebeck 3364 #endif
4057 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4058     m_TreeView.get_selection()->get_selected_rows();
4059     if (!rows.empty())
4060     m_TreeView.scroll_to_row(rows[0]);
4061 schoenebeck 2701 on_sel_change(); // the regular instrument selection change callback
4062     }
4063     }
4064     }
4065    
4066 schoenebeck 2695 /// Returns true if requested dimension region was successfully selected and scrolled to in the list view, false on error.
4067     bool MainWindow::select_dimension_region(gig::DimensionRegion* dimRgn) {
4068     gig::Region* pRegion = (gig::Region*) dimRgn->GetParent();
4069     gig::Instrument* pInstrument = (gig::Instrument*) pRegion->GetParent();
4070    
4071 schoenebeck 3340 //NOTE: This is a big mess! Sometimes GTK requires m_refTreeModelFilter->get_model(), here we need m_TreeView.get_model(), otherwise treeview selection below causes an error!
4072 schoenebeck 2695 Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
4073 schoenebeck 3340 //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
4074    
4075 schoenebeck 2695 for (int i = 0; i < model->children().size(); ++i) {
4076     Gtk::TreeModel::Row row = model->children()[i];
4077     if (row[m_Columns.m_col_instr] == pInstrument) {
4078     // select and show the respective instrument in the list view
4079     show_intruments_tab();
4080 schoenebeck 2994 m_TreeView.get_selection()->unselect_all();
4081 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4082 schoenebeck 3364 auto iterSel = model->children()[i].get_iter();
4083     m_TreeView.get_selection()->select(iterSel);
4084     #else
4085 schoenebeck 2695 m_TreeView.get_selection()->select(model->children()[i]);
4086 schoenebeck 3364 #endif
4087 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4088     m_TreeView.get_selection()->get_selected_rows();
4089     if (!rows.empty())
4090     m_TreeView.scroll_to_row(rows[0]);
4091 schoenebeck 2695 on_sel_change(); // the regular instrument selection change callback
4092    
4093     // select respective region in the region selector
4094     m_RegionChooser.set_region(pRegion);
4095    
4096     // select and show the respective dimension region in the editor
4097     //update_dimregs();
4098     if (!m_DimRegionChooser.select_dimregion(dimRgn)) return false;
4099     //dimreg_edit.set_dim_region(dimRgn);
4100    
4101     return true;
4102     }
4103     }
4104    
4105     return false;
4106     }
4107    
4108 schoenebeck 2691 void MainWindow::select_sample(gig::Sample* sample) {
4109     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewSamples.get_model();
4110     for (int g = 0; g < model->children().size(); ++g) {
4111     Gtk::TreeModel::Row rowGroup = model->children()[g];
4112     for (int s = 0; s < rowGroup.children().size(); ++s) {
4113     Gtk::TreeModel::Row rowSample = rowGroup.children()[s];
4114     if (rowSample[m_SamplesModel.m_col_sample] == sample) {
4115     show_samples_tab();
4116 schoenebeck 2994 m_TreeViewSamples.get_selection()->unselect_all();
4117 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
4118 schoenebeck 3364 auto iterSel = rowGroup.children()[s].get_iter();
4119     m_TreeViewSamples.get_selection()->select(iterSel);
4120     #else
4121 schoenebeck 2691 m_TreeViewSamples.get_selection()->select(rowGroup.children()[s]);
4122 schoenebeck 3364 #endif
4123 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows =
4124     m_TreeViewSamples.get_selection()->get_selected_rows();
4125     if (rows.empty()) return;
4126     m_TreeViewSamples.scroll_to_row(rows[0]);
4127 schoenebeck 2691 return;
4128     }
4129     }
4130     }
4131     }
4132    
4133 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
4134     bool MainWindow::on_sample_treeview_button_release(Gdk::EventButton& _button) {
4135     GdkEventButton* button = _button.gobj();
4136     #else
4137 schoenebeck 1225 void MainWindow::on_sample_treeview_button_release(GdkEventButton* button) {
4138 schoenebeck 3364 #endif
4139 schoenebeck 1225 if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
4140 schoenebeck 2994 // by default if Ctrl keys is pressed down, then a mouse right-click
4141     // does not select the respective row, so we must assure this
4142     // programmatically ...
4143     /*{
4144     Gtk::TreeModel::Path path;
4145     Gtk::TreeViewColumn* pColumn = NULL;
4146     int cellX, cellY;
4147     bool bSuccess = m_TreeViewSamples.get_path_at_pos(
4148     (int)button->x, (int)button->y,
4149     path, pColumn, cellX, cellY
4150     );
4151     if (bSuccess) {
4152     if (m_TreeViewSamples.get_selection()->count_selected_rows() <= 0) {
4153     printf("not selected !!!\n");
4154     m_TreeViewSamples.get_selection()->select(path);
4155     }
4156     }
4157     }*/
4158    
4159 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4160 schoenebeck 1225 Gtk::Menu* sample_popup =
4161     dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/SamplePopupMenu"));
4162 schoenebeck 3364 #endif
4163    
4164 schoenebeck 1225 // update enabled/disabled state of sample popup items
4165     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4166 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4167     const int n = rows.size();
4168     int nGroups = 0;
4169     int nSamples = 0;
4170     for (int r = 0; r < n; ++r) {
4171     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4172     if (!it) continue;
4173 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4174 schoenebeck 2994 if (row[m_SamplesModel.m_col_group]) nGroups++;
4175     if (row[m_SamplesModel.m_col_sample]) nSamples++;
4176 schoenebeck 1225 }
4177 schoenebeck 2994
4178 schoenebeck 3364 #if USE_GTKMM_BUILDER
4179     m_actionSampleProperties->property_enabled() = (n == 1);
4180     m_actionAddSample->property_enabled() = (n);
4181     m_actionAddSampleGroup->property_enabled() = (file);
4182     m_actionViewSampleRefs->property_enabled() = (nSamples == 1);
4183     m_actionRemoveSample->property_enabled() = (n);
4184     m_actionReplaceSample->property_enabled() = (nSamples == 1);
4185     #else
4186 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/SampleProperties"))->
4187 schoenebeck 2994 set_sensitive(n == 1);
4188 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddSample"))->
4189 schoenebeck 2994 set_sensitive(n);
4190 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddGroup"))->
4191     set_sensitive(file);
4192 schoenebeck 2624 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/ShowSampleRefs"))->
4193 schoenebeck 2994 set_sensitive(nSamples == 1);
4194 schoenebeck 1225 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/RemoveSample"))->
4195 schoenebeck 2994 set_sensitive(n);
4196 schoenebeck 3364 #endif
4197 schoenebeck 1225 // show sample popup
4198     sample_popup->popup(button->button, button->time);
4199 schoenebeck 2625
4200 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4201 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/SampleProperties"))->
4202 schoenebeck 2994 set_sensitive(n == 1);
4203 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddSample"))->
4204 schoenebeck 2994 set_sensitive(n);
4205 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddGroup"))->
4206     set_sensitive(file);
4207     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/ShowSampleRefs"))->
4208 schoenebeck 2994 set_sensitive(nSamples == 1);
4209 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/RemoveSample"))->
4210 schoenebeck 2994 set_sensitive(n);
4211 schoenebeck 3364 #endif
4212 schoenebeck 1225 }
4213 schoenebeck 3364
4214     #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
4215     return false;
4216     #endif
4217 schoenebeck 1225 }
4218    
4219 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
4220     bool MainWindow::on_script_treeview_button_release(Gdk::EventButton& _button) {
4221     GdkEventButton* button = _button.gobj();
4222     #else
4223 schoenebeck 2604 void MainWindow::on_script_treeview_button_release(GdkEventButton* button) {
4224 schoenebeck 3364 #endif
4225 schoenebeck 2604 if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
4226 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4227 schoenebeck 2604 Gtk::Menu* script_popup =
4228     dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/ScriptPopupMenu"));
4229 schoenebeck 3364 #endif
4230 schoenebeck 2604 // update enabled/disabled state of sample popup items
4231     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4232     Gtk::TreeModel::iterator it = sel->get_selected();
4233     bool group_selected = false;
4234     bool script_selected = false;
4235     if (it) {
4236     Gtk::TreeModel::Row row = *it;
4237     group_selected = row[m_ScriptsModel.m_col_group];
4238     script_selected = row[m_ScriptsModel.m_col_script];
4239     }
4240 schoenebeck 3364 #if USE_GTKMM_BUILDER
4241     m_actionAddScript->property_enabled() = (group_selected || script_selected);
4242     m_actionAddScriptGroup->property_enabled() = (file);
4243     m_actionEditScript->property_enabled() = (script_selected);
4244     m_actionRemoveScript->property_enabled() = (group_selected || script_selected);
4245     #else
4246 schoenebeck 2604 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScript"))->
4247     set_sensitive(group_selected || script_selected);
4248     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScriptGroup"))->
4249     set_sensitive(file);
4250     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/EditScript"))->
4251     set_sensitive(script_selected);
4252     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/RemoveScript"))->
4253     set_sensitive(group_selected || script_selected);
4254 schoenebeck 3364 #endif
4255 schoenebeck 2604 // show sample popup
4256     script_popup->popup(button->button, button->time);
4257 schoenebeck 2625
4258 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4259 schoenebeck 2625 dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScript"))->
4260     set_sensitive(group_selected || script_selected);
4261     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScriptGroup"))->
4262     set_sensitive(file);
4263     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/EditScript"))->
4264     set_sensitive(script_selected);
4265     dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/RemoveScript"))->
4266     set_sensitive(group_selected || script_selected);
4267 schoenebeck 3364 #endif
4268 schoenebeck 2604 }
4269 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
4270     return false;
4271     #endif
4272 schoenebeck 2604 }
4273 persson 2442
4274 schoenebeck 3339 void MainWindow::updateScriptListOfMenu() {
4275     // remove all entries from "Assign Script" menu
4276     {
4277     const std::vector<Gtk::Widget*> children = assign_scripts_menu->get_children();
4278     for (int i = 0; i < children.size(); ++i) {
4279     Gtk::Widget* child = children[i];
4280     assign_scripts_menu->remove(*child);
4281     delete child;
4282     }
4283     }
4284    
4285     int iTotalScripts = 0;
4286    
4287     if (!file) goto noScripts;
4288    
4289     // add all configured macros as menu items to the "Macro" menu
4290     for (int iGroup = 0; file->GetScriptGroup(iGroup); ++iGroup) {
4291     gig::ScriptGroup* pGroup = file->GetScriptGroup(iGroup);
4292     for (int iScript = 0; pGroup->GetScript(iScript); ++iScript, ++iTotalScripts) {
4293     gig::Script* pScript = pGroup->GetScript(iScript);
4294     std::string name = pScript->Name;
4295    
4296     Gtk::MenuItem* item = new Gtk::MenuItem(name);
4297     item->signal_activate().connect(
4298     sigc::bind(
4299     sigc::mem_fun(*this, &MainWindow::assignScript), pScript
4300     )
4301     );
4302     assign_scripts_menu->append(*item);
4303     item->set_accel_path("<Scripts>/script_" + ToString(iTotalScripts));
4304     //item->set_tooltip_text(comment);
4305     }
4306     }
4307    
4308     noScripts:
4309    
4310     // if there are no macros configured at all, then show a dummy entry instead
4311     if (!iTotalScripts) {
4312     Gtk::MenuItem* item = new Gtk::MenuItem(_("No Scripts"));
4313     item->set_sensitive(false);
4314     assign_scripts_menu->append(*item);
4315     }
4316    
4317 schoenebeck 3419 // add separator line to menu
4318     assign_scripts_menu->append(*new Gtk::SeparatorMenuItem);
4319    
4320     {
4321     Gtk::MenuItem* item = new Gtk::MenuItem(_("Unassign All Scripts"));
4322     item->signal_activate().connect(
4323     sigc::mem_fun(*this, &MainWindow::dropAllScriptSlots)
4324     );
4325     assign_scripts_menu->append(*item);
4326     item->set_accel_path("<Scripts>/DropAllScriptSlots");
4327     }
4328    
4329 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
4330 schoenebeck 3339 assign_scripts_menu->show_all_children();
4331 schoenebeck 3364 #endif
4332 schoenebeck 3339 }
4333    
4334 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4335 persson 2442 Gtk::RadioMenuItem* MainWindow::add_instrument_to_menu(
4336     const Glib::ustring& name, int position) {
4337    
4338     Gtk::RadioMenuItem::Group instrument_group;
4339     const std::vector<Gtk::Widget*> children = instrument_menu->get_children();
4340     if (!children.empty()) {
4341     instrument_group =
4342     static_cast<Gtk::RadioMenuItem*>(children[0])->get_group();
4343     }
4344     Gtk::RadioMenuItem* item =
4345     new Gtk::RadioMenuItem(instrument_group, name);
4346     if (position < 0) {
4347     instrument_menu->append(*item);
4348     } else {
4349     instrument_menu->insert(*item, position);
4350     }
4351     item->show();
4352     item->signal_activate().connect(
4353     sigc::bind(
4354     sigc::mem_fun(*this, &MainWindow::on_instrument_selection_change),
4355     item));
4356     return item;
4357     }
4358 schoenebeck 3364 #endif
4359 persson 2442
4360 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4361 persson 2442 void MainWindow::remove_instrument_from_menu(int index) {
4362     const std::vector<Gtk::Widget*> children =
4363     instrument_menu->get_children();
4364     Gtk::Widget* child = children[index];
4365     instrument_menu->remove(*child);
4366     delete child;
4367     }
4368 schoenebeck 3364 #endif
4369 persson 2442
4370     void MainWindow::add_instrument(gig::Instrument* instrument) {
4371 persson 2446 const Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
4372 persson 2442
4373     // update instrument tree view
4374     instrument_name_connection.block();
4375     Gtk::TreeModel::iterator iterInstr = m_refTreeModel->append();
4376     Gtk::TreeModel::Row rowInstr = *iterInstr;
4377 schoenebeck 3418 const int index = m_refTreeModel->children().size() - 1;
4378 schoenebeck 3800 const int iScriptSlots = instrument->ScriptSlotCount();
4379 schoenebeck 3418 rowInstr[m_Columns.m_col_nr] = index;
4380 persson 2442 rowInstr[m_Columns.m_col_name] = name;
4381     rowInstr[m_Columns.m_col_instr] = instrument;
4382 schoenebeck 3800 rowInstr[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
4383 schoenebeck 3418 rowInstr[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
4384 persson 2442 instrument_name_connection.unblock();
4385    
4386 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4387 persson 2442 add_instrument_to_menu(name);
4388 schoenebeck 3364 #endif
4389 schoenebeck 3339 select_instrument(instrument);
4390 persson 2442 file_changed();
4391     }
4392    
4393 schoenebeck 1225 void MainWindow::on_action_add_instrument() {
4394     static int __instrument_indexer = 0;
4395     if (!file) return;
4396     gig::Instrument* instrument = file->AddInstrument();
4397     __instrument_indexer++;
4398 persson 2446 instrument->pInfo->Name = gig_from_utf8(_("Unnamed Instrument ") +
4399     ToString(__instrument_indexer));
4400 persson 2442
4401     add_instrument(instrument);
4402 schoenebeck 1225 }
4403    
4404 schoenebeck 2395 void MainWindow::on_action_duplicate_instrument() {
4405     if (!file) return;
4406 persson 2442
4407 schoenebeck 2395 // retrieve the currently selected instrument
4408     // (being the original instrument to be duplicated)
4409     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
4410 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4411     for (int r = 0; r < rows.size(); ++r) {
4412     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
4413     if (it) {
4414     Gtk::TreeModel::Row row = *it;
4415     gig::Instrument* instrOrig = row[m_Columns.m_col_instr];
4416     if (instrOrig) {
4417     // duplicate the orginal instrument
4418     gig::Instrument* instrNew = file->AddDuplicateInstrument(instrOrig);
4419     instrNew->pInfo->Name =
4420     instrOrig->pInfo->Name +
4421     gig_from_utf8(Glib::ustring(" (") + _("Copy") + ")");
4422 persson 2442
4423 schoenebeck 2994 add_instrument(instrNew);
4424     }
4425     }
4426     }
4427 schoenebeck 2395 }
4428    
4429 schoenebeck 1225 void MainWindow::on_action_remove_instrument() {
4430     if (!file) return;
4431 schoenebeck 1382 if (file_is_shared) {
4432     Gtk::MessageDialog msg(
4433     *this,
4434     _("You cannot delete an instrument from this file, since it's "
4435     "currently used by the sampler."),
4436     false, Gtk::MESSAGE_INFO
4437     );
4438     msg.run();
4439     return;
4440     }
4441    
4442 schoenebeck 1225 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
4443 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4444     for (int r = rows.size() - 1; r >= 0; --r) {
4445     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
4446     if (!it) continue;
4447 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4448     gig::Instrument* instr = row[m_Columns.m_col_instr];
4449     try {
4450 persson 2442 Gtk::TreePath path(it);
4451     int index = path[0];
4452    
4453 schoenebeck 1225 // remove instrument from the gig file
4454     if (instr) file->DeleteInstrument(instr);
4455 persson 1261 file_changed();
4456 persson 2423
4457 schoenebeck 3364 #if !USE_GTKMM_BUILDER
4458 persson 2442 remove_instrument_from_menu(index);
4459 schoenebeck 3364 #endif
4460 persson 2442
4461     // remove row from instruments tree view
4462     m_refTreeModel->erase(it);
4463 schoenebeck 2994 // update "Nr" column of all instrument rows
4464     {
4465     int index = 0;
4466     for (Gtk::TreeModel::iterator it = m_refTreeModel->children().begin();
4467     it != m_refTreeModel->children().end(); ++it, ++index)
4468     {
4469     Gtk::TreeModel::Row row = *it;
4470 schoenebeck 3418 gig::Instrument* instrument = row[m_Columns.m_col_instr];
4471 schoenebeck 2994 row[m_Columns.m_col_nr] = index;
4472 schoenebeck 3418 row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
4473 schoenebeck 2994 }
4474     }
4475 persson 2442
4476     #if GTKMM_MAJOR_VERSION < 3
4477     // select another instrument (in gtk3 this is done
4478     // automatically)
4479     if (!m_refTreeModel->children().empty()) {
4480     if (index == m_refTreeModel->children().size()) {
4481     index--;
4482     }
4483     m_TreeView.get_selection()->select(
4484     Gtk::TreePath(ToString(index)));
4485     }
4486     #endif
4487 persson 2445 instr_props_set_instrument();
4488 persson 2507 instr = get_instrument();
4489     if (instr) {
4490     midiRules.set_instrument(instr);
4491     } else {
4492     midiRules.hide();
4493     }
4494 schoenebeck 1225 } catch (RIFF::Exception e) {
4495     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
4496     msg.run();
4497     }
4498     }
4499     }
4500    
4501     void MainWindow::on_action_sample_properties() {
4502 schoenebeck 3637 show_sample_props();
4503 schoenebeck 1225 }
4504    
4505 schoenebeck 2604 void MainWindow::on_action_add_script_group() {
4506     static int __script_indexer = 0;
4507     if (!file) return;
4508     gig::ScriptGroup* group = file->AddScriptGroup();
4509     group->Name = gig_from_utf8(_("Unnamed Group"));
4510     if (__script_indexer) group->Name += " " + ToString(__script_indexer);
4511     __script_indexer++;
4512     // update sample tree view
4513     Gtk::TreeModel::iterator iterGroup = m_refScriptsTreeModel->append();
4514     Gtk::TreeModel::Row rowGroup = *iterGroup;
4515     rowGroup[m_ScriptsModel.m_col_name] = gig_to_utf8(group->Name);
4516     rowGroup[m_ScriptsModel.m_col_script] = NULL;
4517     rowGroup[m_ScriptsModel.m_col_group] = group;
4518     file_changed();
4519     }
4520    
4521     void MainWindow::on_action_add_script() {
4522     if (!file) return;
4523     // get selected group
4524     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4525     Gtk::TreeModel::iterator it = sel->get_selected();
4526     if (!it) return;
4527     Gtk::TreeModel::Row row = *it;
4528     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
4529     if (!group) { // not a group, but a script is selected (probably)
4530     gig::Script* script = row[m_ScriptsModel.m_col_script];
4531     if (!script) return;
4532     it = row.parent(); // resolve parent (that is the script's group)
4533     if (!it) return;
4534     row = *it;
4535     group = row[m_ScriptsModel.m_col_group];
4536     if (!group) return;
4537     }
4538    
4539     // add a new script to the .gig file
4540     gig::Script* script = group->AddScript();
4541     Glib::ustring name = _("Unnamed Script");
4542     script->Name = gig_from_utf8(name);
4543    
4544     // add script to the tree view
4545     Gtk::TreeModel::iterator iterScript =
4546     m_refScriptsTreeModel->append(row.children());
4547     Gtk::TreeModel::Row rowScript = *iterScript;
4548     rowScript[m_ScriptsModel.m_col_name] = name;
4549     rowScript[m_ScriptsModel.m_col_script] = script;
4550     rowScript[m_ScriptsModel.m_col_group] = NULL;
4551    
4552     // unfold group of new script item in treeview
4553     Gtk::TreeModel::Path path(iterScript);
4554     m_TreeViewScripts.expand_to_path(path);
4555     }
4556    
4557     void MainWindow::on_action_edit_script() {
4558     if (!file) return;
4559     // get selected script
4560     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4561     Gtk::TreeModel::iterator it = sel->get_selected();
4562     if (!it) return;
4563     Gtk::TreeModel::Row row = *it;
4564     gig::Script* script = row[m_ScriptsModel.m_col_script];
4565 schoenebeck 3749 editScript(script);
4566     }
4567    
4568     void MainWindow::editScript(gig::Script* script) {
4569 schoenebeck 2604 if (!script) return;
4570     ScriptEditor* editor = new ScriptEditor;
4571 schoenebeck 2903 editor->signal_script_to_be_changed.connect(
4572     signal_script_to_be_changed.make_slot()
4573     );
4574 schoenebeck 3750 editor->signal_script_changed.connect([this](gig::Script* script) {
4575     // signal to sampler (which will reload the script due to this)
4576     signal_script_changed.emit(script);
4577     // force script 'patch' variables editor ("Script" tab) to be refreshed
4578     gig::Instrument* instr = get_instrument();
4579     dimreg_edit.scriptVars.setInstrument(instr, true/*force update*/);
4580     });
4581 schoenebeck 2604 editor->setScript(script);
4582     //editor->reparent(*this);
4583     editor->show();
4584     }
4585    
4586     void MainWindow::on_action_remove_script() {
4587     if (!file) return;
4588     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4589     Gtk::TreeModel::iterator it = sel->get_selected();
4590     if (it) {
4591     Gtk::TreeModel::Row row = *it;
4592     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
4593     gig::Script* script = row[m_ScriptsModel.m_col_script];
4594     Glib::ustring name = row[m_ScriptsModel.m_col_name];
4595     try {
4596     // remove script group or script from the gig file
4597     if (group) {
4598     // notify everybody that we're going to remove these samples
4599     //TODO: scripts_to_be_removed_signal.emit(members);
4600     // delete the group in the .gig file including the
4601     // samples that belong to the group
4602     file->DeleteScriptGroup(group);
4603     // notify that we're done with removal
4604     //TODO: scripts_removed_signal.emit();
4605     file_changed();
4606     } else if (script) {
4607     // notify everybody that we're going to remove this sample
4608     //TODO: std::list<gig::Script*> lscripts;
4609     //TODO: lscripts.push_back(script);
4610     //TODO: scripts_to_be_removed_signal.emit(lscripts);
4611     // remove sample from the .gig file
4612     script->GetGroup()->DeleteScript(script);
4613     // notify that we're done with removal
4614     //TODO: scripts_removed_signal.emit();
4615     dimreg_changed();
4616     file_changed();
4617     }
4618     // remove respective row(s) from samples tree view
4619     m_refScriptsTreeModel->erase(it);
4620     } catch (RIFF::Exception e) {
4621     // pretend we're done with removal (i.e. to avoid dead locks)
4622     //TODO: scripts_removed_signal.emit();
4623     // show error message
4624     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
4625     msg.run();
4626     }
4627     }
4628     }
4629    
4630 schoenebeck 1225 void MainWindow::on_action_add_group() {
4631     static int __sample_indexer = 0;
4632     if (!file) return;
4633     gig::Group* group = file->AddGroup();
4634 persson 2446 group->Name = gig_from_utf8(_("Unnamed Group"));
4635 schoenebeck 1225 if (__sample_indexer) group->Name += " " + ToString(__sample_indexer);
4636     __sample_indexer++;
4637     // update sample tree view
4638     Gtk::TreeModel::iterator iterGroup = m_refSamplesTreeModel->append();
4639     Gtk::TreeModel::Row rowGroup = *iterGroup;
4640 persson 2446 rowGroup[m_SamplesModel.m_col_name] = gig_to_utf8(group->Name);
4641 schoenebeck 1225 rowGroup[m_SamplesModel.m_col_sample] = NULL;
4642     rowGroup[m_SamplesModel.m_col_group] = group;
4643 persson 1261 file_changed();
4644 schoenebeck 1225 }
4645    
4646 schoenebeck 2715 void MainWindow::on_action_replace_sample() {
4647     add_or_replace_sample(true);
4648     }
4649    
4650 schoenebeck 1225 void MainWindow::on_action_add_sample() {
4651 schoenebeck 2715 add_or_replace_sample(false);
4652     }
4653    
4654     void MainWindow::add_or_replace_sample(bool replace) {
4655 schoenebeck 1225 if (!file) return;
4656 schoenebeck 2715
4657     // get selected group (and probably selected sample)
4658 schoenebeck 1225 Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4659 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4660     if (rows.empty()) return;
4661     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
4662 schoenebeck 1225 if (!it) return;
4663     Gtk::TreeModel::Row row = *it;
4664 schoenebeck 2715 gig::Sample* sample = NULL;
4665 schoenebeck 1225 gig::Group* group = row[m_SamplesModel.m_col_group];
4666     if (!group) { // not a group, but a sample is selected (probably)
4667 schoenebeck 2715 if (replace) sample = row[m_SamplesModel.m_col_sample];
4668     if (!row[m_SamplesModel.m_col_sample]) return;
4669 schoenebeck 1225 it = row.parent(); // resolve parent (that is the sample's group)
4670     if (!it) return;
4671 schoenebeck 2715 if (!replace) row = *it;
4672     group = (*it)[m_SamplesModel.m_col_group];
4673 schoenebeck 1225 if (!group) return;
4674     }
4675 schoenebeck 2715 if (replace && !sample) return;
4676    
4677 schoenebeck 1225 // show 'browse for file' dialog
4678 schoenebeck 2715 Gtk::FileChooserDialog dialog(*this, replace ? _("Replace Sample with") : _("Add Sample(s)"));
4679 schoenebeck 3364 #if HAS_GTKMM_STOCK
4680 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4681     dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
4682 schoenebeck 3364 #else
4683     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4684     dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
4685     #endif
4686 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
4687 persson 2169
4688     // matches all file types supported by libsndfile
4689     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
4690     Gtk::FileFilter soundfilter;
4691     #else
4692     Glib::RefPtr<Gtk::FileFilter> soundfilter = Gtk::FileFilter::create();
4693     #endif
4694 persson 1262 const char* const supportedFileTypes[] = {
4695 schoenebeck 1225 "*.wav", "*.WAV", "*.aiff", "*.AIFF", "*.aifc", "*.AIFC", "*.snd",
4696     "*.SND", "*.au", "*.AU", "*.paf", "*.PAF", "*.iff", "*.IFF",
4697     "*.svx", "*.SVX", "*.sf", "*.SF", "*.voc", "*.VOC", "*.w64",
4698     "*.W64", "*.pvf", "*.PVF", "*.xi", "*.XI", "*.htk", "*.HTK",
4699     "*.caf", "*.CAF", NULL
4700     };
4701 persson 2169 const char* soundfiles = _("Sound Files");
4702     const char* allfiles = _("All Files");
4703     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
4704 schoenebeck 1225 for (int i = 0; supportedFileTypes[i]; i++)
4705     soundfilter.add_pattern(supportedFileTypes[i]);
4706 persson 2169 soundfilter.set_name(soundfiles);
4707    
4708     // matches every file
4709     Gtk::FileFilter allpassfilter;
4710 schoenebeck 1225 allpassfilter.add_pattern("*.*");
4711 persson 2169 allpassfilter.set_name(allfiles);
4712     #else
4713     for (int i = 0; supportedFileTypes[i]; i++)
4714     soundfilter->add_pattern(supportedFileTypes[i]);
4715     soundfilter->set_name(soundfiles);
4716    
4717     // matches every file
4718     Glib::RefPtr<Gtk::FileFilter> allpassfilter = Gtk::FileFilter::create();
4719     allpassfilter->add_pattern("*.*");
4720     allpassfilter->set_name(allfiles);
4721     #endif
4722 schoenebeck 1225 dialog.add_filter(soundfilter);
4723     dialog.add_filter(allpassfilter);
4724 persson 1725 if (current_sample_dir != "") {
4725     dialog.set_current_folder(current_sample_dir);
4726     }
4727 schoenebeck 1225 if (dialog.run() == Gtk::RESPONSE_OK) {
4728 persson 3477 dialog.hide();
4729 persson 1725 current_sample_dir = dialog.get_current_folder();
4730 schoenebeck 1225 Glib::ustring error_files;
4731 persson 2169 std::vector<std::string> filenames = dialog.get_filenames();
4732     for (std::vector<std::string>::iterator iter = filenames.begin();
4733 schoenebeck 1225 iter != filenames.end(); ++iter) {
4734     printf("Adding sample %s\n",(*iter).c_str());
4735 schoenebeck 3408 // use libsndfile to retrieve file information
4736 schoenebeck 1225 SF_INFO info;
4737     info.format = 0;
4738     SNDFILE* hFile = sf_open((*iter).c_str(), SFM_READ, &info);
4739     try {
4740 persson 1831 if (!hFile) throw std::string(_("could not open file"));
4741 schoenebeck 1225 int bitdepth;
4742     switch (info.format & 0xff) {
4743     case SF_FORMAT_PCM_S8:
4744     case SF_FORMAT_PCM_16:
4745 persson 1265 case SF_FORMAT_PCM_U8:
4746 schoenebeck 1225 bitdepth = 16;
4747     break;
4748     case SF_FORMAT_PCM_24:
4749     case SF_FORMAT_PCM_32:
4750     case SF_FORMAT_FLOAT:
4751     case SF_FORMAT_DOUBLE:
4752 persson 1265 bitdepth = 24;
4753 schoenebeck 1225 break;
4754     default:
4755     sf_close(hFile); // close sound file
4756 persson 1831 throw std::string(_("format not supported")); // unsupported subformat (yet?)
4757 schoenebeck 1225 }
4758 schoenebeck 2715 // add a new sample to the .gig file (if adding is requested actually)
4759     if (!replace) sample = file->AddSample();
4760 schoenebeck 1225 // file name without path
4761 persson 1262 Glib::ustring filename = Glib::filename_display_basename(*iter);
4762     // remove file extension if there is one
4763     for (int i = 0; supportedFileTypes[i]; i++) {
4764     if (Glib::str_has_suffix(filename, supportedFileTypes[i] + 1)) {
4765     filename.erase(filename.length() - strlen(supportedFileTypes[i] + 1));
4766     break;
4767     }
4768     }
4769 persson 2446 sample->pInfo->Name = gig_from_utf8(filename);
4770 schoenebeck 1225 sample->Channels = info.channels;
4771     sample->BitDepth = bitdepth;
4772     sample->FrameSize = bitdepth / 8/*1 byte are 8 bits*/ * info.channels;
4773     sample->SamplesPerSecond = info.samplerate;
4774 persson 1265 sample->AverageBytesPerSecond = sample->FrameSize * sample->SamplesPerSecond;
4775     sample->BlockAlign = sample->FrameSize;
4776     sample->SamplesTotal = info.frames;
4777    
4778     SF_INSTRUMENT instrument;
4779     if (sf_command(hFile, SFC_GET_INSTRUMENT,
4780     &instrument, sizeof(instrument)) != SF_FALSE)
4781     {
4782     sample->MIDIUnityNote = instrument.basenote;
4783 schoenebeck 2466 sample->FineTune = instrument.detune;
4784 persson 1265
4785     if (instrument.loop_count && instrument.loops[0].mode != SF_LOOP_NONE) {
4786     sample->Loops = 1;
4787    
4788     switch (instrument.loops[0].mode) {
4789     case SF_LOOP_FORWARD:
4790     sample->LoopType = gig::loop_type_normal;
4791     break;
4792     case SF_LOOP_BACKWARD:
4793     sample->LoopType = gig::loop_type_backward;
4794     break;
4795     case SF_LOOP_ALTERNATING:
4796     sample->LoopType = gig::loop_type_bidirectional;
4797     break;
4798     }
4799     sample->LoopStart = instrument.loops[0].start;
4800     sample->LoopEnd = instrument.loops[0].end;
4801     sample->LoopPlayCount = instrument.loops[0].count;
4802     sample->LoopSize = sample->LoopEnd - sample->LoopStart + 1;
4803     }
4804     }
4805    
4806 schoenebeck 1225 // schedule resizing the sample (which will be done
4807     // physically when File::Save() is called)
4808     sample->Resize(info.frames);
4809     // make sure sample is part of the selected group
4810 schoenebeck 2715 if (!replace) group->AddSample(sample);
4811 schoenebeck 1225 // schedule that physical resize and sample import
4812     // (data copying), performed when "Save" is requested
4813     SampleImportItem sched_item;
4814     sched_item.gig_sample = sample;
4815     sched_item.sample_path = *iter;
4816 schoenebeck 3116 m_SampleImportQueue[sample] = sched_item;
4817 schoenebeck 1225 // add sample to the tree view
4818 schoenebeck 2715 if (replace) {
4819     row[m_SamplesModel.m_col_name] = gig_to_utf8(sample->pInfo->Name);
4820     } else {
4821     Gtk::TreeModel::iterator iterSample =
4822     m_refSamplesTreeModel->append(row.children());
4823     Gtk::TreeModel::Row rowSample = *iterSample;
4824     rowSample[m_SamplesModel.m_col_name] =
4825     gig_to_utf8(sample->pInfo->Name);
4826     rowSample[m_SamplesModel.m_col_sample] = sample;
4827     rowSample[m_SamplesModel.m_col_group] = NULL;
4828     }
4829 schoenebeck 1225 // close sound file
4830     sf_close(hFile);
4831 persson 1261 file_changed();
4832 schoenebeck 1225 } catch (std::string what) { // remember the files that made trouble (and their cause)
4833 persson 2442 if (!error_files.empty()) error_files += "\n";
4834 schoenebeck 1225 error_files += *iter += " (" + what + ")";
4835     }
4836     }
4837     // show error message box when some file(s) could not be opened / added
4838 persson 2442 if (!error_files.empty()) {
4839 schoenebeck 2715 Glib::ustring txt =
4840     (replace
4841     ? _("Failed to replace sample with:\n")
4842     : _("Could not add the following sample(s):\n"))
4843     + error_files;
4844 schoenebeck 1225 Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
4845     msg.run();
4846     }
4847     }
4848     }
4849    
4850 schoenebeck 1673 void MainWindow::on_action_replace_all_samples_in_all_groups()
4851     {
4852     if (!file) return;
4853     Gtk::FileChooserDialog dialog(*this, _("Select Folder"),
4854     Gtk::FILE_CHOOSER_ACTION_SELECT_FOLDER);
4855 persson 2442 const char* str =
4856 schoenebeck 1673 _("This is a very specific function. It tries to replace all samples "
4857 persson 1799 "in the current gig file by samples located in the chosen "
4858     "directory.\n\n"
4859     "It works like this: For each sample in the gig file, it tries to "
4860 schoenebeck 1673 "find a sample file in the selected directory with the same name as "
4861 persson 1799 "the sample in the gig file. Optionally, you can add a filename "
4862     "extension below, which will be added to the filename expected to be "
4863 schoenebeck 1673 "found. That is, assume you have a gig file with a sample called "
4864     "'Snare', if you enter '.wav' below (like it's done by default), it "
4865 persson 1799 "expects to find a sample file called 'Snare.wav' and will replace "
4866     "the sample in the gig file accordingly. If you don't need an "
4867     "extension, blank the field below. Any gig sample where no "
4868     "appropriate sample file could be found will be reported and left "
4869 persson 2344 "untouched.\n");
4870     #if GTKMM_MAJOR_VERSION < 3
4871     view::WrapLabel description(str);
4872     #else
4873     Gtk::Label description(str);
4874     description.set_line_wrap();
4875     #endif
4876 schoenebeck 3364 HBox entryArea;
4877 persson 2169 Gtk::Label entryLabel( _("Add filename extension: "), Gtk::ALIGN_START);
4878 schoenebeck 1673 Gtk::Entry postfixEntryBox;
4879     postfixEntryBox.set_text(".wav");
4880     entryArea.pack_start(entryLabel);
4881     entryArea.pack_start(postfixEntryBox);
4882 schoenebeck 3364 #if USE_GTKMM_BOX
4883     dialog.get_content_area()->pack_start(description, Gtk::PACK_SHRINK);
4884     dialog.get_content_area()->pack_start(entryArea, Gtk::PACK_SHRINK);
4885     #else
4886 schoenebeck 1673 dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
4887     dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
4888 schoenebeck 3364 #endif
4889 schoenebeck 1673 description.show();
4890 schoenebeck 3364
4891     #if HAS_GTKMM_SHOW_ALL_CHILDREN
4892 persson 1799 entryArea.show_all();
4893 schoenebeck 3364 #else
4894     entryArea.show();
4895     #endif
4896    
4897     #if HAS_GTKMM_STOCK
4898 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4899 schoenebeck 3364 #else
4900     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4901     #endif
4902 schoenebeck 1673 dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
4903     dialog.set_select_multiple(false);
4904 persson 1725 if (current_sample_dir != "") {
4905     dialog.set_current_folder(current_sample_dir);
4906     }
4907 schoenebeck 1673 if (dialog.run() == Gtk::RESPONSE_OK)
4908     {
4909 persson 3477 dialog.hide();
4910 persson 1725 current_sample_dir = dialog.get_current_folder();
4911 schoenebeck 1673 Glib::ustring error_files;
4912 persson 2169 std::string folder = dialog.get_filename();
4913 schoenebeck 1673 for (gig::Sample* sample = file->GetFirstSample();
4914     sample; sample = file->GetNextSample())
4915     {
4916     std::string filename =
4917 persson 2446 folder + G_DIR_SEPARATOR_S +
4918     Glib::filename_from_utf8(gig_to_utf8(sample->pInfo->Name) +
4919     postfixEntryBox.get_text());
4920 schoenebeck 1673 SF_INFO info;
4921     info.format = 0;
4922     SNDFILE* hFile = sf_open(filename.c_str(), SFM_READ, &info);
4923     try
4924     {
4925 persson 1831 if (!hFile) throw std::string(_("could not open file"));
4926 schoenebeck 1673 switch (info.format & 0xff) {
4927     case SF_FORMAT_PCM_S8:
4928     case SF_FORMAT_PCM_16:
4929     case SF_FORMAT_PCM_U8:
4930     case SF_FORMAT_PCM_24:
4931     case SF_FORMAT_PCM_32:
4932     case SF_FORMAT_FLOAT:
4933     case SF_FORMAT_DOUBLE:
4934     break;
4935     default:
4936     sf_close(hFile);
4937 persson 1831 throw std::string(_("format not supported"));
4938 schoenebeck 1673 }
4939     SampleImportItem sched_item;
4940     sched_item.gig_sample = sample;
4941     sched_item.sample_path = filename;
4942 schoenebeck 3116 m_SampleImportQueue[sample] = sched_item;
4943 schoenebeck 1673 sf_close(hFile);
4944     file_changed();
4945     }
4946     catch (std::string what)
4947     {
4948 persson 2442 if (!error_files.empty()) error_files += "\n";
4949 persson 2446 error_files += Glib::filename_to_utf8(filename) +
4950     " (" + what + ")";
4951 schoenebeck 1673 }
4952     }
4953     // show error message box when some file(s) could not be opened / added
4954 persson 2442 if (!error_files.empty()) {
4955 schoenebeck 1673 Glib::ustring txt =
4956     _("Could not replace the following sample(s):\n") + error_files;
4957     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
4958     msg.run();
4959     }
4960     }
4961     }
4962    
4963 schoenebeck 1225 void MainWindow::on_action_remove_sample() {
4964     if (!file) return;
4965     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4966 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4967     for (int r = rows.size() - 1; r >= 0; --r) {
4968     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4969     if (!it) continue;
4970 schoenebeck 1225 Gtk::TreeModel::Row row = *it;
4971     gig::Group* group = row[m_SamplesModel.m_col_group];
4972     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
4973     Glib::ustring name = row[m_SamplesModel.m_col_name];
4974     try {
4975     // remove group or sample from the gig file
4976     if (group) {
4977 persson 2446 // temporarily remember the samples that belong to
4978 schoenebeck 1225 // that group (we need that to clean the queue)
4979     std::list<gig::Sample*> members;
4980     for (gig::Sample* pSample = group->GetFirstSample();
4981     pSample; pSample = group->GetNextSample()) {
4982     members.push_back(pSample);
4983     }
4984 schoenebeck 1322 // notify everybody that we're going to remove these samples
4985     samples_to_be_removed_signal.emit(members);
4986 schoenebeck 1225 // delete the group in the .gig file including the
4987     // samples that belong to the group
4988     file->DeleteGroup(group);
4989 schoenebeck 1322 // notify that we're done with removal
4990     samples_removed_signal.emit();
4991 schoenebeck 1225 // if sample(s) were just previously added, remove
4992     // them from the import queue
4993     for (std::list<gig::Sample*>::iterator member = members.begin();
4994 schoenebeck 3116 member != members.end(); ++member)
4995     {
4996     if (m_SampleImportQueue.count(*member)) {
4997     printf("Removing previously added sample '%s' from group '%s'\n",
4998     m_SampleImportQueue[sample].sample_path.c_str(), name.c_str());
4999     m_SampleImportQueue.erase(*member);
5000 schoenebeck 1225 }
5001     }
5002 persson 1261 file_changed();
5003 schoenebeck 1225 } else if (sample) {
5004 schoenebeck 1322 // notify everybody that we're going to remove this sample
5005     std::list<gig::Sample*> lsamples;
5006     lsamples.push_back(sample);
5007     samples_to_be_removed_signal.emit(lsamples);
5008 schoenebeck 1225 // remove sample from the .gig file
5009     file->DeleteSample(sample);
5010 schoenebeck 1322 // notify that we're done with removal
5011     samples_removed_signal.emit();
5012 schoenebeck 1225 // if sample was just previously added, remove it from
5013     // the import queue
5014 schoenebeck 3116 if (m_SampleImportQueue.count(sample)) {
5015     printf("Removing previously added sample '%s'\n",
5016     m_SampleImportQueue[sample].sample_path.c_str());
5017     m_SampleImportQueue.erase(sample);
5018 schoenebeck 1225 }
5019 persson 1303 dimreg_changed();
5020 persson 1261 file_changed();
5021 schoenebeck 1225 }
5022     // remove respective row(s) from samples tree view
5023     m_refSamplesTreeModel->erase(it);
5024     } catch (RIFF::Exception e) {
5025 schoenebeck 1322 // pretend we're done with removal (i.e. to avoid dead locks)
5026     samples_removed_signal.emit();
5027     // show error message
5028 schoenebeck 1225 Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
5029     msg.run();
5030     }
5031     }
5032     }
5033    
5034 schoenebeck 2772 void MainWindow::on_action_remove_unused_samples() {
5035     if (!file) return;
5036    
5037     // collect all samples that are not referenced by any instrument
5038     std::list<gig::Sample*> lsamples;
5039     for (int iSample = 0; file->GetSample(iSample); ++iSample) {
5040     gig::Sample* sample = file->GetSample(iSample);
5041     bool isUsed = false;
5042     for (gig::Instrument* instrument = file->GetFirstInstrument(); instrument;
5043     instrument = file->GetNextInstrument())
5044     {
5045     for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
5046     rgn = instrument->GetNextRegion())
5047     {
5048     for (int i = 0; i < 256; ++i) {
5049     if (!rgn->pDimensionRegions[i]) continue;
5050     if (rgn->pDimensionRegions[i]->pSample != sample) continue;
5051     isUsed = true;
5052     goto endOfRefSearch;
5053     }
5054     }
5055     }
5056     endOfRefSearch:
5057     if (!isUsed) lsamples.push_back(sample);
5058     }
5059    
5060     if (lsamples.empty()) return;
5061    
5062     // notify everybody that we're going to remove these samples
5063     samples_to_be_removed_signal.emit(lsamples);
5064    
5065     // remove collected samples
5066     try {
5067     for (std::list<gig::Sample*>::iterator itSample = lsamples.begin();
5068     itSample != lsamples.end(); ++itSample)
5069     {
5070     gig::Sample* sample = *itSample;
5071     // remove sample from the .gig file
5072     file->DeleteSample(sample);
5073 schoenebeck 3116 // if sample was just previously added, remove it from the import queue
5074     if (m_SampleImportQueue.count(sample)) {
5075     printf("Removing previously added sample '%s'\n",
5076     m_SampleImportQueue[sample].sample_path.c_str());
5077     m_SampleImportQueue.erase(sample);
5078 schoenebeck 2772 }
5079     }
5080     } catch (RIFF::Exception e) {
5081     // show error message
5082     Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
5083     msg.run();
5084     }
5085    
5086     // notify everybody that we're done with removal
5087     samples_removed_signal.emit();
5088    
5089     dimreg_changed();
5090     file_changed();
5091     __refreshEntireGUI();
5092     }
5093    
5094 schoenebeck 2610 // see comment on on_sample_treeview_drag_begin()
5095     void MainWindow::on_scripts_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5096     {
5097     first_call_to_drag_data_get = true;
5098     }
5099    
5100     void MainWindow::on_scripts_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5101     Gtk::SelectionData& selection_data, guint, guint)
5102     {
5103     if (!first_call_to_drag_data_get) return;
5104     first_call_to_drag_data_get = false;
5105    
5106     // get selected script
5107     gig::Script* script = NULL;
5108     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
5109     Gtk::TreeModel::iterator it = sel->get_selected();
5110     if (it) {
5111     Gtk::TreeModel::Row row = *it;
5112     script = row[m_ScriptsModel.m_col_script];
5113     }
5114     // pass the gig::Script as pointer
5115     selection_data.set(selection_data.get_target(), 0/*unused*/,
5116     (const guchar*)&script,
5117     sizeof(script)/*length of data in bytes*/);
5118     }
5119    
5120 schoenebeck 2701 // see comment on on_sample_treeview_drag_begin()
5121     void MainWindow::on_instruments_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5122     {
5123     first_call_to_drag_data_get = true;
5124     }
5125    
5126     void MainWindow::on_instruments_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5127     Gtk::SelectionData& selection_data, guint, guint)
5128     {
5129     if (!first_call_to_drag_data_get) return;
5130     first_call_to_drag_data_get = false;
5131    
5132     // get selected source instrument
5133     gig::Instrument* src = NULL;
5134     {
5135     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
5136 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5137     if (!rows.empty()) {
5138     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
5139     if (it) {
5140     Gtk::TreeModel::Row row = *it;
5141     src = row[m_Columns.m_col_instr];
5142     }
5143 schoenebeck 2701 }
5144     }
5145     if (!src) return;
5146    
5147     // pass the source gig::Instrument as pointer
5148     selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&src,
5149     sizeof(src)/*length of data in bytes*/);
5150     }
5151    
5152     void MainWindow::on_instruments_treeview_drop_drag_data_received(
5153     const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
5154     const Gtk::SelectionData& selection_data, guint, guint time)
5155     {
5156     gig::Instrument* src = *((gig::Instrument**) selection_data.get_data());
5157     if (!src || selection_data.get_length() != sizeof(gig::Instrument*))
5158     return;
5159    
5160     gig::Instrument* dst = NULL;
5161     {
5162     Gtk::TreeModel::Path path;
5163     const bool found = m_TreeView.get_path_at_pos(x, y, path);
5164     if (!found) return;
5165    
5166     Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
5167     if (!iter) return;
5168     Gtk::TreeModel::Row row = *iter;
5169     dst = row[m_Columns.m_col_instr];
5170     }
5171     if (!dst) return;
5172    
5173     //printf("dragdrop received src=%s dst=%s\n", src->pInfo->Name.c_str(), dst->pInfo->Name.c_str());
5174     src->MoveTo(dst);
5175     __refreshEntireGUI();
5176     select_instrument(src);
5177     }
5178    
5179 persson 1303 // For some reason drag_data_get gets called two times for each
5180     // drag'n'drop (at least when target is an Entry). This work-around
5181     // makes sure the code in drag_data_get and drop_drag_data_received is
5182     // only executed once, as drag_begin only gets called once.
5183     void MainWindow::on_sample_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
5184     {
5185     first_call_to_drag_data_get = true;
5186     }
5187    
5188 schoenebeck 1225 void MainWindow::on_sample_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
5189     Gtk::SelectionData& selection_data, guint, guint)
5190     {
5191 persson 1303 if (!first_call_to_drag_data_get) return;
5192     first_call_to_drag_data_get = false;
5193    
5194 schoenebeck 1225 // get selected sample
5195     gig::Sample* sample = NULL;
5196     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5197 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5198     if (!rows.empty()) {
5199     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5200     if (it) {
5201     Gtk::TreeModel::Row row = *it;
5202     sample = row[m_SamplesModel.m_col_sample];
5203     }
5204 schoenebeck 1225 }
5205     // pass the gig::Sample as pointer
5206     selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&sample,
5207     sizeof(sample)/*length of data in bytes*/);
5208     }
5209    
5210     void MainWindow::on_sample_label_drop_drag_data_received(
5211     const Glib::RefPtr<Gdk::DragContext>& context, int, int,
5212     const Gtk::SelectionData& selection_data, guint, guint time)
5213     {
5214     gig::Sample* sample = *((gig::Sample**) selection_data.get_data());
5215    
5216 persson 1265 if (sample && selection_data.get_length() == sizeof(gig::Sample*)) {
5217 persson 1303 std::cout << "Drop received sample \"" <<
5218     sample->pInfo->Name << "\"" << std::endl;
5219     // drop success
5220     context->drop_reply(true, time);
5221    
5222 schoenebeck 1322 //TODO: we should better move most of the following code to DimRegionEdit::set_sample()
5223    
5224     // notify everybody that we're going to alter the region
5225     gig::Region* region = m_RegionChooser.get_region();
5226     region_to_be_changed_signal.emit(region);
5227    
5228 persson 1303 // find the samplechannel dimension
5229     gig::dimension_def_t* stereo_dimension = 0;
5230     for (int i = 0 ; i < region->Dimensions ; i++) {
5231     if (region->pDimensionDefinitions[i].dimension ==
5232     gig::dimension_samplechannel) {
5233     stereo_dimension = &region->pDimensionDefinitions[i];
5234     break;
5235     }
5236 schoenebeck 1225 }
5237 persson 1303 bool channels_changed = false;
5238     if (sample->Channels == 1 && stereo_dimension) {
5239     // remove the samplechannel dimension
5240 schoenebeck 2550 /* commented out, because it makes it impossible building up an instrument from scratch using two separate L/R samples
5241 persson 1303 region->DeleteDimension(stereo_dimension);
5242     channels_changed = true;
5243     region_changed();
5244 schoenebeck 2550 */
5245 persson 1303 }
5246 schoenebeck 2464 dimreg_edit.set_sample(
5247     sample,
5248     is_copy_samples_unity_note_enabled(),
5249     is_copy_samples_fine_tune_enabled(),
5250     is_copy_samples_loop_enabled()
5251     );
5252 persson 1303
5253     if (sample->Channels == 2 && !stereo_dimension) {
5254     // add samplechannel dimension
5255     gig::dimension_def_t dim;
5256     dim.dimension = gig::dimension_samplechannel;
5257     dim.bits = 1;
5258     dim.zones = 2;
5259     region->AddDimension(&dim);
5260     channels_changed = true;
5261     region_changed();
5262     }
5263     if (channels_changed) {
5264     // unmap all samples with wrong number of channels
5265     // TODO: maybe there should be a warning dialog for this
5266     for (int i = 0 ; i < region->DimensionRegions ; i++) {
5267     gig::DimensionRegion* d = region->pDimensionRegions[i];
5268     if (d->pSample && d->pSample->Channels != sample->Channels) {
5269 schoenebeck 1322 gig::Sample* oldref = d->pSample;
5270     d->pSample = NULL;
5271     sample_ref_changed_signal.emit(oldref, NULL);
5272 persson 1303 }
5273     }
5274     }
5275    
5276 schoenebeck 1322 // notify we're done with altering
5277     region_changed_signal.emit(region);
5278    
5279 persson 1460 file_changed();
5280    
5281 persson 1303 return;
5282 schoenebeck 1225 }
5283     // drop failed
5284     context->drop_reply(false, time);
5285     }
5286    
5287     void MainWindow::sample_name_changed(const Gtk::TreeModel::Path& path,
5288     const Gtk::TreeModel::iterator& iter) {
5289     if (!iter) return;
5290     Gtk::TreeModel::Row row = *iter;
5291     Glib::ustring name = row[m_SamplesModel.m_col_name];
5292     gig::Group* group = row[m_SamplesModel.m_col_group];
5293     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
5294 persson 2446 gig::String gigname(gig_from_utf8(name));
5295 schoenebeck 1225 if (group) {
5296 persson 2446 if (group->Name != gigname) {
5297     group->Name = gigname;
5298 persson 1261 printf("group name changed\n");
5299     file_changed();
5300     }
5301 schoenebeck 1225 } else if (sample) {
5302 persson 2446 if (sample->pInfo->Name != gigname) {
5303     sample->pInfo->Name = gigname;
5304 persson 1261 printf("sample name changed\n");
5305     file_changed();
5306     }
5307 schoenebeck 1225 }
5308 schoenebeck 3637 // change name in the sample properties window
5309     if (sampleProps.get_sample() == sample && sample) {
5310     sampleProps.set_sample(sample);
5311     }
5312 schoenebeck 1225 }
5313    
5314 schoenebeck 2604 void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
5315     const Gtk::TreeModel::iterator& iter) {
5316     if (!iter) return;
5317     Gtk::TreeModel::Row row = *iter;
5318     Glib::ustring name = row[m_ScriptsModel.m_col_name];
5319     gig::ScriptGroup* group = row[m_ScriptsModel.m_col_group];
5320     gig::Script* script = row[m_ScriptsModel.m_col_script];
5321     gig::String gigname(gig_from_utf8(name));
5322     if (group) {
5323     if (group->Name != gigname) {
5324     group->Name = gigname;
5325     printf("script group name changed\n");
5326     file_changed();
5327     }
5328     } else if (script) {
5329     if (script->Name != gigname) {
5330     script->Name = gigname;
5331     printf("script name changed\n");
5332     file_changed();
5333     }
5334     }
5335     }
5336    
5337 schoenebeck 2644 void MainWindow::script_double_clicked(const Gtk::TreeModel::Path& path,
5338     Gtk::TreeViewColumn* column)
5339     {
5340     Gtk::TreeModel::iterator iter = m_refScriptsTreeModel->get_iter(path);
5341     if (!iter) return;
5342     Gtk::TreeModel::Row row = *iter;
5343     gig::Script* script = row[m_ScriptsModel.m_col_script];
5344 schoenebeck 3750 editScript(script);
5345 schoenebeck 2644 }
5346    
5347 schoenebeck 1225 void MainWindow::instrument_name_changed(const Gtk::TreeModel::Path& path,
5348     const Gtk::TreeModel::iterator& iter) {
5349     if (!iter) return;
5350     Gtk::TreeModel::Row row = *iter;
5351     Glib::ustring name = row[m_Columns.m_col_name];
5352 persson 2442
5353 schoenebeck 3364 #if !USE_GTKMM_BUILDER
5354 persson 2442 // change name in instrument menu
5355     int index = path[0];
5356     const std::vector<Gtk::Widget*> children = instrument_menu->get_children();
5357     if (index < children.size()) {
5358     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION >= 16) || GTKMM_MAJOR_VERSION > 2
5359     static_cast<Gtk::RadioMenuItem*>(children[index])->set_label(name);
5360     #else
5361     remove_instrument_from_menu(index);
5362     Gtk::RadioMenuItem* item = add_instrument_to_menu(name, index);
5363     item->set_active();
5364     #endif
5365     }
5366 schoenebeck 3364 #endif
5367 persson 2442
5368     // change name in gig
5369 schoenebeck 1225 gig::Instrument* instrument = row[m_Columns.m_col_instr];
5370 persson 2446 gig::String gigname(gig_from_utf8(name));
5371     if (instrument && instrument->pInfo->Name != gigname) {
5372     instrument->pInfo->Name = gigname;
5373 persson 2445
5374     // change name in the instrument properties window
5375     if (instrumentProps.get_instrument() == instrument) {
5376     instrumentProps.update_name();
5377     }
5378    
5379 persson 1261 file_changed();
5380     }
5381 schoenebeck 1225 }
5382 schoenebeck 1322
5383 schoenebeck 3340 bool MainWindow::instrument_row_visible(const Gtk::TreeModel::const_iterator& iter) {
5384     if (!iter)
5385     return true;
5386    
5387     Glib::ustring pattern = m_searchText.get_text().lowercase();
5388     trim(pattern);
5389     if (pattern.empty()) return true;
5390    
5391 schoenebeck 3450 #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
5392 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.
5393     Gtk::TreeModel::Row row = **(Gtk::TreeModel::iterator*)(&iter);
5394     #else
5395 schoenebeck 3340 Gtk::TreeModel::Row row = *iter;
5396 schoenebeck 3364 #endif
5397 schoenebeck 3340 Glib::ustring name = row[m_Columns.m_col_name];
5398     name = name.lowercase();
5399    
5400     std::vector<Glib::ustring> tokens = Glib::Regex::split_simple(" ", pattern);
5401     for (int t = 0; t < tokens.size(); ++t)
5402     if (name.find(tokens[t]) == Glib::ustring::npos)
5403     return false;
5404    
5405     return true;
5406     }
5407    
5408 schoenebeck 2548 void MainWindow::on_action_combine_instruments() {
5409     CombineInstrumentsDialog* d = new CombineInstrumentsDialog(*this, file);
5410 schoenebeck 3299
5411     // take over selection from instruments list view for the combine dialog's
5412     // list view as pre-selection
5413     std::set<int> indeces;
5414     {
5415     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
5416     std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5417     for (int r = 0; r < rows.size(); ++r) {
5418     Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
5419     if (it) {
5420     Gtk::TreeModel::Row row = *it;
5421     int index = row[m_Columns.m_col_nr];
5422     indeces.insert(index);
5423     }
5424     }
5425     }
5426     d->setSelectedInstruments(indeces);
5427    
5428 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5429 schoenebeck 2548 d->show_all();
5430 schoenebeck 3364 #else
5431     d->show();
5432     #endif
5433 schoenebeck 2548 d->run();
5434     if (d->fileWasChanged()) {
5435     // update GUI with new instrument just created
5436     add_instrument(d->newCombinedInstrument());
5437     }
5438     delete d;
5439     }
5440    
5441 schoenebeck 2624 void MainWindow::on_action_view_references() {
5442     Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5443 schoenebeck 2994 std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5444     if (rows.empty()) return;
5445     Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5446 schoenebeck 2624 if (!it) return;
5447     Gtk::TreeModel::Row row = *it;
5448     gig::Sample* sample = row[m_SamplesModel.m_col_sample];
5449     if (!sample) return;
5450    
5451     ReferencesView* d = new ReferencesView(*this);
5452     d->setSample(sample);
5453 schoenebeck 2695 d->dimension_region_selected.connect(
5454     sigc::mem_fun(*this, &MainWindow::select_dimension_region)
5455     );
5456 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5457 schoenebeck 2624 d->show_all();
5458 schoenebeck 3364 #else
5459     d->show();
5460     #endif
5461 schoenebeck 2624 d->resize(500, 400);
5462     d->run();
5463     delete d;
5464     }
5465    
5466 schoenebeck 2553 void MainWindow::mergeFiles(const std::vector<std::string>& filenames) {
5467     struct _Source {
5468     std::vector<RIFF::File*> riffs;
5469     std::vector<gig::File*> gigs;
5470    
5471     ~_Source() {
5472     for (int k = 0; k < gigs.size(); ++k) delete gigs[k];
5473     for (int k = 0; k < riffs.size(); ++k) delete riffs[k];
5474     riffs.clear();
5475     gigs.clear();
5476     }
5477     } sources;
5478    
5479     if (filenames.empty())
5480     throw RIFF::Exception(_("No files selected, so nothing done."));
5481    
5482     // first open all input files (to avoid output file corruption)
5483     int i;
5484     try {
5485     for (i = 0; i < filenames.size(); ++i) {
5486     const std::string& filename = filenames[i];
5487     printf("opening file=%s\n", filename.c_str());
5488    
5489     RIFF::File* riff = new RIFF::File(filename);
5490     sources.riffs.push_back(riff);
5491    
5492     gig::File* gig = new gig::File(riff);
5493     sources.gigs.push_back(gig);
5494     }
5495     } catch (RIFF::Exception e) {
5496     throw RIFF::Exception(
5497     _("Error occurred while opening '") +
5498     filenames[i] +
5499     "': " +
5500     e.Message
5501     );
5502     } catch (...) {
5503     throw RIFF::Exception(
5504     _("Unknown exception occurred while opening '") +
5505     filenames[i] + "'"
5506     );
5507     }
5508    
5509     // now merge the opened .gig files to the main .gig file currently being
5510     // open in gigedit
5511     try {
5512     for (i = 0; i < filenames.size(); ++i) {
5513     const std::string& filename = filenames[i];
5514     printf("merging file=%s\n", filename.c_str());
5515     assert(i < sources.gigs.size());
5516    
5517     this->file->AddContentOf(sources.gigs[i]);
5518     }
5519     } catch (RIFF::Exception e) {
5520     throw RIFF::Exception(
5521     _("Error occurred while merging '") +
5522     filenames[i] +
5523     "': " +
5524     e.Message
5525     );
5526     } catch (...) {
5527     throw RIFF::Exception(
5528     _("Unknown exception occurred while merging '") +
5529     filenames[i] + "'"
5530     );
5531     }
5532    
5533 schoenebeck 2683 // Finally save gig file persistently to disk ...
5534     //NOTE: requires that this gig file already has a filename !
5535     {
5536     std::cout << "Saving file\n" << std::flush;
5537     file_structure_to_be_changed_signal.emit(this->file);
5538    
5539     progress_dialog = new ProgressDialog( //FIXME: memory leak!
5540     _("Saving") + Glib::ustring(" '") +
5541     Glib::filename_display_basename(this->filename) + "' ...",
5542     *this
5543     );
5544 schoenebeck 3364 #if HAS_GTKMM_SHOW_ALL_CHILDREN
5545 schoenebeck 2683 progress_dialog->show_all();
5546 schoenebeck 3364 #else
5547     progress_dialog->show();
5548     #endif
5549 schoenebeck 2683 saver = new Saver(this->file); //FIXME: memory leak!
5550     saver->signal_progress().connect(
5551     sigc::mem_fun(*this, &MainWindow::on_saver_progress));
5552     saver->signal_finished().connect(
5553     sigc::mem_fun(*this, &MainWindow::on_saver_finished));
5554     saver->signal_error().connect(
5555     sigc::mem_fun(*this, &MainWindow::on_saver_error));
5556     saver->launch();
5557     }
5558 schoenebeck 2553 }
5559    
5560     void MainWindow::on_action_merge_files() {
5561     if (this->file->GetFileName().empty()) {
5562     Glib::ustring txt = _(
5563     "You seem to have a new .gig file open that has not been saved "
5564     "yet. You must save it somewhere before starting to merge it with "
5565     "other .gig files though, because during the merge operation the "
5566     "other files' sample data must be written on file level to the "
5567     "target .gig file."
5568     );
5569     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
5570     msg.run();
5571     return;
5572     }
5573    
5574     Gtk::FileChooserDialog dialog(*this, _("Merge .gig files"));
5575 schoenebeck 3364 #if HAS_GTKMM_STOCK
5576 schoenebeck 3158 dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
5577 schoenebeck 3364 #else
5578     dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
5579     #endif
5580 schoenebeck 2553 dialog.add_button(_("Merge"), Gtk::RESPONSE_OK);
5581     dialog.set_default_response(Gtk::RESPONSE_CANCEL);
5582     #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
5583     Gtk::FileFilter filter;
5584     filter.add_pattern("*.gig");
5585     #else
5586     Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
5587     filter->add_pattern("*.gig");
5588     #endif
5589     dialog.set_filter(filter);
5590     if (current_gig_dir != "") {
5591     dialog.set_current_folder(current_gig_dir);
5592     }
5593     dialog.set_select_multiple(true);
5594    
5595     // show warning in the file picker dialog
5596 schoenebeck 3364 HBox descriptionArea;
5597 schoenebeck 2553 descriptionArea.set_spacing(15);
5598 persson 2845 Gtk::Image warningIcon;
5599     warningIcon.set_from_icon_name("dialog-warning",
5600     Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
5601 schoenebeck 2553 descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
5602     #if GTKMM_MAJOR_VERSION < 3
5603     view::WrapLabel description;
5604     #else
5605     Gtk::Label description;
5606     description.set_line_wrap();
5607     #endif
5608     description.set_markup(_(
5609     "\nSelect at least one .gig file that shall be merged to the .gig file "
5610     "currently being open in gigedit.\n\n"
5611     "<b>Please Note:</b> Merging with other files will modify your "
5612     "currently open .gig file on file level! And be aware that the current "
5613     "merge algorithm does not detect duplicate samples yet. So if you are "
5614     "merging files which are using equivalent sample data, those "
5615     "equivalent samples will currently be treated as separate samples and "
5616     "will accordingly be stored separately in the target .gig file!"
5617     ));
5618     descriptionArea.pack_start(description);
5619 schoenebeck 3364 #if USE_GTKMM_BOX
5620     # warning No description area implemented for dialog on GTKMM 3
5621     #else
5622 schoenebeck 2553 dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
5623 schoenebeck 3364 #endif
5624     #if HAS_GTKMM_SHOW_ALL_CHILDREN
5625 schoenebeck 2553 descriptionArea.show_all();
5626 schoenebeck 3364 #else
5627     descriptionArea.show();
5628     #endif
5629 schoenebeck 2553
5630     if (dialog.run() == Gtk::RESPONSE_OK) {
5631 persson 3477 dialog.hide();
5632 persson 3472 #ifdef GLIB_THREADS
5633 persson 2841 printf("on_action_merge_files self=%p\n",
5634     static_cast<void*>(Glib::Threads::Thread::self()));
5635 persson 3472 #else
5636     std::cout << "on_action_merge_files self=" <<
5637     std::this_thread::get_id() << "\n";
5638     #endif
5639 schoenebeck 2553 std::vector<std::string> filenames = dialog.get_filenames();
5640    
5641     // merge the selected files to the currently open .gig file
5642     try {
5643     mergeFiles(filenames);
5644     } catch (RIFF::Exception e) {
5645     Gtk::MessageDialog msg(*this, e.Message, false, Gtk::MESSAGE_ERROR);
5646     msg.run();
5647     }
5648    
5649     // update GUI
5650 schoenebeck 2772 __refreshEntireGUI();
5651 schoenebeck 2553 }
5652     }
5653    
5654 schoenebeck 1411 void MainWindow::set_file_is_shared(bool b) {
5655     this->file_is_shared = b;
5656    
5657     if (file_is_shared) {
5658     m_AttachedStateLabel.set_label(_("live-mode"));
5659     m_AttachedStateImage.set(
5660     Gdk::Pixbuf::create_from_xpm_data(status_attached_xpm)
5661     );
5662     } else {
5663     m_AttachedStateLabel.set_label(_("stand-alone"));
5664     m_AttachedStateImage.set(
5665     Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
5666     );
5667     }
5668 schoenebeck 2689
5669     {
5670 schoenebeck 3364 #if USE_GTKMM_BUILDER
5671     m_actionToggleSyncSamplerSelection->property_enabled() = b;
5672     #else
5673 schoenebeck 2689 Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
5674     uiManager->get_widget("/MenuBar/MenuSettings/SyncSamplerInstrumentSelection"));
5675     if (item) item->set_sensitive(b);
5676 schoenebeck 3364 #endif
5677 schoenebeck 2689 }
5678 schoenebeck 1411 }
5679    
5680 schoenebeck 2621 void MainWindow::on_sample_ref_count_incremented(gig::Sample* sample, int offset) {
5681     if (!sample) return;
5682     sample_ref_count[sample] += offset;
5683     const int refcount = sample_ref_count[sample];
5684    
5685     Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewSamples.get_model();
5686     for (int g = 0; g < model->children().size(); ++g) {
5687     Gtk::TreeModel::Row rowGroup = model->children()[g];
5688     for (int s = 0; s < rowGroup.children().size(); ++s) {
5689     Gtk::TreeModel::Row rowSample = rowGroup.children()[s];
5690     if (rowSample[m_SamplesModel.m_col_sample] != sample) continue;
5691     rowSample[m_SamplesModel.m_col_refcount] = ToString(refcount) + " " + _("Refs.");
5692 schoenebeck 2625 rowSample[m_SamplesModel.m_color] = refcount ? "black" : "red";
5693 schoenebeck 2621 }
5694     }
5695     }
5696    
5697     void MainWindow::on_sample_ref_changed(gig::Sample* oldSample, gig::Sample* newSample) {
5698     on_sample_ref_count_incremented(oldSample, -1);
5699     on_sample_ref_count_incremented(newSample, +1);
5700     }
5701    
5702     void MainWindow::on_samples_to_be_removed(std::list<gig::Sample*> samples) {
5703     // just in case a new sample is added later with exactly the same memory
5704     // address, which would lead to incorrect refcount if not deleted here
5705     for (std::list<gig::Sample*>::const_iterator it = samples.begin();
5706 schoenebeck 2666 it != samples.end(); ++it)
5707 schoenebeck 2621 {
5708     sample_ref_count.erase(*it);
5709     }
5710     }
5711    
5712 schoenebeck 2625 void MainWindow::show_samples_tab() {
5713     m_TreeViewNotebook.set_current_page(0);
5714     }
5715    
5716     void MainWindow::show_intruments_tab() {
5717     m_TreeViewNotebook.set_current_page(1);
5718     }
5719    
5720     void MainWindow::show_scripts_tab() {
5721     m_TreeViewNotebook.set_current_page(2);
5722     }
5723    
5724 schoenebeck 3339 void MainWindow::select_instrument_by_dir(int dir) {
5725     if (!file) return;
5726     gig::Instrument* pInstrument = get_instrument();
5727     if (!pInstrument) {
5728     select_instrument( file->GetInstrument(0) );
5729     return;
5730     }
5731     for (int i = 0; file->GetInstrument(i); ++i) {
5732     if (file->GetInstrument(i) == pInstrument) {
5733     select_instrument( file->GetInstrument(i + dir) );
5734     return;
5735     }
5736     }
5737     }
5738    
5739     void MainWindow::select_prev_instrument() {
5740     select_instrument_by_dir(-1);
5741     }
5742    
5743     void MainWindow::select_next_instrument() {
5744     select_instrument_by_dir(1);
5745     }
5746    
5747 schoenebeck 3123 void MainWindow::select_prev_region() {
5748     m_RegionChooser.select_prev_region();
5749     }
5750    
5751     void MainWindow::select_next_region() {
5752     m_RegionChooser.select_next_region();
5753     }
5754    
5755     void MainWindow::select_next_dim_rgn_zone() {
5756     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5757     m_DimRegionChooser.select_next_dimzone();
5758     }
5759    
5760     void MainWindow::select_prev_dim_rgn_zone() {
5761     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5762     m_DimRegionChooser.select_prev_dimzone();
5763     }
5764    
5765 schoenebeck 3134 void MainWindow::select_add_next_dim_rgn_zone() {
5766     m_DimRegionChooser.select_next_dimzone(true);
5767     }
5768    
5769     void MainWindow::select_add_prev_dim_rgn_zone() {
5770     m_DimRegionChooser.select_prev_dimzone(true);
5771     }
5772    
5773 schoenebeck 3123 void MainWindow::select_prev_dimension() {
5774     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5775     m_DimRegionChooser.select_prev_dimension();
5776     }
5777    
5778     void MainWindow::select_next_dimension() {
5779     if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5780     m_DimRegionChooser.select_next_dimension();
5781     }
5782    
5783 schoenebeck 3144 #define CLIPBOARD_DIMENSIONREGION_TARGET \
5784     ("libgig.DimensionRegion." + m_serializationArchive.rawDataFormat())
5785    
5786     void MainWindow::copy_selected_dimrgn() {
5787     gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5788     if (!pDimRgn) {
5789     updateClipboardPasteAvailable();
5790     updateClipboardCopyAvailable();
5791     return;
5792     }
5793    
5794     std::vector<Gtk::TargetEntry> targets;
5795     targets.push_back( Gtk::TargetEntry(CLIPBOARD_DIMENSIONREGION_TARGET) );
5796    
5797     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5798     clipboard->set(
5799     targets,
5800     sigc::mem_fun(*this, &MainWindow::on_clipboard_get),
5801     sigc::mem_fun(*this, &MainWindow::on_clipboard_clear)
5802     );
5803    
5804     m_serializationArchive.serialize(pDimRgn);
5805    
5806     updateClipboardPasteAvailable();
5807     }
5808    
5809     void MainWindow::paste_copied_dimrgn() {
5810     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5811     clipboard->request_contents(
5812     CLIPBOARD_DIMENSIONREGION_TARGET,
5813     sigc::mem_fun(*this, &MainWindow::on_clipboard_received)
5814     );
5815     updateClipboardPasteAvailable();
5816     }
5817    
5818 schoenebeck 3151 void MainWindow::adjust_clipboard_content() {
5819 schoenebeck 3155 MacroEditor* editor = new MacroEditor();
5820 schoenebeck 3162 editor->setMacro(&m_serializationArchive, true);
5821 schoenebeck 3151 editor->show();
5822     }
5823    
5824 schoenebeck 3144 void MainWindow::updateClipboardPasteAvailable() {
5825     Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5826     clipboard->request_targets(
5827     sigc::mem_fun(*this, &MainWindow::on_clipboard_received_targets)
5828     );
5829     }
5830    
5831     void MainWindow::updateClipboardCopyAvailable() {
5832     bool bDimensionRegionCopyIsPossible = m_DimRegionChooser.get_main_dimregion();
5833 schoenebeck 3364 #if USE_GTKMM_BUILDER
5834     m_actionCopyDimRgn->property_enabled() = bDimensionRegionCopyIsPossible;
5835     #else
5836 schoenebeck 3144 static_cast<Gtk::MenuItem*>(
5837     uiManager->get_widget("/MenuBar/MenuEdit/CopyDimRgn")
5838     )->set_sensitive(bDimensionRegionCopyIsPossible);
5839 schoenebeck 3364 #endif
5840 schoenebeck 3144 }
5841    
5842 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
5843     void MainWindow::on_clipboard_owner_change(Gdk::EventOwnerChange& event) {
5844     #else
5845 schoenebeck 3144 void MainWindow::on_clipboard_owner_change(GdkEventOwnerChange* event) {
5846 schoenebeck 3364 #endif
5847 schoenebeck 3144 updateClipboardPasteAvailable();
5848     }
5849    
5850     void MainWindow::on_clipboard_get(Gtk::SelectionData& selection_data, guint /*info*/) {
5851     const std::string target = selection_data.get_target();
5852     if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5853     selection_data.set(
5854     CLIPBOARD_DIMENSIONREGION_TARGET, 8 /* "format": probably unused*/,
5855     &m_serializationArchive.rawData()[0],
5856     m_serializationArchive.rawData().size()
5857     );
5858     } else {
5859     std::cerr << "Clipboard: content for unknown target '" << target << "' requested\n";
5860     }
5861     }
5862    
5863     void MainWindow::on_clipboard_clear() {
5864     m_serializationArchive.clear();
5865     updateClipboardPasteAvailable();
5866     updateClipboardCopyAvailable();
5867     }
5868    
5869 schoenebeck 3157 //NOTE: Might throw exception !!!
5870     void MainWindow::applyMacro(Serialization::Archive& macro) {
5871     gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5872     if (!pDimRgn) return;
5873    
5874     for (std::set<gig::DimensionRegion*>::iterator itDimReg = dimreg_edit.dimregs.begin();
5875     itDimReg != dimreg_edit.dimregs.end(); ++itDimReg)
5876     {
5877     gig::DimensionRegion* pDimRgn = *itDimReg;
5878 schoenebeck 3177 DimRegionChangeGuard(this, pDimRgn);
5879 schoenebeck 3160 macro.deserialize(pDimRgn);
5880 schoenebeck 3157 }
5881     //region_changed()
5882     file_changed();
5883     dimreg_changed();
5884     }
5885    
5886 schoenebeck 3144 void MainWindow::on_clipboard_received(const Gtk::SelectionData& selection_data) {
5887     const std::string target = selection_data.get_target();
5888     if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5889     Glib::ustring errorText;
5890     try {
5891     m_serializationArchive.decode(
5892     selection_data.get_data(), selection_data.get_length()
5893     );
5894 schoenebeck 3157 applyMacro(m_serializationArchive);
5895 schoenebeck 3144 } catch (Serialization::Exception e) {
5896     errorText = e.Message;
5897     } catch (...) {
5898 schoenebeck 3157 errorText = _("Unknown exception while pasting DimensionRegion");
5899 schoenebeck 3144 }
5900     if (!errorText.empty()) {
5901     Glib::ustring txt = _("Pasting DimensionRegion failed:\n") + errorText;
5902     Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
5903     msg.run();
5904     }
5905     }
5906     }
5907    
5908     void MainWindow::on_clipboard_received_targets(const std::vector<Glib::ustring>& targets) {
5909     const bool bDimensionRegionPasteIsPossible =
5910     std::find(targets.begin(), targets.end(),
5911     CLIPBOARD_DIMENSIONREGION_TARGET) != targets.end();
5912    
5913 schoenebeck 3364 #if USE_GTKMM_BUILDER
5914     m_actionPasteDimRgn->property_enabled() = bDimensionRegionPasteIsPossible;
5915     m_actionAdjustClipboard->property_enabled() = bDimensionRegionPasteIsPossible;
5916     #else
5917 schoenebeck 3144 static_cast<Gtk::MenuItem*>(
5918     uiManager->get_widget("/MenuBar/MenuEdit/PasteDimRgn")
5919     )->set_sensitive(bDimensionRegionPasteIsPossible);
5920 schoenebeck 3151
5921     static_cast<Gtk::MenuItem*>(
5922     uiManager->get_widget("/MenuBar/MenuEdit/AdjustClipboard")
5923     )->set_sensitive(bDimensionRegionPasteIsPossible);
5924 schoenebeck 3364 #endif
5925 schoenebeck 3144 }
5926    
5927 schoenebeck 1339 sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
5928 schoenebeck 1322 return file_structure_to_be_changed_signal;
5929     }
5930    
5931 schoenebeck 1339 sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_changed() {
5932 schoenebeck 1322 return file_structure_changed_signal;
5933     }
5934    
5935 schoenebeck 1339 sigc::signal<void, std::list<gig::Sample*> >& MainWindow::signal_samples_to_be_removed() {
5936 schoenebeck 1322 return samples_to_be_removed_signal;
5937     }
5938    
5939 schoenebeck 1339 sigc::signal<void>& MainWindow::signal_samples_removed() {
5940 schoenebeck 1322 return samples_removed_signal;
5941     }
5942    
5943 schoenebeck 1339 sigc::signal<void, gig::Region*>& MainWindow::signal_region_to_be_changed() {
5944 schoenebeck 1322 return region_to_be_changed_signal;
5945     }
5946    
5947 schoenebeck 1339 sigc::signal<void, gig::Region*>& MainWindow::signal_region_changed() {
5948 schoenebeck 1322 return region_changed_signal;
5949     }
5950    
5951 schoenebeck 1853 sigc::signal<void, gig::Sample*>& MainWindow::signal_sample_changed() {
5952     return sample_changed_signal;
5953     }
5954    
5955 schoenebeck 1339 sigc::signal<void, gig::Sample*/*old*/, gig::Sample*/*new*/>& MainWindow::signal_sample_ref_changed() {
5956 schoenebeck 1322 return sample_ref_changed_signal;
5957     }
5958    
5959 schoenebeck 1339 sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_to_be_changed() {
5960 schoenebeck 1322 return dimreg_to_be_changed_signal;
5961     }
5962    
5963 schoenebeck 1339 sigc::signal<void, gig::DimensionRegion*>& MainWindow::signal_dimreg_changed() {
5964 schoenebeck 1322 return dimreg_changed_signal;
5965     }
5966 schoenebeck 1654
5967     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_on() {
5968     return note_on_signal;
5969     }
5970    
5971     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_note_off() {
5972     return note_off_signal;
5973     }
5974 schoenebeck 1660
5975     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_hit() {
5976     return m_RegionChooser.signal_keyboard_key_hit();
5977     }
5978    
5979     sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
5980     return m_RegionChooser.signal_keyboard_key_released();
5981     }
5982 schoenebeck 2689
5983     sigc::signal<void, gig::Instrument*>& MainWindow::signal_switch_sampler_instrument() {
5984     return switch_sampler_instrument_signal;
5985     }

  ViewVC Help
Powered by ViewVC