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

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

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

revision 2664 by schoenebeck, Sat Jul 5 19:43:14 2014 UTC revision 3637 by schoenebeck, Thu Oct 24 13:12:52 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006-2014 Andreas Persson   * Copyright (C) 2006-2019 Andreas Persson
3   *   *
4   * This program is free software; you can redistribute it and/or   * This program is free software; you can redistribute it and/or
5   * modify it under the terms of the GNU General Public License as   * modify it under the terms of the GNU General Public License as
# Line 20  Line 20 
20  #include <iostream>  #include <iostream>
21  #include <cstring>  #include <cstring>
22    
23    #include "compat.h"
24    
25  #include <glibmm/convert.h>  #include <glibmm/convert.h>
26  #include <glibmm/dispatcher.h>  #include <glibmm/dispatcher.h>
27  #include <glibmm/miscutils.h>  #include <glibmm/miscutils.h>
28  #include <glibmm/stringutils.h>  #include <glibmm/stringutils.h>
29    #include <glibmm/regex.h>
30  #include <gtkmm/aboutdialog.h>  #include <gtkmm/aboutdialog.h>
31  #include <gtkmm/filechooserdialog.h>  #include <gtkmm/filechooserdialog.h>
32  #include <gtkmm/messagedialog.h>  #include <gtkmm/messagedialog.h>
33  #include <gtkmm/stock.h>  #if HAS_GTKMM_STOCK
34    # include <gtkmm/stock.h>
35    #endif
36  #include <gtkmm/targetentry.h>  #include <gtkmm/targetentry.h>
37  #include <gtkmm/main.h>  #include <gtkmm/main.h>
38  #include <gtkmm/toggleaction.h>  #if GTKMM_MAJOR_VERSION < 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION < 89)
39    # include <gtkmm/toggleaction.h>
40    #endif
41    #include <gtkmm/accelmap.h>
42  #if GTKMM_MAJOR_VERSION < 3  #if GTKMM_MAJOR_VERSION < 3
43  #include "wrapLabel.hh"  #include "wrapLabel.hh"
44  #endif  #endif
# Line 39  Line 47 
47  #include "compat.h"  #include "compat.h"
48    
49  #include <stdio.h>  #include <stdio.h>
50  #include <sndfile.h>  #ifdef LIBSNDFILE_HEADER_FILE
51    # include LIBSNDFILE_HEADER_FILE(sndfile.h)
52    #else
53    # include <sndfile.h>
54    #endif
55  #include <assert.h>  #include <assert.h>
56    
57  #include "mainwindow.h"  #include "mainwindow.h"
# Line 50  Line 62 
62  #include "ReferencesView.h"  #include "ReferencesView.h"
63  #include "../../gfx/status_attached.xpm"  #include "../../gfx/status_attached.xpm"
64  #include "../../gfx/status_detached.xpm"  #include "../../gfx/status_detached.xpm"
65    #include "gfx/builtinpix.h"
66    #include "MacroEditor.h"
67    #include "MacrosSetup.h"
68    #if defined(__APPLE__)
69    # include "MacHelper.h"
70    #endif
71    
72    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  MainWindow::MainWindow() :  MainWindow::MainWindow() :
80      m_DimRegionChooser(*this),      m_DimRegionChooser(*this),
81      dimreg_label(_("Changes apply to:")),      dimreg_label(_("Changes apply to:")),
82      dimreg_all_regions(_("all regions")),      dimreg_all_regions(_("all regions")),
83      dimreg_all_dimregs(_("all dimension splits")),      dimreg_all_dimregs(_("all dimension splits")),
84      dimreg_stereo(_("both channels"))      dimreg_stereo(_("both channels")),
85        labelLegend(_("Legend:")),
86        labelNoSample(_(" No Sample")),
87        labelMissingSample(_(" Missing some Sample(s)")),
88        labelLooped(_(" Looped")),
89        labelSomeLoops(_(" Some Loop(s)"))
90  {  {
91        loadBuiltInPix();
92    
93        this->file = NULL;
94    
95  //    set_border_width(5);  //    set_border_width(5);
 //    set_default_size(400, 200);  
96    
97        if (!Settings::singleton()->autoRestoreWindowDimension) {
98    #if GTKMM_MAJOR_VERSION >= 3
99            set_default_size(960, 600);
100    #else
101            set_default_size(865, 600);
102    #endif
103            set_position(Gtk::WIN_POS_CENTER);
104        }
105    
106      add(m_VBox);      add(m_VBox);
107    
# Line 71  MainWindow::MainWindow() : Line 111  MainWindow::MainWindow() :
111    
112      // m_TreeView.set_reorderable();      // m_TreeView.set_reorderable();
113    
114    #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      m_TreeView.signal_button_press_event().connect_notify(      m_TreeView.signal_button_press_event().connect_notify(
119          sigc::mem_fun(*this, &MainWindow::on_button_release));          sigc::mem_fun(*this, &MainWindow::on_button_release));
120    #endif
121    
122      // Add the TreeView tab, inside a ScrolledWindow, with the button underneath:      // Add the TreeView tab, inside a ScrolledWindow, with the button underneath:
123      m_ScrolledWindow.add(m_TreeView);      m_ScrolledWindow.add(m_TreeView);
# Line 85  MainWindow::MainWindow() : Line 130  MainWindow::MainWindow() :
130      m_ScrolledWindowScripts.add(m_TreeViewScripts);      m_ScrolledWindowScripts.add(m_TreeViewScripts);
131      m_ScrolledWindowScripts.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);      m_ScrolledWindowScripts.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
132    
133    #if GTKMM_MAJOR_VERSION < 3
134      m_TreeViewNotebook.set_size_request(300);      m_TreeViewNotebook.set_size_request(300);
135    #endif
136    
137        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    
     m_HPaned.add1(m_TreeViewNotebook);  
147      dimreg_hbox.add(dimreg_label);      dimreg_hbox.add(dimreg_label);
148      dimreg_hbox.add(dimreg_all_regions);      dimreg_hbox.add(dimreg_all_regions);
149      dimreg_hbox.add(dimreg_all_dimregs);      dimreg_hbox.add(dimreg_all_dimregs);
# Line 96  MainWindow::MainWindow() : Line 151  MainWindow::MainWindow() :
151      dimreg_hbox.add(dimreg_stereo);      dimreg_hbox.add(dimreg_stereo);
152      dimreg_vbox.add(dimreg_edit);      dimreg_vbox.add(dimreg_edit);
153      dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);      dimreg_vbox.pack_start(dimreg_hbox, Gtk::PACK_SHRINK);
154        {
155            legend_hbox.add(labelLegend);
156    
157            imageNoSample.set(redDot);
158    #if HAS_GTKMM_ALIGNMENT
159            imageNoSample.set_alignment(Gtk::ALIGN_END);
160            labelNoSample.set_alignment(Gtk::ALIGN_START);
161    #else
162            imageNoSample.set_halign(Gtk::ALIGN_END);
163            labelNoSample.set_halign(Gtk::ALIGN_START);
164    #endif
165            legend_hbox.add(imageNoSample);
166            legend_hbox.add(labelNoSample);
167    
168            imageMissingSample.set(yellowDot);
169    #if HAS_GTKMM_ALIGNMENT
170            imageMissingSample.set_alignment(Gtk::ALIGN_END);
171            labelMissingSample.set_alignment(Gtk::ALIGN_START);
172    #else
173            imageMissingSample.set_halign(Gtk::ALIGN_END);
174            labelMissingSample.set_halign(Gtk::ALIGN_START);
175    #endif
176            legend_hbox.add(imageMissingSample);
177            legend_hbox.add(labelMissingSample);
178    
179            imageLooped.set(blackLoop);
180    #if HAS_GTKMM_ALIGNMENT
181            imageLooped.set_alignment(Gtk::ALIGN_END);
182            labelLooped.set_alignment(Gtk::ALIGN_START);
183    #else
184            imageLooped.set_halign(Gtk::ALIGN_END);
185            labelLooped.set_halign(Gtk::ALIGN_START);
186    #endif
187            legend_hbox.add(imageLooped);
188            legend_hbox.add(labelLooped);
189    
190            imageSomeLoops.set(grayLoop);
191    #if HAS_GTKMM_ALIGNMENT
192            imageSomeLoops.set_alignment(Gtk::ALIGN_END);
193            labelSomeLoops.set_alignment(Gtk::ALIGN_START);
194    #else
195            imageSomeLoops.set_halign(Gtk::ALIGN_END);
196            labelSomeLoops.set_halign(Gtk::ALIGN_START);
197    #endif
198            legend_hbox.add(imageSomeLoops);
199            legend_hbox.add(labelSomeLoops);
200    
201    #if HAS_GTKMM_SHOW_ALL_CHILDREN
202            legend_hbox.show_all_children();
203    #endif
204        }
205        dimreg_vbox.pack_start(legend_hbox, Gtk::PACK_SHRINK);
206      m_HPaned.add2(dimreg_vbox);      m_HPaned.add2(dimreg_vbox);
207    
208      dimreg_label.set_tooltip_text(_("To automatically apply your changes above globally to the entire instrument, check all 3 check boxes on the right."));      dimreg_label.set_tooltip_text(_("To automatically apply your changes above globally to the entire instrument, check all 3 check boxes on the right."));
# Line 107  MainWindow::MainWindow() : Line 214  MainWindow::MainWindow() :
214      m_TreeViewNotebook.append_page(m_ScrolledWindow, _("Instruments"));      m_TreeViewNotebook.append_page(m_ScrolledWindow, _("Instruments"));
215      m_TreeViewNotebook.append_page(m_ScrolledWindowScripts, _("Scripts"));      m_TreeViewNotebook.append_page(m_ScrolledWindowScripts, _("Scripts"));
216    
217    #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      actionGroup = Gtk::ActionGroup::create();      actionGroup = Gtk::ActionGroup::create();
257    
258      actionGroup->add(Gtk::Action::create("MenuFile", _("_File")));      actionGroup->add(Gtk::Action::create("MenuFile", _("_File")));
# Line 156  MainWindow::MainWindow() : Line 302  MainWindow::MainWindow() :
302          sigc::mem_fun(*this, &MainWindow::show_intruments_tab)          sigc::mem_fun(*this, &MainWindow::show_intruments_tab)
303      );      );
304      actionGroup->add(      actionGroup->add(
305          Gtk::Action::create("MenuScript", _("S_cript")),          Gtk::Action::create("MenuScript", _("Scr_ipt")),
306          sigc::mem_fun(*this, &MainWindow::show_scripts_tab)          sigc::mem_fun(*this, &MainWindow::show_scripts_tab)
307      );      );
308      actionGroup->add(Gtk::Action::create("AllInstruments", _("_Select")));      actionGroup->add(Gtk::Action::create("AllInstruments", _("_Select")));
309        actionGroup->add(Gtk::Action::create("AssignScripts", _("Assign Script")));
310    
311      actionGroup->add(Gtk::Action::create("MenuEdit", _("_Edit")));      actionGroup->add(Gtk::Action::create("MenuEdit", _("_Edit")));
312    #endif
313    
314        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    #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        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        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        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        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        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    
422        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    #endif
427    
428    #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      Glib::RefPtr<Gtk::ToggleAction> toggle_action =      Glib::RefPtr<Gtk::ToggleAction> toggle_action =
434          Gtk::ToggleAction::create("CopySampleUnity", _("Copy Sample's _Unity Note"));          Gtk::ToggleAction::create("CopySampleUnity", _("Copy Sample's _Unity Note"));
435      toggle_action->set_active(true);      toggle_action->set_active(true);
# Line 177  MainWindow::MainWindow() : Line 444  MainWindow::MainWindow() :
444          Gtk::ToggleAction::create("CopySampleLoop", _("Copy Sample's _Loop Points"));          Gtk::ToggleAction::create("CopySampleLoop", _("Copy Sample's _Loop Points"));
445      toggle_action->set_active(true);      toggle_action->set_active(true);
446      actionGroup->add(toggle_action);      actionGroup->add(toggle_action);
447    #endif
448    
449    #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        m_actionToggleShowTooltips = m_actionGroup->add_action_bool(
455            "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),
456            Settings::singleton()->showTooltips
457        );
458        m_actionToggleSaveWithTempFile =
459            m_actionGroup->add_action_bool("SaveWithTemporaryFile", sigc::mem_fun(*this, &MainWindow::on_save_with_temporary_file), Settings::singleton()->saveWithTemporaryFile);
460        m_actionGroup->add_action("RefreshAll", sigc::mem_fun(*this, &MainWindow::on_action_refresh_all));
461    #else
462        actionGroup->add(Gtk::Action::create("MenuMacro", _("_Macro")));
463    
464    
465      actionGroup->add(Gtk::Action::create("MenuView", _("_View")));      actionGroup->add(Gtk::Action::create("MenuView", _("Vie_w")));
466      toggle_action =      toggle_action =
467          Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));          Gtk::ToggleAction::create("Statusbar", _("_Statusbar"));
468      toggle_action->set_active(true);      toggle_action->set_active(true);
# Line 187  MainWindow::MainWindow() : Line 470  MainWindow::MainWindow() :
470                       sigc::mem_fun(                       sigc::mem_fun(
471                           *this, &MainWindow::on_action_view_status_bar));                           *this, &MainWindow::on_action_view_status_bar));
472    
473        toggle_action =
474            Gtk::ToggleAction::create("AutoRestoreWinDim", _("_Auto Restore Window Dimension"));
475        toggle_action->set_active(Settings::singleton()->autoRestoreWindowDimension);
476        actionGroup->add(toggle_action,
477                         sigc::mem_fun(
478                             *this, &MainWindow::on_auto_restore_win_dim));
479    
480        toggle_action =
481            Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));
482        toggle_action->set_active(Settings::singleton()->showTooltips);
483        actionGroup->add(
484            toggle_action,
485            sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips)
486        );
487    
488        toggle_action =
489            Gtk::ToggleAction::create("SaveWithTemporaryFile", _("Save with _temporary file"));
490        toggle_action->set_active(Settings::singleton()->saveWithTemporaryFile);
491        actionGroup->add(toggle_action,
492                         sigc::mem_fun(
493                             *this, &MainWindow::on_save_with_temporary_file));
494    
495        actionGroup->add(
496            Gtk::Action::create("RefreshAll", _("_Refresh All")),
497            sigc::mem_fun(*this, &MainWindow::on_action_refresh_all)
498        );                
499    #endif
500    
501    #if USE_GLIB_ACTION
502        m_actionGroup->add_action(
503            "About", sigc::mem_fun(*this, &MainWindow::on_action_help_about)
504        );
505        m_actionGroup->add_action(
506            "AddInstrument", sigc::mem_fun(*this, &MainWindow::on_action_add_instrument)
507        );
508        m_actionGroup->add_action(
509            "DupInstrument", sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
510        );
511        m_actionGroup->add_action(
512            "CombInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
513        );
514        m_actionGroup->add_action(
515            "RemoveInstrument", sigc::mem_fun(*this, &MainWindow::on_action_remove_instrument)
516        );
517    #else
518      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);      action = Gtk::Action::create("MenuHelp", Gtk::Stock::HELP);
519      actionGroup->add(Gtk::Action::create("MenuHelp",      actionGroup->add(Gtk::Action::create("MenuHelp",
520                                           action->property_label()));                                           action->property_label()));
# Line 202  MainWindow::MainWindow() : Line 530  MainWindow::MainWindow() :
530          sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)          sigc::mem_fun(*this, &MainWindow::on_action_duplicate_instrument)
531      );      );
532      actionGroup->add(      actionGroup->add(
533            Gtk::Action::create("CombInstruments", _("_Combine Instruments ...")),
534            Gtk::AccelKey(GDK_KEY_j, primaryModifierKey),
535            sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
536        );
537        actionGroup->add(
538          Gtk::Action::create("RemoveInstrument", Gtk::Stock::REMOVE),          Gtk::Action::create("RemoveInstrument", Gtk::Stock::REMOVE),
539          sigc::mem_fun(*this, &MainWindow::on_action_remove_instrument)          sigc::mem_fun(*this, &MainWindow::on_action_remove_instrument)
540      );      );
541    #endif
542    
543    #if USE_GLIB_ACTION
544        m_actionToggleWarnOnExtensions = m_actionGroup->add_action_bool(
545            "WarnUserOnExtensions", sigc::mem_fun(*this, &MainWindow::on_action_warn_user_on_extensions),
546            Settings::singleton()->warnUserOnExtensions
547        );
548        m_actionToggleSyncSamplerSelection = m_actionGroup->add_action_bool(
549            "SyncSamplerInstrumentSelection", sigc::mem_fun(*this, &MainWindow::on_action_sync_sampler_instrument_selection),
550            Settings::singleton()->syncSamplerInstrumentSelection
551        );
552        m_actionToggleMoveRootNoteWithRegion = m_actionGroup->add_action_bool(
553            "MoveRootNoteWithRegionMoved", sigc::mem_fun(*this, &MainWindow::on_action_move_root_note_with_region_moved),
554            Settings::singleton()->moveRootNoteWithRegionMoved
555        );
556    #else
557      actionGroup->add(Gtk::Action::create("MenuSettings", _("_Settings")));      actionGroup->add(Gtk::Action::create("MenuSettings", _("_Settings")));
558            
559      toggle_action =      toggle_action =
# Line 217  MainWindow::MainWindow() : Line 564  MainWindow::MainWindow() :
564          sigc::mem_fun(*this, &MainWindow::on_action_warn_user_on_extensions)          sigc::mem_fun(*this, &MainWindow::on_action_warn_user_on_extensions)
565      );      );
566    
567        toggle_action =
568            Gtk::ToggleAction::create("SyncSamplerInstrumentSelection", _("Synchronize sampler's instrument selection"));
569        toggle_action->set_active(Settings::singleton()->syncSamplerInstrumentSelection);
570        actionGroup->add(
571            toggle_action,
572            sigc::mem_fun(*this, &MainWindow::on_action_sync_sampler_instrument_selection)
573        );
574    
575        toggle_action =
576            Gtk::ToggleAction::create("MoveRootNoteWithRegionMoved", _("Move root note with region moved"));
577        toggle_action->set_active(Settings::singleton()->moveRootNoteWithRegionMoved);
578        actionGroup->add(
579            toggle_action,
580            sigc::mem_fun(*this, &MainWindow::on_action_move_root_note_with_region_moved)
581        );
582    #endif
583    
584    #if USE_GLIB_ACTION
585        m_actionGroup->add_action(
586            "CombineInstruments", sigc::mem_fun(*this, &MainWindow::on_action_combine_instruments)
587        );
588        m_actionGroup->add_action(
589            "MergeFiles", sigc::mem_fun(*this, &MainWindow::on_action_merge_files)
590        );
591    #else
592      actionGroup->add(Gtk::Action::create("MenuTools", _("_Tools")));      actionGroup->add(Gtk::Action::create("MenuTools", _("_Tools")));
593    
594      actionGroup->add(      actionGroup->add(
# Line 229  MainWindow::MainWindow() : Line 600  MainWindow::MainWindow() :
600          Gtk::Action::create("MergeFiles", _("_Merge Files...")),          Gtk::Action::create("MergeFiles", _("_Merge Files...")),
601          sigc::mem_fun(*this, &MainWindow::on_action_merge_files)          sigc::mem_fun(*this, &MainWindow::on_action_merge_files)
602      );      );
603    #endif
604    
605      // sample right-click popup actions      // sample right-click popup actions
606    #if USE_GLIB_ACTION
607        m_actionSampleProperties = m_actionGroup->add_action(
608            "SampleProperties", sigc::mem_fun(*this, &MainWindow::on_action_sample_properties)
609        );
610        m_actionAddSampleGroup = m_actionGroup->add_action(
611            "AddGroup", sigc::mem_fun(*this, &MainWindow::on_action_add_group)
612        );
613        m_actionAddSample = m_actionGroup->add_action(
614            "AddSample", sigc::mem_fun(*this, &MainWindow::on_action_add_sample)
615        );
616        m_actionRemoveSample = m_actionGroup->add_action(
617            "RemoveSample", sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
618        );
619        m_actionGroup->add_action(
620            "RemoveUnusedSamples", sigc::mem_fun(*this, &MainWindow::on_action_remove_unused_samples)
621        );
622        m_actionViewSampleRefs = m_actionGroup->add_action(
623            "ShowSampleRefs", sigc::mem_fun(*this, &MainWindow::on_action_view_references)
624        );
625        m_actionReplaceSample = m_actionGroup->add_action(
626            "ReplaceSample", sigc::mem_fun(*this, &MainWindow::on_action_replace_sample)
627        );
628        m_actionGroup->add_action(
629            "ReplaceAllSamplesInAllGroups", sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
630        );
631    #else
632      actionGroup->add(      actionGroup->add(
633          Gtk::Action::create("SampleProperties", Gtk::Stock::PROPERTIES),          Gtk::Action::create("SampleProperties", Gtk::Stock::PROPERTIES),
634          sigc::mem_fun(*this, &MainWindow::on_action_sample_properties)          sigc::mem_fun(*this, &MainWindow::on_action_sample_properties)
# Line 249  MainWindow::MainWindow() : Line 646  MainWindow::MainWindow() :
646          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)          sigc::mem_fun(*this, &MainWindow::on_action_remove_sample)
647      );      );
648      actionGroup->add(      actionGroup->add(
649            Gtk::Action::create("RemoveUnusedSamples", _("Remove _Unused Samples")),
650            sigc::mem_fun(*this, &MainWindow::on_action_remove_unused_samples)
651        );
652        actionGroup->add(
653          Gtk::Action::create("ShowSampleRefs", _("Show References...")),          Gtk::Action::create("ShowSampleRefs", _("Show References...")),
654          sigc::mem_fun(*this, &MainWindow::on_action_view_references)          sigc::mem_fun(*this, &MainWindow::on_action_view_references)
655      );      );
656      actionGroup->add(      actionGroup->add(
657            Gtk::Action::create("ReplaceSample",
658                                _("Replace Sample...")),
659            sigc::mem_fun(*this, &MainWindow::on_action_replace_sample)
660        );
661        actionGroup->add(
662          Gtk::Action::create("ReplaceAllSamplesInAllGroups",          Gtk::Action::create("ReplaceAllSamplesInAllGroups",
663                              _("Replace All Samples in All Groups...")),                              _("Replace All Samples in All Groups...")),
664          sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)          sigc::mem_fun(*this, &MainWindow::on_action_replace_all_samples_in_all_groups)
665      );      );
666    #endif
667            
668      // script right-click popup actions      // script right-click popup actions
669    #if USE_GLIB_ACTION
670        m_actionAddScriptGroup = m_actionGroup->add_action(
671            "AddScriptGroup", sigc::mem_fun(*this, &MainWindow::on_action_add_script_group)
672        );
673        m_actionAddScript = m_actionGroup->add_action(
674            "AddScript", sigc::mem_fun(*this, &MainWindow::on_action_add_script)
675        );
676        m_actionEditScript = m_actionGroup->add_action(
677            "EditScript", sigc::mem_fun(*this, &MainWindow::on_action_edit_script)
678        );
679        m_actionRemoveScript = m_actionGroup->add_action(
680            "RemoveScript", sigc::mem_fun(*this, &MainWindow::on_action_remove_script)
681        );
682    #else
683      actionGroup->add(      actionGroup->add(
684          Gtk::Action::create("AddScriptGroup", _("Add _Group")),          Gtk::Action::create("AddScriptGroup", _("Add _Group")),
685          sigc::mem_fun(*this, &MainWindow::on_action_add_script_group)          sigc::mem_fun(*this, &MainWindow::on_action_add_script_group)
# Line 275  MainWindow::MainWindow() : Line 696  MainWindow::MainWindow() :
696          Gtk::Action::create("RemoveScript", Gtk::Stock::REMOVE),          Gtk::Action::create("RemoveScript", Gtk::Stock::REMOVE),
697          sigc::mem_fun(*this, &MainWindow::on_action_remove_script)          sigc::mem_fun(*this, &MainWindow::on_action_remove_script)
698      );      );
699    #endif
700    
701    #if USE_GTKMM_BUILDER
702        insert_action_group("AppMenu", m_actionGroup);
703        
704        m_uiManager = Gtk::Builder::create();
705        Glib::ustring ui_info =
706            "<interface>"
707            "  <menubar id='MenuBar'>"
708            "    <menu id='MenuFile'>"
709            "      <attribute name='label' translatable='yes'>_File</attribute>"
710            "      <section>"
711            "        <item id='New'>"
712            "          <attribute name='label' translatable='yes'>New</attribute>"
713            "          <attribute name='action'>AppMenu.New</attribute>"
714            "        </item>"
715            "        <item id='Open'>"
716            "          <attribute name='label' translatable='yes'>Open</attribute>"
717            "          <attribute name='action'>AppMenu.Open</attribute>"
718            "        </item>"
719            "      </section>"
720            "      <section>"
721            "        <item id='Save'>"
722            "          <attribute name='label' translatable='yes'>Save</attribute>"
723            "          <attribute name='action'>AppMenu.Save</attribute>"
724            "        </item>"
725            "        <item id='SaveAs'>"
726            "          <attribute name='label' translatable='yes'>Save As</attribute>"
727            "          <attribute name='action'>AppMenu.SaveAs</attribute>"
728            "        </item>"
729            "      </section>"
730            "      <section>"
731            "        <item id='Properties'>"
732            "          <attribute name='label' translatable='yes'>Properties</attribute>"
733            "          <attribute name='action'>AppMenu.Properties</attribute>"
734            "        </item>"
735            "      </section>"
736            "      <section>"
737            "        <item id='Quit'>"
738            "          <attribute name='label' translatable='yes'>Quit</attribute>"
739            "          <attribute name='action'>AppMenu.Quit</attribute>"
740            "        </item>"
741            "      </section>"
742            "    </menu>"
743            "    <menu id='MenuEdit'>"
744            "      <attribute name='label' translatable='yes'>Edit</attribute>"
745            "      <section>"
746            "        <item id='CopyDimRgn'>"
747            "          <attribute name='label' translatable='yes'>Copy Dimension Region</attribute>"
748            "          <attribute name='action'>AppMenu.CopyDimRgn</attribute>"
749            "        </item>"
750            "        <item id='AdjustClipboard'>"
751            "          <attribute name='label' translatable='yes'>Adjust Clipboard</attribute>"
752            "          <attribute name='action'>AppMenu.AdjustClipboard</attribute>"
753            "        </item>"
754            "        <item id='PasteDimRgn'>"
755            "          <attribute name='label' translatable='yes'>Paste Dimension Region</attribute>"
756            "          <attribute name='action'>AppMenu.PasteDimRgn</attribute>"
757            "        </item>"
758            "      </section>"
759            "        <item id='SelectPrevInstr'>"
760            "          <attribute name='label' translatable='yes'>Previous Instrument</attribute>"
761            "          <attribute name='action'>AppMenu.SelectPrevInstr</attribute>"
762            "        </item>"
763            "        <item id='SelectNextInstr'>"
764            "          <attribute name='label' translatable='yes'>Next Instrument</attribute>"
765            "          <attribute name='action'>AppMenu.SelectNextInstr</attribute>"
766            "        </item>"
767            "      <section>"
768            "        <item id='SelectPrevRegion'>"
769            "          <attribute name='label' translatable='yes'>Previous Region</attribute>"
770            "          <attribute name='action'>AppMenu.SelectPrevRegion</attribute>"
771            "        </item>"
772            "        <item id='SelectNextRegion'>"
773            "          <attribute name='label' translatable='yes'>Next Region</attribute>"
774            "          <attribute name='action'>AppMenu.SelectNextRegion</attribute>"
775            "        </item>"
776            "      </section>"
777            "        <item id='SelectPrevDimension'>"
778            "          <attribute name='label' translatable='yes'>Previous Dimension</attribute>"
779            "          <attribute name='action'>AppMenu.SelectPrevDimension</attribute>"
780            "        </item>"
781            "        <item id='SelectNextDimension'>"
782            "          <attribute name='label' translatable='yes'>Next Dimension</attribute>"
783            "          <attribute name='action'>AppMenu.SelectNextDimension</attribute>"
784            "        </item>"
785            "        <item id='SelectPrevDimRgnZone'>"
786            "          <attribute name='label' translatable='yes'>Previous Dimension Region Zone</attribute>"
787            "          <attribute name='action'>AppMenu.SelectPrevDimRgnZone</attribute>"
788            "        </item>"
789            "        <item id='SelectNextDimRgnZone'>"
790            "          <attribute name='label' translatable='yes'>Next Dimension Region Zone</attribute>"
791            "          <attribute name='action'>AppMenu.SelectNextDimRgnZone</attribute>"
792            "        </item>"
793            "        <item id='SelectAddPrevDimRgnZone'>"
794            "          <attribute name='label' translatable='yes'>Add Previous Dimension Region Zone</attribute>"
795            "          <attribute name='action'>AppMenu.SelectAddPrevDimRgnZone</attribute>"
796            "        </item>"
797            "        <item id='SelectAddNextDimRgnZone'>"
798            "          <attribute name='label' translatable='yes'>Add Next Dimension Region Zone</attribute>"
799            "          <attribute name='action'>AppMenu.SelectAddNextDimRgnZone</attribute>"
800            "        </item>"
801            "      <section>"
802            "        <item id='CopySampleUnity'>"
803            "          <attribute name='label' translatable='yes'>Copy Sample Unity</attribute>"
804            "          <attribute name='action'>AppMenu.CopySampleUnity</attribute>"
805            "        </item>"
806            "        <item id='CopySampleTune'>"
807            "          <attribute name='label' translatable='yes'>Copy Sample Tune</attribute>"
808            "          <attribute name='action'>AppMenu.CopySampleTune</attribute>"
809            "        </item>"
810            "        <item id='CopySampleLoop'>"
811            "          <attribute name='label' translatable='yes'>Copy Sample Loop</attribute>"
812            "          <attribute name='action'>AppMenu.CopySampleLoop</attribute>"
813            "        </item>"
814            "      </section>"
815            "    </menu>"
816            "    <menu id='MenuMacro'>"
817            "      <attribute name='label' translatable='yes'>Macro</attribute>"
818            "      <section>"
819            "      </section>"
820            "    </menu>"
821            "    <menu id='MenuSample'>"
822            "      <attribute name='label' translatable='yes'>Sample</attribute>"
823            "      <section>"
824            "        <item id='SampleProperties'>"
825            "          <attribute name='label' translatable='yes'>Properties</attribute>"
826            "          <attribute name='action'>AppMenu.SampleProperties</attribute>"
827            "        </item>"
828            "        <item id='AddGroup'>"
829            "          <attribute name='label' translatable='yes'>Add Group</attribute>"
830            "          <attribute name='action'>AppMenu.AddGroup</attribute>"
831            "        </item>"
832            "        <item id='AddSample'>"
833            "          <attribute name='label' translatable='yes'>Add Sample</attribute>"
834            "          <attribute name='action'>AppMenu.AddSample</attribute>"
835            "        </item>"
836            "        <item id='ShowSampleRefs'>"
837            "          <attribute name='label' translatable='yes'>Show Sample References</attribute>"
838            "          <attribute name='action'>AppMenu.ShowSampleRefs</attribute>"
839            "        </item>"
840            "        <item id='ReplaceSample'>"
841            "          <attribute name='label' translatable='yes'>Replace Sample</attribute>"
842            "          <attribute name='action'>AppMenu.ReplaceSample</attribute>"
843            "        </item>"
844            "        <item id='ReplaceAllSamplesInAllGroups'>"
845            "          <attribute name='label' translatable='yes'>Replace all Samples in all Groups</attribute>"
846            "          <attribute name='action'>AppMenu.ReplaceAllSamplesInAllGroups</attribute>"
847            "        </item>"
848            "      </section>"
849            "      <section>"
850            "        <item id='RemoveSample'>"
851            "          <attribute name='label' translatable='yes'>Remove Sample</attribute>"
852            "          <attribute name='action'>AppMenu.RemoveSample</attribute>"
853            "        </item>"
854            "        <item id='RemoveUnusedSamples'>"
855            "          <attribute name='label' translatable='yes'>Remove unused Samples</attribute>"
856            "          <attribute name='action'>AppMenu.RemoveUnusedSamples</attribute>"
857            "        </item>"
858            "      </section>"
859            "    </menu>"
860            "    <menu id='MenuInstrument'>"
861            "      <attribute name='label' translatable='yes'>Instrument</attribute>"
862            "      <section>"
863            "        <item id='InstrProperties'>"
864            "          <attribute name='label' translatable='yes'>Properties</attribute>"
865            "          <attribute name='action'>AppMenu.InstrProperties</attribute>"
866            "        </item>"
867            "        <item id='MidiRules'>"
868            "          <attribute name='label' translatable='yes'>MIDI Rules</attribute>"
869            "          <attribute name='action'>AppMenu.MidiRules</attribute>"
870            "        </item>"
871            "        <item id='ScriptSlots'>"
872            "          <attribute name='label' translatable='yes'>Script Slots</attribute>"
873            "          <attribute name='action'>AppMenu.ScriptSlots</attribute>"
874            "        </item>"
875            "      </section>"
876            "      <submenu id='AssignScripts'>"
877            "        <attribute name='label' translatable='yes'>Assign Scripts</attribute>"
878            "      </submenu>"
879            "      <section>"
880            "        <item id='AddInstrument'>"
881            "          <attribute name='label' translatable='yes'>Add Instrument</attribute>"
882            "          <attribute name='action'>AppMenu.AddInstrument</attribute>"
883            "        </item>"
884            "        <item id='DupInstrument'>"
885            "          <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
886            "          <attribute name='action'>AppMenu.DupInstrument</attribute>"
887            "        </item>"
888            "        <item id='CombInstruments'>"
889            "          <attribute name='label' translatable='yes'>Combine Instrument</attribute>"
890            "          <attribute name='action'>AppMenu.CombInstruments</attribute>"
891            "        </item>"
892            "      </section>"
893            "      <section>"
894            "        <item id='RemoveInstrument'>"
895            "          <attribute name='label' translatable='yes'>Remove Instrument</attribute>"
896            "          <attribute name='action'>AppMenu.RemoveInstrument</attribute>"
897            "        </item>"
898            "      </section>"
899            "    </menu>"
900            "    <menu id='MenuScript'>"
901            "      <attribute name='label' translatable='yes'>Script</attribute>"
902            "      <section>"
903            "        <item id='AddScriptGroup'>"
904            "          <attribute name='label' translatable='yes'>Add Script Group</attribute>"
905            "          <attribute name='action'>AppMenu.AddScriptGroup</attribute>"
906            "        </item>"
907            "        <item id='AddScript'>"
908            "          <attribute name='label' translatable='yes'>Add Script</attribute>"
909            "          <attribute name='action'>AppMenu.AddScript</attribute>"
910            "        </item>"
911            "        <item id='EditScript'>"
912            "          <attribute name='label' translatable='yes'>Edit Script</attribute>"
913            "          <attribute name='action'>AppMenu.EditScript</attribute>"
914            "        </item>"
915            "      </section>"
916            "      <section>"
917            "        <item id='RemoveScript'>"
918            "          <attribute name='label' translatable='yes'>Remove Script</attribute>"
919            "          <attribute name='action'>AppMenu.RemoveScript</attribute>"
920            "        </item>"
921            "      </section>"
922            "    </menu>"
923            "    <menu id='MenuView'>"
924            "      <attribute name='label' translatable='yes'>View</attribute>"
925            "      <section>"
926            "        <item id='Statusbar'>"
927            "          <attribute name='label' translatable='yes'>Statusbar</attribute>"
928            "          <attribute name='action'>AppMenu.Statusbar</attribute>"
929            "        </item>"
930            "        <item id='ShowTooltips'>"
931            "          <attribute name='label' translatable='yes'>Tooltips for Beginners</attribute>"
932            "          <attribute name='action'>AppMenu.ShowTooltips</attribute>"
933            "        </item>"
934            "        <item id='AutoRestoreWinDim'>"
935            "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"
936            "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"
937            "        </item>"
938            "      </section>"
939            "      <section>"
940            "        <item id='RefreshAll'>"
941            "          <attribute name='label' translatable='yes'>Refresh All</attribute>"
942            "          <attribute name='action'>AppMenu.RefreshAll</attribute>"
943            "        </item>"
944            "      </section>"
945            "    </menu>"
946            "    <menu id='MenuTools'>"
947            "      <attribute name='label' translatable='yes'>Tools</attribute>"
948            "      <section>"
949            "        <item id='CombineInstruments'>"
950            "          <attribute name='label' translatable='yes'>Combine Instruments ...</attribute>"
951            "          <attribute name='action'>AppMenu.CombineInstruments</attribute>"
952            "        </item>"
953            "        <item id='MergeFiles'>"
954            "          <attribute name='label' translatable='yes'>Merge Files ...</attribute>"
955            "          <attribute name='action'>AppMenu.MergeFiles</attribute>"
956            "        </item>"
957            "      </section>"
958            "    </menu>"
959            "    <menu id='MenuSettings'>"
960            "      <attribute name='label' translatable='yes'>Settings</attribute>"
961            "      <section>"
962            "        <item id='WarnUserOnExtensions'>"
963            "          <attribute name='label' translatable='yes'>Warning on Format Extensions</attribute>"
964            "          <attribute name='action'>AppMenu.WarnUserOnExtensions</attribute>"
965            "        </item>"
966            "        <item id='SyncSamplerInstrumentSelection'>"
967            "          <attribute name='label' translatable='yes'>Synchronize Sampler Selection</attribute>"
968            "          <attribute name='action'>AppMenu.SyncSamplerInstrumentSelection</attribute>"
969            "        </item>"
970            "        <item id='MoveRootNoteWithRegionMoved'>"
971            "          <attribute name='label' translatable='yes'>Move Root Note with Region moved</attribute>"
972            "          <attribute name='action'>AppMenu.MoveRootNoteWithRegionMoved</attribute>"
973            "        </item>"
974            "        <item id='SaveWithTemporaryFile'>"
975            "          <attribute name='label' translatable='yes'>Save with temporary file</attribute>"
976            "          <attribute name='action'>AppMenu.SaveWithTemporaryFile</attribute>"
977            "        </item>"
978            "      </section>"
979            "    </menu>"
980            "    <menu id='MenuHelp'>"
981            "      <attribute name='label' translatable='yes'>Help</attribute>"
982            "      <section>"
983            "        <item id='About'>"
984            "          <attribute name='label' translatable='yes'>About ...</attribute>"
985            "          <attribute name='action'>AppMenu.About</attribute>"
986            "        </item>"
987            "      </section>"
988            "    </menu>"
989            "  </menubar>"
990            // popups
991            "  <menu id='PopupMenu'>"
992            "    <section>"
993            "      <item id='InstrProperties'>"
994            "        <attribute name='label' translatable='yes'>Instrument Properties</attribute>"
995            "        <attribute name='action'>AppMenu.InstrProperties</attribute>"
996            "      </item>"
997            "      <item id='MidiRules'>"
998            "        <attribute name='label' translatable='yes'>MIDI Rules</attribute>"
999            "        <attribute name='action'>AppMenu.MidiRules</attribute>"
1000            "      </item>"
1001            "      <item id='ScriptSlots'>"
1002            "        <attribute name='label' translatable='yes'>Script Slots</attribute>"
1003            "        <attribute name='action'>AppMenu.ScriptSlots</attribute>"
1004            "      </item>"
1005            "      <item id='AddInstrument'>"
1006            "        <attribute name='label' translatable='yes'>Add Instrument</attribute>"
1007            "        <attribute name='action'>AppMenu.AddInstrument</attribute>"
1008            "      </item>"
1009            "      <item id='DupInstrument'>"
1010            "        <attribute name='label' translatable='yes'>Duplicate Instrument</attribute>"
1011            "        <attribute name='action'>AppMenu.DupInstrument</attribute>"
1012            "      </item>"
1013            "      <item id='CombInstruments'>"
1014            "        <attribute name='label' translatable='yes'>Combine Instruments</attribute>"
1015            "        <attribute name='action'>AppMenu.CombInstruments</attribute>"
1016            "      </item>"
1017            "    </section>"
1018            "    <section>"
1019            "      <item id='RemoveInstrument'>"
1020            "        <attribute name='label' translatable='yes'>Remove Instruments</attribute>"
1021            "        <attribute name='action'>AppMenu.RemoveInstrument</attribute>"
1022            "      </item>"
1023            "    </section>"
1024            "  </menu>"
1025            "  <menu id='SamplePopupMenu'>"
1026            "    <section>"
1027            "      <item id='SampleProperties'>"
1028            "        <attribute name='label' translatable='yes'>Sample Properties</attribute>"
1029            "        <attribute name='action'>AppMenu.SampleProperties</attribute>"
1030            "      </item>"
1031            "      <item id='AddGroup'>"
1032            "        <attribute name='label' translatable='yes'>Add Sample Group</attribute>"
1033            "        <attribute name='action'>AppMenu.AddGroup</attribute>"
1034            "      </item>"
1035            "      <item id='AddSample'>"
1036            "        <attribute name='label' translatable='yes'>Add Sample</attribute>"
1037            "        <attribute name='action'>AppMenu.AddSample</attribute>"
1038            "      </item>"
1039            "      <item id='ShowSampleRefs'>"
1040            "        <attribute name='label' translatable='yes'>Show Sample References ...</attribute>"
1041            "        <attribute name='action'>AppMenu.ShowSampleRefs</attribute>"
1042            "      </item>"
1043            "      <item id='ReplaceSample'>"
1044            "        <attribute name='label' translatable='yes'>Replace Sample</attribute>"
1045            "        <attribute name='action'>AppMenu.ReplaceSample</attribute>"
1046            "      </item>"
1047            "      <item id='ReplaceAllSamplesInAllGroups'>"
1048            "        <attribute name='label' translatable='yes'>Replace all Samples ...</attribute>"
1049            "        <attribute name='action'>AppMenu.ReplaceAllSamplesInAllGroups</attribute>"
1050            "      </item>"
1051            "    </section>"
1052            "    <section>"
1053            "      <item id='RemoveSample'>"
1054            "        <attribute name='label' translatable='yes'>Remove Sample</attribute>"
1055            "        <attribute name='action'>AppMenu.RemoveSample</attribute>"
1056            "      </item>"
1057            "      <item id='RemoveUnusedSamples'>"
1058            "        <attribute name='label' translatable='yes'>Remove unused Samples</attribute>"
1059            "        <attribute name='action'>AppMenu.RemoveUnusedSamples</attribute>"
1060            "      </item>"
1061            "    </section>"
1062            "  </menu>"
1063            "  <menu id='ScriptPopupMenu'>"
1064            "    <section>"
1065            "      <item id='AddScriptGroup'>"
1066            "        <attribute name='label' translatable='yes'>Add Script Group</attribute>"
1067            "        <attribute name='action'>AppMenu.AddScriptGroup</attribute>"
1068            "      </item>"
1069            "      <item id='AddScript'>"
1070            "        <attribute name='label' translatable='yes'>Add Script</attribute>"
1071            "        <attribute name='action'>AppMenu.AddScript</attribute>"
1072            "      </item>"
1073            "      <item id='EditScript'>"
1074            "        <attribute name='label' translatable='yes'>Edit Script</attribute>"
1075            "        <attribute name='action'>AppMenu.EditScript</attribute>"
1076            "      </item>"
1077            "    </section>"
1078            "    <section>"
1079            "      <item id='RemoveScript'>"
1080            "        <attribute name='label' translatable='yes'>Remove Script</attribute>"
1081            "        <attribute name='action'>AppMenu.RemoveScript</attribute>"
1082            "      </item>"
1083            "    </section>"
1084            "  </menu>"
1085            "</interface>";
1086        m_uiManager->add_from_string(ui_info);
1087    #else
1088      uiManager = Gtk::UIManager::create();      uiManager = Gtk::UIManager::create();
1089      uiManager->insert_action_group(actionGroup);      uiManager->insert_action_group(actionGroup);
1090      add_accel_group(uiManager->get_accel_group());      add_accel_group(uiManager->get_accel_group());
# Line 295  MainWindow::MainWindow() : Line 1104  MainWindow::MainWindow() :
1104          "      <menuitem action='Quit'/>"          "      <menuitem action='Quit'/>"
1105          "    </menu>"          "    </menu>"
1106          "    <menu action='MenuEdit'>"          "    <menu action='MenuEdit'>"
1107            "      <menuitem action='CopyDimRgn'/>"
1108            "      <menuitem action='AdjustClipboard'/>"
1109            "      <menuitem action='PasteDimRgn'/>"
1110            "      <separator/>"
1111            "      <menuitem action='SelectPrevInstr'/>"
1112            "      <menuitem action='SelectNextInstr'/>"
1113            "      <separator/>"
1114            "      <menuitem action='SelectPrevRegion'/>"
1115            "      <menuitem action='SelectNextRegion'/>"
1116            "      <separator/>"
1117            "      <menuitem action='SelectPrevDimension'/>"
1118            "      <menuitem action='SelectNextDimension'/>"
1119            "      <menuitem action='SelectPrevDimRgnZone'/>"
1120            "      <menuitem action='SelectNextDimRgnZone'/>"
1121            "      <menuitem action='SelectAddPrevDimRgnZone'/>"
1122            "      <menuitem action='SelectAddNextDimRgnZone'/>"
1123            "      <separator/>"
1124          "      <menuitem action='CopySampleUnity'/>"          "      <menuitem action='CopySampleUnity'/>"
1125          "      <menuitem action='CopySampleTune'/>"          "      <menuitem action='CopySampleTune'/>"
1126          "      <menuitem action='CopySampleLoop'/>"          "      <menuitem action='CopySampleLoop'/>"
1127          "    </menu>"          "    </menu>"
1128            "    <menu action='MenuMacro'>"
1129            "    </menu>"
1130          "    <menu action='MenuSample'>"          "    <menu action='MenuSample'>"
1131          "      <menuitem action='SampleProperties'/>"          "      <menuitem action='SampleProperties'/>"
1132          "      <menuitem action='AddGroup'/>"          "      <menuitem action='AddGroup'/>"
1133          "      <menuitem action='AddSample'/>"          "      <menuitem action='AddSample'/>"
1134          "      <menuitem action='ShowSampleRefs'/>"          "      <menuitem action='ShowSampleRefs'/>"
1135            "      <menuitem action='ReplaceSample' />"
1136          "      <menuitem action='ReplaceAllSamplesInAllGroups' />"          "      <menuitem action='ReplaceAllSamplesInAllGroups' />"
1137          "      <separator/>"          "      <separator/>"
1138          "      <menuitem action='RemoveSample'/>"          "      <menuitem action='RemoveSample'/>"
1139            "      <menuitem action='RemoveUnusedSamples'/>"
1140          "    </menu>"          "    </menu>"
1141          "    <menu action='MenuInstrument'>"          "    <menu action='MenuInstrument'>"
1142          "      <menu action='AllInstruments'>"          "      <menu action='AllInstruments'>"
# Line 315  MainWindow::MainWindow() : Line 1145  MainWindow::MainWindow() :
1145          "      <menuitem action='InstrProperties'/>"          "      <menuitem action='InstrProperties'/>"
1146          "      <menuitem action='MidiRules'/>"          "      <menuitem action='MidiRules'/>"
1147          "      <menuitem action='ScriptSlots'/>"          "      <menuitem action='ScriptSlots'/>"
1148            "      <menu action='AssignScripts'/>"
1149          "      <menuitem action='AddInstrument'/>"          "      <menuitem action='AddInstrument'/>"
1150          "      <menuitem action='DupInstrument'/>"          "      <menuitem action='DupInstrument'/>"
1151            "      <menuitem action='CombInstruments'/>"
1152          "      <separator/>"          "      <separator/>"
1153          "      <menuitem action='RemoveInstrument'/>"          "      <menuitem action='RemoveInstrument'/>"
1154          "    </menu>"          "    </menu>"
# Line 329  MainWindow::MainWindow() : Line 1161  MainWindow::MainWindow() :
1161          "    </menu>"          "    </menu>"
1162          "    <menu action='MenuView'>"          "    <menu action='MenuView'>"
1163          "      <menuitem action='Statusbar'/>"          "      <menuitem action='Statusbar'/>"
1164            "      <menuitem action='ShowTooltips'/>"
1165            "      <menuitem action='AutoRestoreWinDim'/>"
1166            "      <separator/>"
1167            "      <menuitem action='RefreshAll'/>"
1168          "    </menu>"          "    </menu>"
1169          "    <menu action='MenuTools'>"          "    <menu action='MenuTools'>"
1170          "      <menuitem action='CombineInstruments'/>"          "      <menuitem action='CombineInstruments'/>"
# Line 336  MainWindow::MainWindow() : Line 1172  MainWindow::MainWindow() :
1172          "    </menu>"          "    </menu>"
1173          "    <menu action='MenuSettings'>"          "    <menu action='MenuSettings'>"
1174          "      <menuitem action='WarnUserOnExtensions'/>"          "      <menuitem action='WarnUserOnExtensions'/>"
1175            "      <menuitem action='SyncSamplerInstrumentSelection'/>"
1176            "      <menuitem action='MoveRootNoteWithRegionMoved'/>"
1177            "      <menuitem action='SaveWithTemporaryFile'/>"
1178          "    </menu>"          "    </menu>"
1179          "    <menu action='MenuHelp'>"          "    <menu action='MenuHelp'>"
1180          "      <menuitem action='About'/>"          "      <menuitem action='About'/>"
# Line 347  MainWindow::MainWindow() : Line 1186  MainWindow::MainWindow() :
1186          "    <menuitem action='ScriptSlots'/>"          "    <menuitem action='ScriptSlots'/>"
1187          "    <menuitem action='AddInstrument'/>"          "    <menuitem action='AddInstrument'/>"
1188          "    <menuitem action='DupInstrument'/>"          "    <menuitem action='DupInstrument'/>"
1189            "    <menuitem action='CombInstruments'/>"
1190          "    <separator/>"          "    <separator/>"
1191          "    <menuitem action='RemoveInstrument'/>"          "    <menuitem action='RemoveInstrument'/>"
1192          "  </popup>"          "  </popup>"
# Line 355  MainWindow::MainWindow() : Line 1195  MainWindow::MainWindow() :
1195          "    <menuitem action='AddGroup'/>"          "    <menuitem action='AddGroup'/>"
1196          "    <menuitem action='AddSample'/>"          "    <menuitem action='AddSample'/>"
1197          "    <menuitem action='ShowSampleRefs'/>"          "    <menuitem action='ShowSampleRefs'/>"
1198            "    <menuitem action='ReplaceSample' />"
1199          "    <menuitem action='ReplaceAllSamplesInAllGroups' />"          "    <menuitem action='ReplaceAllSamplesInAllGroups' />"
1200          "    <separator/>"          "    <separator/>"
1201          "    <menuitem action='RemoveSample'/>"          "    <menuitem action='RemoveSample'/>"
1202            "    <menuitem action='RemoveUnusedSamples'/>"
1203          "  </popup>"          "  </popup>"
1204          "  <popup name='ScriptPopupMenu'>"          "  <popup name='ScriptPopupMenu'>"
1205          "    <menuitem action='AddScriptGroup'/>"          "    <menuitem action='AddScriptGroup'/>"
# Line 368  MainWindow::MainWindow() : Line 1210  MainWindow::MainWindow() :
1210          "  </popup>"          "  </popup>"
1211          "</ui>";          "</ui>";
1212      uiManager->add_ui_from_string(ui_info);      uiManager->add_ui_from_string(ui_info);
1213    #endif
1214    
1215    #if USE_GTKMM_BUILDER
1216        popup_menu = new Gtk::Menu(
1217            Glib::RefPtr<Gio::Menu>::cast_dynamic(
1218                m_uiManager->get_object("PopupMenu")
1219            )
1220        );
1221        sample_popup = new Gtk::Menu(
1222            Glib::RefPtr<Gio::Menu>::cast_dynamic(
1223                m_uiManager->get_object("SamplePopupMenu")
1224            )
1225        );
1226        script_popup = new Gtk::Menu(
1227            Glib::RefPtr<Gio::Menu>::cast_dynamic(
1228                m_uiManager->get_object("ScriptPopupMenu")
1229            )
1230        );
1231    #else
1232      popup_menu = dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/PopupMenu"));      popup_menu = dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/PopupMenu"));
1233            
1234      // Set tooltips for menu items (for some reason, setting a tooltip on the      // Set tooltips for menu items (for some reason, setting a tooltip on the
# Line 388  MainWindow::MainWindow() : Line 1248  MainWindow::MainWindow() :
1248      {      {
1249          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1250              uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));              uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));
1251          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 informations to be altered by this action."));          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."));
1252      }      }
1253      {      {
1254          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
# Line 397  MainWindow::MainWindow() : Line 1257  MainWindow::MainWindow() :
1257      }      }
1258      {      {
1259          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1260                uiManager->get_widget("/MenuBar/MenuSettings/SyncSamplerInstrumentSelection"));
1261            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)."));
1262        }
1263        {
1264            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1265                uiManager->get_widget("/MenuBar/MenuSettings/MoveRootNoteWithRegionMoved"));
1266            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."));
1267        }
1268        {
1269            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1270                uiManager->get_widget("/MenuBar/MenuSample/RemoveUnusedSamples"));
1271            item->set_tooltip_text(_("Removes all samples that are not referenced by any instrument (i.e. red ones)."));
1272            // copy tooltip to popup menu
1273            Gtk::MenuItem* item2 = dynamic_cast<Gtk::MenuItem*>(
1274                uiManager->get_widget("/SamplePopupMenu/RemoveUnusedSamples"));
1275            item2->set_tooltip_text(item->get_tooltip_text());
1276        }
1277        {
1278            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1279                uiManager->get_widget("/MenuBar/MenuView/RefreshAll"));
1280            item->set_tooltip_text(_("Reloads the currently open gig file and updates the entire graphical user interface."));
1281        }
1282        {
1283            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1284                uiManager->get_widget("/MenuBar/MenuView/AutoRestoreWinDim"));
1285            item->set_tooltip_text(_("If checked, size and position of all windows will be saved and automatically restored next time."));
1286        }
1287        {
1288            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1289              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));
1290          item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));          item->set_tooltip_text(_("Create combi sounds out of individual sounds of this .gig file."));
1291      }      }
# Line 405  MainWindow::MainWindow() : Line 1294  MainWindow::MainWindow() :
1294              uiManager->get_widget("/MenuBar/MenuTools/MergeFiles"));              uiManager->get_widget("/MenuBar/MenuTools/MergeFiles"));
1295          item->set_tooltip_text(_("Add instruments and samples of other .gig files to this .gig file."));          item->set_tooltip_text(_("Add instruments and samples of other .gig files to this .gig file."));
1296      }      }
1297    #endif
1298    
1299    #if USE_GTKMM_BUILDER
1300        assign_scripts_menu = new Gtk::Menu(
1301            Glib::RefPtr<Gio::Menu>::cast_dynamic(
1302                m_uiManager->get_object("AssignScripts")
1303            )
1304        );
1305    #else
1306      instrument_menu = static_cast<Gtk::MenuItem*>(      instrument_menu = static_cast<Gtk::MenuItem*>(
1307          uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments"))->get_submenu();          uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments"))->get_submenu();
1308    
1309        assign_scripts_menu = static_cast<Gtk::MenuItem*>(
1310            uiManager->get_widget("/MenuBar/MenuInstrument/AssignScripts"))->get_submenu();
1311    #endif
1312    
1313    #if USE_GTKMM_BUILDER
1314        Gtk::Widget* menuBar = NULL;
1315        m_uiManager->get_widget("MenuBar", menuBar);
1316    #else
1317      Gtk::Widget* menuBar = uiManager->get_widget("/MenuBar");      Gtk::Widget* menuBar = uiManager->get_widget("/MenuBar");
1318    #endif
1319    
1320      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);      m_VBox.pack_start(*menuBar, Gtk::PACK_SHRINK);
1321      m_VBox.pack_start(m_HPaned);      m_VBox.pack_start(m_HPaned);
1322      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);      m_VBox.pack_start(m_RegionChooser, Gtk::PACK_SHRINK);
# Line 421  MainWindow::MainWindow() : Line 1327  MainWindow::MainWindow() :
1327      set_file_is_shared(false);      set_file_is_shared(false);
1328    
1329      // Status Bar:      // Status Bar:
1330    #if USE_GTKMM_BOX
1331    # warning No status bar layout for GTKMM 4 yet
1332    #else
1333      m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);      m_StatusBar.pack_start(m_AttachedStateLabel, Gtk::PACK_SHRINK);
1334      m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);      m_StatusBar.pack_start(m_AttachedStateImage, Gtk::PACK_SHRINK);
1335    #endif
1336      m_StatusBar.show();      m_StatusBar.show();
1337    
1338      m_RegionChooser.signal_region_selected().connect(      m_RegionChooser.signal_region_selected().connect(
# Line 433  MainWindow::MainWindow() : Line 1343  MainWindow::MainWindow() :
1343    
1344      // Create the Tree model:      // Create the Tree model:
1345      m_refTreeModel = Gtk::ListStore::create(m_Columns);      m_refTreeModel = Gtk::ListStore::create(m_Columns);
1346      m_TreeView.set_model(m_refTreeModel);      m_refTreeModelFilter = Gtk::TreeModelFilter::create(m_refTreeModel);
1347      m_TreeView.set_tooltip_text(_("Right click here for actions on instruments & MIDI Rules."));      m_refTreeModelFilter->set_visible_func(
1348            sigc::mem_fun(*this, &MainWindow::instrument_row_visible)
1349        );
1350        m_TreeView.set_model(m_refTreeModelFilter);
1351    
1352        m_TreeView.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1353        m_TreeView.set_has_tooltip(true);
1354        m_TreeView.signal_query_tooltip().connect(
1355            sigc::mem_fun(*this, &MainWindow::onQueryTreeViewTooltip)
1356        );
1357      instrument_name_connection = m_refTreeModel->signal_row_changed().connect(      instrument_name_connection = m_refTreeModel->signal_row_changed().connect(
1358          sigc::mem_fun(*this, &MainWindow::instrument_name_changed)          sigc::mem_fun(*this, &MainWindow::instrument_name_changed)
1359      );      );
1360    
1361      // Add the TreeView's view columns:      // Add the TreeView's view columns:
1362      m_TreeView.append_column_editable("Instrument", m_Columns.m_col_name);      m_TreeView.append_column(_("Nr"), m_Columns.m_col_nr);
1363      m_TreeView.set_headers_visible(false);      m_TreeView.append_column_editable(_("Instrument"), m_Columns.m_col_name);
1364        m_TreeView.append_column(_("Scripts"), m_Columns.m_col_scripts);
1365        m_TreeView.set_headers_visible(true);
1366        
1367        // establish drag&drop within the instrument tree view, allowing to reorder
1368        // the sequence of instruments within the gig file
1369        {
1370            std::vector<Gtk::TargetEntry> drag_target_instrument;
1371            drag_target_instrument.push_back(Gtk::TargetEntry("gig::Instrument"));
1372            m_TreeView.drag_source_set(drag_target_instrument);
1373            m_TreeView.drag_dest_set(drag_target_instrument);
1374            m_TreeView.signal_drag_begin().connect(
1375                sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_begin)
1376            );
1377            m_TreeView.signal_drag_data_get().connect(
1378                sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drag_data_get)
1379            );
1380            m_TreeView.signal_drag_data_received().connect(
1381                sigc::mem_fun(*this, &MainWindow::on_instruments_treeview_drop_drag_data_received)
1382            );
1383        }
1384    
1385      // create samples treeview (including its data model)      // create samples treeview (including its data model)
1386      m_refSamplesTreeModel = SamplesTreeStore::create(m_SamplesModel);      m_refSamplesTreeModel = SamplesTreeStore::create(m_SamplesModel);
1387      m_TreeViewSamples.set_model(m_refSamplesTreeModel);      m_TreeViewSamples.set_model(m_refSamplesTreeModel);
1388        m_TreeViewSamples.get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1389      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."));      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."));
1390      // m_TreeViewSamples.set_reorderable();      // m_TreeViewSamples.set_reorderable();
1391      m_TreeViewSamples.append_column_editable(_("Name"), m_SamplesModel.m_col_name);      m_TreeViewSamples.append_column_editable(_("Name"), m_SamplesModel.m_col_name);
# Line 467  MainWindow::MainWindow() : Line 1407  MainWindow::MainWindow() :
1407          );          );
1408      }      }
1409      m_TreeViewSamples.set_headers_visible(true);      m_TreeViewSamples.set_headers_visible(true);
1410    #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
1411        m_TreeViewSamples.signal_button_press_event().connect(
1412            sigc::mem_fun(*this, &MainWindow::on_sample_treeview_button_release)
1413        );
1414    #else
1415      m_TreeViewSamples.signal_button_press_event().connect_notify(      m_TreeViewSamples.signal_button_press_event().connect_notify(
1416          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_button_release)          sigc::mem_fun(*this, &MainWindow::on_sample_treeview_button_release)
1417      );      );
1418    #endif
1419      m_refSamplesTreeModel->signal_row_changed().connect(      m_refSamplesTreeModel->signal_row_changed().connect(
1420          sigc::mem_fun(*this, &MainWindow::sample_name_changed)          sigc::mem_fun(*this, &MainWindow::sample_name_changed)
1421      );      );
# Line 486  MainWindow::MainWindow() : Line 1432  MainWindow::MainWindow() :
1432      // m_TreeViewScripts.set_reorderable();      // m_TreeViewScripts.set_reorderable();
1433      m_TreeViewScripts.append_column_editable("Samples", m_ScriptsModel.m_col_name);      m_TreeViewScripts.append_column_editable("Samples", m_ScriptsModel.m_col_name);
1434      m_TreeViewScripts.set_headers_visible(false);      m_TreeViewScripts.set_headers_visible(false);
1435    #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
1436        m_TreeViewScripts.signal_button_press_event().connect(
1437            sigc::mem_fun(*this, &MainWindow::on_script_treeview_button_release)
1438        );
1439    #else
1440      m_TreeViewScripts.signal_button_press_event().connect_notify(      m_TreeViewScripts.signal_button_press_event().connect_notify(
1441          sigc::mem_fun(*this, &MainWindow::on_script_treeview_button_release)          sigc::mem_fun(*this, &MainWindow::on_script_treeview_button_release)
1442      );      );
1443      //FIXME: why the heck does this double click signal_row_activated() only fired while CTRL key is pressed ?  #endif
1444        //FIXME: why the heck does this double click signal_row_activated() only fire while CTRL key is pressed ?
1445      m_TreeViewScripts.signal_row_activated().connect(      m_TreeViewScripts.signal_row_activated().connect(
1446          sigc::mem_fun(*this, &MainWindow::script_double_clicked)          sigc::mem_fun(*this, &MainWindow::script_double_clicked)
1447      );      );
# Line 526  MainWindow::MainWindow() : Line 1478  MainWindow::MainWindow() :
1478          sigc::hide(sigc::mem_fun(*this, &MainWindow::file_changed)));          sigc::hide(sigc::mem_fun(*this, &MainWindow::file_changed)));
1479      m_RegionChooser.signal_instrument_changed().connect(      m_RegionChooser.signal_instrument_changed().connect(
1480          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1481        m_RegionChooser.signal_instrument_changed().connect(
1482            sigc::mem_fun(*this, &MainWindow::region_changed));
1483      m_DimRegionChooser.signal_region_changed().connect(      m_DimRegionChooser.signal_region_changed().connect(
1484          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1485      instrumentProps.signal_changed().connect(      instrumentProps.signal_changed().connect(
1486          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1487      propDialog.signal_changed().connect(      sampleProps.signal_changed().connect(
1488            sigc::mem_fun(*this, &MainWindow::file_changed));
1489        fileProps.signal_changed().connect(
1490          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1491      midiRules.signal_changed().connect(      midiRules.signal_changed().connect(
1492          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
# Line 548  MainWindow::MainWindow() : Line 1504  MainWindow::MainWindow() :
1504          sigc::mem_fun(*this, &MainWindow::on_samples_to_be_removed)          sigc::mem_fun(*this, &MainWindow::on_samples_to_be_removed)
1505      );      );
1506    
1507        dimreg_edit.signal_select_sample().connect(
1508            sigc::mem_fun(*this, &MainWindow::select_sample)
1509        );
1510    
1511      m_RegionChooser.signal_instrument_struct_to_be_changed().connect(      m_RegionChooser.signal_instrument_struct_to_be_changed().connect(
1512          sigc::hide(          sigc::hide(
1513              sigc::bind(              sigc::bind(
1514                  file_structure_to_be_changed_signal.make_slot(),                  file_structure_to_be_changed_signal.make_slot(),
1515    #if SIGCXX_MAJOR_VERSION > 2 || (SIGCXX_MAJOR_VERSION == 2 && SIGCXX_MINOR_VERSION >= 8)
1516                    std::ref(this->file)
1517    #else
1518                  sigc::ref(this->file)                  sigc::ref(this->file)
1519    #endif
1520              )              )
1521          )          )
1522      );      );
# Line 560  MainWindow::MainWindow() : Line 1524  MainWindow::MainWindow() :
1524          sigc::hide(          sigc::hide(
1525              sigc::bind(              sigc::bind(
1526                  file_structure_changed_signal.make_slot(),                  file_structure_changed_signal.make_slot(),
1527    #if SIGCXX_MAJOR_VERSION > 2 || (SIGCXX_MAJOR_VERSION == 2 && SIGCXX_MINOR_VERSION >= 8)
1528                    std::ref(this->file)
1529    #else
1530                  sigc::ref(this->file)                  sigc::ref(this->file)
1531    #endif
1532              )              )
1533          )          )
1534      );      );
# Line 581  MainWindow::MainWindow() : Line 1549  MainWindow::MainWindow() :
1549      dimreg_stereo.signal_toggled().connect(      dimreg_stereo.signal_toggled().connect(
1550          sigc::mem_fun(*this, &MainWindow::update_dimregs));          sigc::mem_fun(*this, &MainWindow::update_dimregs));
1551    
1552        m_searchText.signal_changed().connect(
1553            sigc::mem_fun(*m_refTreeModelFilter.operator->(), &Gtk::TreeModelFilter::refilter)
1554        );
1555    
1556      file = 0;      file = 0;
1557      file_is_changed = false;      file_is_changed = false;
1558    
1559    #if HAS_GTKMM_SHOW_ALL_CHILDREN
1560      show_all_children();      show_all_children();
1561    #endif
1562    
1563      // start with a new gig file by default      // start with a new gig file by default
1564      on_action_file_new();      on_action_file_new();
1565    
1566        m_TreeViewNotebook.signal_switch_page().connect(
1567            sigc::mem_fun(*this, &MainWindow::on_notebook_tab_switched)
1568        );
1569    
1570      // select 'Instruments' tab by default      // select 'Instruments' tab by default
1571      // (gtk allows this only if the tab childs are visible, thats why it's here)      // (gtk allows this only if the tab childs are visible, thats why it's here)
1572      m_TreeViewNotebook.set_current_page(1);      m_TreeViewNotebook.set_current_page(1);
1573    
1574        Gtk::Clipboard::get()->signal_owner_change().connect(
1575            sigc::mem_fun(*this, &MainWindow::on_clipboard_owner_change)
1576        );
1577        updateClipboardPasteAvailable();
1578        updateClipboardCopyAvailable();
1579    
1580        // setup macros and their keyboard accelerators
1581        {
1582    #if USE_GTKMM_BUILDER
1583            menuMacro = new Gtk::Menu(
1584                Glib::RefPtr<Gio::Menu>::cast_dynamic(
1585                    m_uiManager->get_object("MenuMacro")
1586                )
1587            );
1588    #else
1589            Gtk::Menu* menuMacro = dynamic_cast<Gtk::MenuItem*>(
1590                uiManager->get_widget("/MenuBar/MenuMacro")
1591            )->get_submenu();
1592    #endif
1593    
1594            const Gdk::ModifierType noModifier = (Gdk::ModifierType)0;
1595            Gtk::AccelMap::add_entry("<Macros>/macro_0", GDK_KEY_F1, noModifier);
1596            Gtk::AccelMap::add_entry("<Macros>/macro_1", GDK_KEY_F2, noModifier);
1597            Gtk::AccelMap::add_entry("<Macros>/macro_2", GDK_KEY_F3, noModifier);
1598            Gtk::AccelMap::add_entry("<Macros>/macro_3", GDK_KEY_F4, noModifier);
1599            Gtk::AccelMap::add_entry("<Macros>/macro_4", GDK_KEY_F5, noModifier);
1600            Gtk::AccelMap::add_entry("<Macros>/macro_5", GDK_KEY_F6, noModifier);
1601            Gtk::AccelMap::add_entry("<Macros>/macro_6", GDK_KEY_F7, noModifier);
1602            Gtk::AccelMap::add_entry("<Macros>/macro_7", GDK_KEY_F8, noModifier);
1603            Gtk::AccelMap::add_entry("<Macros>/macro_8", GDK_KEY_F9, noModifier);
1604            Gtk::AccelMap::add_entry("<Macros>/macro_9", GDK_KEY_F10, noModifier);
1605            Gtk::AccelMap::add_entry("<Macros>/macro_10", GDK_KEY_F11, noModifier);
1606            Gtk::AccelMap::add_entry("<Macros>/macro_11", GDK_KEY_F12, noModifier);
1607            Gtk::AccelMap::add_entry("<Macros>/macro_12", GDK_KEY_F13, noModifier);
1608            Gtk::AccelMap::add_entry("<Macros>/macro_13", GDK_KEY_F14, noModifier);
1609            Gtk::AccelMap::add_entry("<Macros>/macro_14", GDK_KEY_F15, noModifier);
1610            Gtk::AccelMap::add_entry("<Macros>/macro_15", GDK_KEY_F16, noModifier);
1611            Gtk::AccelMap::add_entry("<Macros>/macro_16", GDK_KEY_F17, noModifier);
1612            Gtk::AccelMap::add_entry("<Macros>/macro_17", GDK_KEY_F18, noModifier);
1613            Gtk::AccelMap::add_entry("<Macros>/macro_18", GDK_KEY_F19, noModifier);
1614            Gtk::AccelMap::add_entry("<Macros>/SetupMacros", 'm', primaryModifierKey);
1615    
1616            Glib::RefPtr<Gtk::AccelGroup> accelGroup = this->get_accel_group();
1617            menuMacro->set_accel_group(accelGroup);
1618    
1619            updateMacroMenu();
1620        }
1621    
1622        // setup "Assign Scripts" keyboard accelerators
1623        {
1624            Gtk::AccelMap::add_entry("<Scripts>/script_0", GDK_KEY_F1, Gdk::SHIFT_MASK);
1625            Gtk::AccelMap::add_entry("<Scripts>/script_1", GDK_KEY_F2, Gdk::SHIFT_MASK);
1626            Gtk::AccelMap::add_entry("<Scripts>/script_2", GDK_KEY_F3, Gdk::SHIFT_MASK);
1627            Gtk::AccelMap::add_entry("<Scripts>/script_3", GDK_KEY_F4, Gdk::SHIFT_MASK);
1628            Gtk::AccelMap::add_entry("<Scripts>/script_4", GDK_KEY_F5, Gdk::SHIFT_MASK);
1629            Gtk::AccelMap::add_entry("<Scripts>/script_5", GDK_KEY_F6, Gdk::SHIFT_MASK);
1630            Gtk::AccelMap::add_entry("<Scripts>/script_6", GDK_KEY_F7, Gdk::SHIFT_MASK);
1631            Gtk::AccelMap::add_entry("<Scripts>/script_7", GDK_KEY_F8, Gdk::SHIFT_MASK);
1632            Gtk::AccelMap::add_entry("<Scripts>/script_8", GDK_KEY_F9, Gdk::SHIFT_MASK);
1633            Gtk::AccelMap::add_entry("<Scripts>/script_9", GDK_KEY_F10, Gdk::SHIFT_MASK);
1634            Gtk::AccelMap::add_entry("<Scripts>/script_10", GDK_KEY_F11, Gdk::SHIFT_MASK);
1635            Gtk::AccelMap::add_entry("<Scripts>/script_11", GDK_KEY_F12, Gdk::SHIFT_MASK);
1636            Gtk::AccelMap::add_entry("<Scripts>/script_12", GDK_KEY_F13, Gdk::SHIFT_MASK);
1637            Gtk::AccelMap::add_entry("<Scripts>/script_13", GDK_KEY_F14, Gdk::SHIFT_MASK);
1638            Gtk::AccelMap::add_entry("<Scripts>/script_14", GDK_KEY_F15, Gdk::SHIFT_MASK);
1639            Gtk::AccelMap::add_entry("<Scripts>/script_15", GDK_KEY_F16, Gdk::SHIFT_MASK);
1640            Gtk::AccelMap::add_entry("<Scripts>/script_16", GDK_KEY_F17, Gdk::SHIFT_MASK);
1641            Gtk::AccelMap::add_entry("<Scripts>/script_17", GDK_KEY_F18, Gdk::SHIFT_MASK);
1642            Gtk::AccelMap::add_entry("<Scripts>/script_18", GDK_KEY_F19, Gdk::SHIFT_MASK);
1643            Gtk::AccelMap::add_entry("<Scripts>/DropAllScriptSlots", GDK_KEY_BackSpace, Gdk::SHIFT_MASK);
1644    
1645            Glib::RefPtr<Gtk::AccelGroup> accelGroup = this->get_accel_group();
1646            assign_scripts_menu->set_accel_group(accelGroup);
1647        }
1648    
1649        on_show_tooltips_changed();
1650    
1651        Glib::signal_idle().connect_once(
1652            sigc::mem_fun(*this, &MainWindow::bringToFront),
1653            200
1654        );
1655  }  }
1656    
1657  MainWindow::~MainWindow()  MainWindow::~MainWindow()
1658  {  {
1659  }  }
1660    
1661    void MainWindow::bringToFront() {
1662        #if defined(__APPLE__)
1663        macRaiseAppWindow();
1664        #endif
1665        raise();
1666        present();
1667    }
1668    
1669    void MainWindow::updateMacroMenu() {
1670    #if !USE_GTKMM_BUILDER
1671        Gtk::Menu* menuMacro = dynamic_cast<Gtk::MenuItem*>(
1672            uiManager->get_widget("/MenuBar/MenuMacro")
1673        )->get_submenu();
1674    #endif
1675    
1676        // remove all entries from "Macro" menu
1677        {
1678            const std::vector<Gtk::Widget*> children = menuMacro->get_children();
1679            for (int i = 0; i < children.size(); ++i) {
1680                Gtk::Widget* child = children[i];
1681                menuMacro->remove(*child);
1682                delete child;
1683            }
1684        }
1685    
1686        // (re)load all macros from config file
1687        try {
1688            Settings::singleton()->loadMacros(m_macros);
1689        } catch (Serialization::Exception e) {
1690            std::cerr << "Exception while loading macros: " << e.Message << std::endl;
1691        } catch (...) {
1692            std::cerr << "Unknown exception while loading macros!" << std::endl;
1693        }
1694    
1695        // add all configured macros as menu items to the "Macro" menu
1696        for (int iMacro = 0; iMacro < m_macros.size(); ++iMacro) {
1697            const Serialization::Archive& macro = m_macros[iMacro];
1698            std::string name =
1699                macro.name().empty() ?
1700                    (std::string(_("Unnamed Macro")) + " " + ToString(iMacro+1)) : macro.name();
1701            Gtk::MenuItem* item = new Gtk::MenuItem(name);
1702            item->signal_activate().connect(
1703                sigc::bind(
1704                    sigc::mem_fun(*this, &MainWindow::onMacroSelected), iMacro
1705                )
1706            );
1707            menuMacro->append(*item);
1708            item->set_accel_path("<Macros>/macro_" + ToString(iMacro));
1709            Glib::ustring comment = macro.comment();
1710            if (!comment.empty())
1711                item->set_tooltip_text(comment);
1712        }
1713        // if there are no macros configured at all, then show a dummy entry instead
1714        if (m_macros.empty()) {
1715            Gtk::MenuItem* item = new Gtk::MenuItem(_("No Macros"));
1716            item->set_sensitive(false);
1717            menuMacro->append(*item);
1718        }
1719    
1720        // add separator line to menu
1721        menuMacro->append(*new Gtk::SeparatorMenuItem);
1722    
1723        {
1724            Gtk::MenuItem* item = new Gtk::MenuItem(_("Setup Macros ..."));
1725            item->signal_activate().connect(
1726                sigc::mem_fun(*this, &MainWindow::setupMacros)
1727            );
1728            menuMacro->append(*item);
1729            item->set_accel_path("<Macros>/SetupMacros");
1730        }
1731    
1732    #if HAS_GTKMM_SHOW_ALL_CHILDREN
1733        menuMacro->show_all_children();
1734    #endif
1735    }
1736    
1737    void MainWindow::onMacroSelected(int iMacro) {
1738        printf("onMacroSelected(%d)\n", iMacro);
1739        if (iMacro < 0 || iMacro >= m_macros.size()) return;
1740        Glib::ustring errorText;
1741        try {
1742            applyMacro(m_macros[iMacro]);
1743        } catch (Serialization::Exception e) {
1744            errorText = e.Message;
1745        } catch (...) {
1746            errorText = _("Unknown exception while applying macro");
1747        }
1748        if (!errorText.empty()) {
1749            Glib::ustring txt = _("Applying macro failed:\n") + errorText;
1750            Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
1751            msg.run();
1752        }
1753    }
1754    
1755    void MainWindow::setupMacros() {
1756        MacrosSetup* setup = new MacrosSetup();
1757        gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
1758        setup->setMacros(m_macros, &m_serializationArchive, pDimRgn);
1759        setup->signal_macros_changed().connect(
1760            sigc::mem_fun(*this, &MainWindow::onMacrosSetupChanged)
1761        );
1762        setup->show();
1763    }
1764    
1765    void MainWindow::onMacrosSetupChanged(const std::vector<Serialization::Archive>& macros) {
1766        m_macros = macros;
1767        Settings::singleton()->saveMacros(m_macros);
1768        updateMacroMenu();
1769    }
1770    
1771    //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.
1772    void MainWindow::on_notebook_tab_switched(void* page, guint page_num) {
1773        bool isInstrumentsPage = (page_num == 1);
1774        // so far we only support filtering for the instruments list, so hide the
1775        // filter text entry field if another tab is selected
1776        m_searchField.set_visible(isInstrumentsPage);
1777    }
1778    
1779  bool MainWindow::on_delete_event(GdkEventAny* event)  bool MainWindow::on_delete_event(GdkEventAny* event)
1780  {  {
1781      return !file_is_shared && file_is_changed && !close_confirmation_dialog();      return !file_is_shared && file_is_changed && !close_confirmation_dialog();
# Line 617  void MainWindow::region_changed() Line 1795  void MainWindow::region_changed()
1795  gig::Instrument* MainWindow::get_instrument()  gig::Instrument* MainWindow::get_instrument()
1796  {  {
1797      gig::Instrument* instrument = 0;      gig::Instrument* instrument = 0;
1798      Gtk::TreeModel::const_iterator it =      std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
1799          m_TreeView.get_selection()->get_selected();      if (rows.empty()) return NULL;
1800        //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
1801        Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
1802      if (it) {      if (it) {
1803          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
1804          instrument = row[m_Columns.m_col_instr];          instrument = row[m_Columns.m_col_instr];
# Line 661  void MainWindow::update_dimregs() Line 1841  void MainWindow::update_dimregs()
1841              add_region_to_dimregs(region, stereo, all_dimregs);              add_region_to_dimregs(region, stereo, all_dimregs);
1842          }          }
1843      }      }
1844    
1845        m_RegionChooser.setModifyAllRegions(all_regions);
1846        m_DimRegionChooser.setModifyAllRegions(all_regions);
1847        m_DimRegionChooser.setModifyAllDimensionRegions(all_dimregs);
1848        m_DimRegionChooser.setModifyBothChannels(stereo);
1849    
1850        updateClipboardCopyAvailable();
1851  }  }
1852    
1853  void MainWindow::dimreg_all_dimregs_toggled()  void MainWindow::dimreg_all_dimregs_toggled()
# Line 677  void MainWindow::dimreg_changed() Line 1864  void MainWindow::dimreg_changed()
1864    
1865  void MainWindow::on_sel_change()  void MainWindow::on_sel_change()
1866  {  {
1867    #if !USE_GTKMM_BUILDER
1868      // select item in instrument menu      // select item in instrument menu
1869      Gtk::TreeModel::iterator it = m_TreeView.get_selection()->get_selected();      std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
1870      if (it) {      if (!rows.empty()) {
1871          Gtk::TreePath path(it);          Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
1872          int index = path[0];          if (it) {
1873          const std::vector<Gtk::Widget*> children =              Gtk::TreePath path(it);
1874              instrument_menu->get_children();              int index = path[0];
1875          static_cast<Gtk::RadioMenuItem*>(children[index])->set_active();              const std::vector<Gtk::Widget*> children =
1876                    instrument_menu->get_children();
1877                static_cast<Gtk::RadioMenuItem*>(children[index])->set_active();
1878            }
1879      }      }
1880    #endif
1881    
1882        updateScriptListOfMenu();
1883    
1884      m_RegionChooser.set_instrument(get_instrument());      m_RegionChooser.set_instrument(get_instrument());
1885    
1886        if (Settings::singleton()->syncSamplerInstrumentSelection) {
1887            switch_sampler_instrument_signal.emit(get_instrument());
1888        }
1889    }
1890    
1891    
1892    LoaderSaverBase::LoaderSaverBase(const Glib::ustring filename, gig::File* gig) :
1893        filename(filename), gig(gig),
1894    #ifdef GLIB_THREADS
1895        thread(0),
1896    #endif
1897        progress(0.f)
1898    {
1899  }  }
1900    
1901  void loader_progress_callback(gig::progress_t* progress)  void loader_progress_callback(gig::progress_t* progress)
1902  {  {
1903      Loader* loader = static_cast<Loader*>(progress->custom);      LoaderSaverBase* loader = static_cast<LoaderSaverBase*>(progress->custom);
1904      loader->progress_callback(progress->factor);      loader->progress_callback(progress->factor);
1905  }  }
1906    
1907  void Loader::progress_callback(float fraction)  void LoaderSaverBase::progress_callback(float fraction)
1908  {  {
1909      {      {
1910    #ifdef GLIB_THREADS
1911          Glib::Threads::Mutex::Lock lock(progressMutex);          Glib::Threads::Mutex::Lock lock(progressMutex);
1912    #else
1913            std::lock_guard<std::mutex> lock(progressMutex);
1914    #endif
1915          progress = fraction;          progress = fraction;
1916      }      }
1917      progress_dispatcher();      progress_dispatcher();
1918  }  }
1919    
1920  void Loader::thread_function()  #if defined(WIN32) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
1921    // make sure stack is 16-byte aligned for SSE instructions
1922    __attribute__((force_align_arg_pointer))
1923    #endif
1924    void LoaderSaverBase::thread_function()
1925  {  {
1926      printf("thread_function self=%x\n", Glib::Threads::Thread::self());  #ifdef GLIB_THREADS
1927      printf("Start %s\n", filename);      printf("thread_function self=%p\n",
1928      RIFF::File* riff = new RIFF::File(filename);             static_cast<void*>(Glib::Threads::Thread::self()));
1929      gig = new gig::File(riff);  #else
1930      gig::progress_t progress;      std::cout << "thread_function self=" << std::this_thread::get_id() << "\n";
1931      progress.callback = loader_progress_callback;  #endif
1932      progress.custom = this;      printf("Start %s\n", filename.c_str());
1933        try {
1934            gig::progress_t progress;
1935            progress.callback = loader_progress_callback;
1936            progress.custom = this;
1937    
1938            thread_function_sub(progress);
1939            printf("End\n");
1940            finished_dispatcher();
1941        } catch (RIFF::Exception e) {
1942            error_message = e.Message;
1943            error_dispatcher.emit();
1944        } catch (...) {
1945            error_message = _("Unknown exception occurred");
1946            error_dispatcher.emit();
1947        }
1948    }
1949    
1950      gig->GetInstrument(0, &progress);  void LoaderSaverBase::launch()
1951      printf("End\n");  {
1952      finished_dispatcher();  #ifdef GLIB_THREADS
1953    #ifdef OLD_THREADS
1954        thread = Glib::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function), true);
1955    #else
1956        thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &LoaderSaverBase::thread_function));
1957    #endif
1958        printf("launch thread=%p\n", static_cast<void*>(thread));
1959    #else
1960        thread = std::thread([this](){ thread_function(); });
1961        std::cout << "launch thread=" << thread.get_id() << "\n";
1962    #endif
1963  }  }
1964    
1965  Loader::Loader(const char* filename)  float LoaderSaverBase::get_progress()
     : filename(filename), thread(0)  
1966  {  {
1967    #ifdef GLIB_THREADS
1968        Glib::Threads::Mutex::Lock lock(progressMutex);
1969    #else
1970        std::lock_guard<std::mutex> lock(progressMutex);
1971    #endif
1972        return progress;
1973  }  }
1974    
1975  void Loader::launch()  Glib::Dispatcher& LoaderSaverBase::signal_progress()
1976  {  {
1977  #ifdef OLD_THREADS      return progress_dispatcher;
1978      thread = Glib::Thread::create(sigc::mem_fun(*this, &Loader::thread_function), true);  }
1979    
1980    Glib::Dispatcher& LoaderSaverBase::signal_finished()
1981    {
1982        return finished_dispatcher;
1983    }
1984    
1985    Glib::Dispatcher& LoaderSaverBase::signal_error()
1986    {
1987        return error_dispatcher;
1988    }
1989    
1990    void LoaderSaverBase::join() {
1991    #ifdef GLIB_THREADS
1992        thread->join();
1993  #else  #else
1994      thread = Glib::Threads::Thread::create(sigc::mem_fun(*this, &Loader::thread_function));      thread.join();
1995  #endif  #endif
     printf("launch thread=%x\n", thread);  
1996  }  }
1997    
1998  float Loader::get_progress()  
1999    Loader::Loader(const char* filename) :
2000        LoaderSaverBase(filename, 0)
2001  {  {
     float res;  
     {  
         Glib::Threads::Mutex::Lock lock(progressMutex);  
         res = progress;  
     }  
     return res;  
2002  }  }
2003    
2004  Glib::Dispatcher& Loader::signal_progress()  void Loader::thread_function_sub(gig::progress_t& progress)
2005  {  {
2006      return progress_dispatcher;      RIFF::File* riff = new RIFF::File(filename);
2007        gig = new gig::File(riff);
2008    
2009        gig->GetInstrument(0, &progress);
2010  }  }
2011    
2012  Glib::Dispatcher& Loader::signal_finished()  
2013    Saver::Saver(gig::File* file, Glib::ustring filename) :
2014        LoaderSaverBase(filename, file)
2015  {  {
     return finished_dispatcher;  
2016  }  }
2017    
2018  LoadDialog::LoadDialog(const Glib::ustring& title, Gtk::Window& parent)  void Saver::thread_function_sub(gig::progress_t& progress)
2019    {
2020        // if no filename was provided, that means "save", if filename was provided means "save as"
2021        if (filename.empty()) {
2022            if (!Settings::singleton()->saveWithTemporaryFile) {
2023                // save directly over the existing .gig file
2024                // (requires less disk space than solution below
2025                // but may be slower)
2026                gig->Save(&progress);
2027            } else {
2028                // save the file as separate temporary file first,
2029                // then move the saved file over the old file
2030                // (may result in performance speedup during save)
2031                gig::String tmpname = filename + ".TMP";
2032                gig->Save(tmpname, &progress);
2033    #if defined(WIN32)
2034                if (!DeleteFile(filename.c_str())) {
2035                    throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file).");
2036                }
2037    #else // POSIX ...
2038                if (unlink(filename.c_str())) {
2039                    throw RIFF::Exception("Could not replace original file with temporary file (unable to remove original file): " + gig::String(strerror(errno)));
2040                }
2041    #endif
2042                if (rename(tmpname.c_str(), filename.c_str())) {
2043    #if defined(WIN32)
2044                    throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file).");
2045    #else
2046                    throw RIFF::Exception("Could not replace original file with temporary file (unable to rename temp file): " + gig::String(strerror(errno)));
2047    #endif
2048                }
2049            }
2050        } else {
2051            gig->Save(filename, &progress);
2052        }
2053    }
2054    
2055    
2056    ProgressDialog::ProgressDialog(const Glib::ustring& title, Gtk::Window& parent)
2057      : Gtk::Dialog(title, parent, true)      : Gtk::Dialog(title, parent, true)
2058  {  {
2059    #if USE_GTKMM_BOX
2060        get_content_area()->pack_start(progressBar);
2061    #else
2062      get_vbox()->pack_start(progressBar);      get_vbox()->pack_start(progressBar);
2063    #endif
2064    #if HAS_GTKMM_SHOW_ALL_CHILDREN
2065      show_all_children();      show_all_children();
2066    #endif
2067        resize(600,50);
2068  }  }
2069    
2070  // Clear all GUI elements / controls. This method is typically called  // Clear all GUI elements / controls. This method is typically called
# Line 771  void MainWindow::__clear() { Line 2076  void MainWindow::__clear() {
2076      m_refTreeModel->clear();      m_refTreeModel->clear();
2077      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
2078      m_refScriptsTreeModel->clear();      m_refScriptsTreeModel->clear();
2079    #if !USE_GTKMM_BUILDER
2080      // remove all entries from "Instrument" menu      // remove all entries from "Instrument" menu
2081      while (!instrument_menu->get_children().empty()) {      while (!instrument_menu->get_children().empty()) {
2082          remove_instrument_from_menu(0);          remove_instrument_from_menu(0);
2083      }      }
2084    #endif
2085      // free libgig's gig::File instance      // free libgig's gig::File instance
2086      if (file && !file_is_shared) delete file;      if (file && !file_is_shared) delete file;
2087      file = NULL;      file = NULL;
# Line 786  void MainWindow::__refreshEntireGUI() { Line 2093  void MainWindow::__refreshEntireGUI() {
2093      m_refTreeModel->clear();      m_refTreeModel->clear();
2094      m_refSamplesTreeModel->clear();      m_refSamplesTreeModel->clear();
2095      m_refScriptsTreeModel->clear();      m_refScriptsTreeModel->clear();
2096    #if !USE_GTKMM_BUILDER
2097      // remove all entries from "Instrument" menu      // remove all entries from "Instrument" menu
2098      while (!instrument_menu->get_children().empty()) {      while (!instrument_menu->get_children().empty()) {
2099          remove_instrument_from_menu(0);          remove_instrument_from_menu(0);
2100      }      }
2101    #endif
2102    
2103      if (!this->file) return;      if (!this->file) return;
2104    
# Line 823  bool MainWindow::close_confirmation_dial Line 2132  bool MainWindow::close_confirmation_dial
2132      g_free(msg);      g_free(msg);
2133      dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));      dialog.set_secondary_text(_("If you close without saving, your changes will be lost."));
2134      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);      dialog.add_button(_("Close _Without Saving"), Gtk::RESPONSE_NO);
2135    #if HAS_GTKMM_STOCK
2136      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2137      dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);      dialog.add_button(file_has_name ? Gtk::Stock::SAVE : Gtk::Stock::SAVE_AS, Gtk::RESPONSE_YES);
2138    #else
2139        dialog.add_button(_("_OK"), Gtk::RESPONSE_OK);
2140        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2141    #endif
2142      dialog.set_default_response(Gtk::RESPONSE_YES);      dialog.set_default_response(Gtk::RESPONSE_YES);
2143      int response = dialog.run();      int response = dialog.run();
2144      dialog.hide();      dialog.hide();
2145      if (response == Gtk::RESPONSE_YES) return file_save();  
2146      return response != Gtk::RESPONSE_CANCEL;      // user decided to exit app without saving
2147        if (response == Gtk::RESPONSE_NO) return true;
2148    
2149        // user cancelled dialog, thus don't close app
2150        if (response == Gtk::RESPONSE_CANCEL) return false;
2151    
2152        // TODO: the following return valid is disabled and hard coded instead for
2153        // now, due to the fact that saving with progress bar is now implemented
2154        // asynchronously, as a result the app does not close automatically anymore
2155        // after saving the file has completed
2156        //
2157        //   if (response == Gtk::RESPONSE_YES) return file_save();
2158        //   return response != Gtk::RESPONSE_CANCEL;
2159        //
2160        if (response == Gtk::RESPONSE_YES) file_save();
2161        return false; // always prevent closing the app for now (see comment above)
2162  }  }
2163    
2164  bool MainWindow::leaving_shared_mode_dialog() {  bool MainWindow::leaving_shared_mode_dialog() {
# Line 840  bool MainWindow::leaving_shared_mode_dia Line 2169  bool MainWindow::leaving_shared_mode_dia
2169            "used by the sampler until you tell the sampler explicitly to "            "used by the sampler until you tell the sampler explicitly to "
2170            "load it."));            "load it."));
2171      dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);      dialog.add_button(_("_Yes, Detach"), Gtk::RESPONSE_YES);
2172    #if HAS_GTKMM_STOCK
2173      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2174    #else
2175        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2176    #endif
2177      dialog.set_default_response(Gtk::RESPONSE_CANCEL);      dialog.set_default_response(Gtk::RESPONSE_CANCEL);
2178      int response = dialog.run();      int response = dialog.run();
2179      dialog.hide();      dialog.hide();
# Line 854  void MainWindow::on_action_file_open() Line 2187  void MainWindow::on_action_file_open()
2187      if (file_is_shared && !leaving_shared_mode_dialog()) return;      if (file_is_shared && !leaving_shared_mode_dialog()) return;
2188    
2189      Gtk::FileChooserDialog dialog(*this, _("Open file"));      Gtk::FileChooserDialog dialog(*this, _("Open file"));
2190    #if HAS_GTKMM_STOCK
2191      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2192      dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);      dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
2193    #else
2194        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2195        dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
2196    #endif
2197      dialog.set_default_response(Gtk::RESPONSE_OK);      dialog.set_default_response(Gtk::RESPONSE_OK);
2198  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
2199      Gtk::FileFilter filter;      Gtk::FileFilter filter;
# Line 869  void MainWindow::on_action_file_open() Line 2207  void MainWindow::on_action_file_open()
2207          dialog.set_current_folder(current_gig_dir);          dialog.set_current_folder(current_gig_dir);
2208      }      }
2209      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
2210            dialog.hide();
2211          std::string filename = dialog.get_filename();          std::string filename = dialog.get_filename();
2212          printf("filename=%s\n", filename.c_str());          printf("filename=%s\n", filename.c_str());
2213          printf("on_action_file_open self=%x\n", Glib::Threads::Thread::self());  #ifdef GLIB_THREADS
2214            printf("on_action_file_open self=%p\n",
2215                   static_cast<void*>(Glib::Threads::Thread::self()));
2216    #else
2217            std::cout << "on_action_file_open self=" <<
2218                std::this_thread::get_id() << "\n";
2219    #endif
2220          load_file(filename.c_str());          load_file(filename.c_str());
2221          current_gig_dir = Glib::path_get_dirname(filename);          current_gig_dir = Glib::path_get_dirname(filename);
2222      }      }
# Line 880  void MainWindow::on_action_file_open() Line 2225  void MainWindow::on_action_file_open()
2225  void MainWindow::load_file(const char* name)  void MainWindow::load_file(const char* name)
2226  {  {
2227      __clear();      __clear();
2228      load_dialog = new LoadDialog(_("Loading..."), *this);  
2229      load_dialog->show_all();      progress_dialog = new ProgressDialog( //FIXME: memory leak!
2230      loader = new Loader(strdup(name));          _("Loading") +  Glib::ustring(" '") +
2231            Glib::filename_display_basename(name) + "' ...",
2232            *this
2233        );
2234    #if HAS_GTKMM_SHOW_ALL_CHILDREN
2235        progress_dialog->show_all();
2236    #endif
2237        loader = new Loader(name); //FIXME: memory leak!
2238      loader->signal_progress().connect(      loader->signal_progress().connect(
2239          sigc::mem_fun(*this, &MainWindow::on_loader_progress));          sigc::mem_fun(*this, &MainWindow::on_loader_progress));
2240      loader->signal_finished().connect(      loader->signal_finished().connect(
2241          sigc::mem_fun(*this, &MainWindow::on_loader_finished));          sigc::mem_fun(*this, &MainWindow::on_loader_finished));
2242        loader->signal_error().connect(
2243            sigc::mem_fun(*this, &MainWindow::on_loader_error));
2244      loader->launch();      loader->launch();
2245  }  }
2246    
# Line 913  void MainWindow::load_instrument(gig::In Line 2267  void MainWindow::load_instrument(gig::In
2267              // make sure the selected item in the "instruments" tree view is              // make sure the selected item in the "instruments" tree view is
2268              // visible (scroll to it)              // visible (scroll to it)
2269              m_TreeView.scroll_to_row(Gtk::TreePath(ToString(i)));              m_TreeView.scroll_to_row(Gtk::TreePath(ToString(i)));
2270    #if !USE_GTKMM_BUILDER
2271              // select item in instrument menu              // select item in instrument menu
2272              {              {
2273                  const std::vector<Gtk::Widget*> children =                  const std::vector<Gtk::Widget*> children =
2274                      instrument_menu->get_children();                      instrument_menu->get_children();
2275                  static_cast<Gtk::RadioMenuItem*>(children[i])->set_active();                  static_cast<Gtk::RadioMenuItem*>(children[i])->set_active();
2276              }              }
2277    #endif
2278              // update region chooser and dimension region chooser              // update region chooser and dimension region chooser
2279              m_RegionChooser.set_instrument(instr);              m_RegionChooser.set_instrument(instr);
2280              break;              break;
# Line 928  void MainWindow::load_instrument(gig::In Line 2284  void MainWindow::load_instrument(gig::In
2284    
2285  void MainWindow::on_loader_progress()  void MainWindow::on_loader_progress()
2286  {  {
2287      load_dialog->set_fraction(loader->get_progress());      progress_dialog->set_fraction(loader->get_progress());
2288  }  }
2289    
2290  void MainWindow::on_loader_finished()  void MainWindow::on_loader_finished()
2291  {  {
2292        loader->join();
2293      printf("Loader finished!\n");      printf("Loader finished!\n");
2294      printf("on_loader_finished self=%x\n", Glib::Threads::Thread::self());  #ifdef GLIB_THREADS
2295      load_gig(loader->gig, loader->filename);      printf("on_loader_finished self=%p\n",
2296      load_dialog->hide();             static_cast<void*>(Glib::Threads::Thread::self()));
2297    #else
2298        std::cout << "on_loader_finished self=" <<
2299            std::this_thread::get_id() << "\n";
2300    #endif
2301        load_gig(loader->gig, loader->filename.c_str());
2302        progress_dialog->hide();
2303    }
2304    
2305    void MainWindow::on_loader_error()
2306    {
2307        loader->join();
2308        Glib::ustring txt = _("Could not load file: ") + loader->error_message;
2309        Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2310        msg.run();
2311        progress_dialog->hide();
2312  }  }
2313    
2314  void MainWindow::on_action_file_save()  void MainWindow::on_action_file_save()
# Line 975  bool MainWindow::file_save() Line 2347  bool MainWindow::file_save()
2347    
2348      std::cout << "Saving file\n" << std::flush;      std::cout << "Saving file\n" << std::flush;
2349      file_structure_to_be_changed_signal.emit(this->file);      file_structure_to_be_changed_signal.emit(this->file);
2350      try {  
2351          file->Save();      progress_dialog = new ProgressDialog( //FIXME: memory leak!
2352          if (file_is_changed) {          _("Saving") +  Glib::ustring(" '") +
2353              set_title(get_title().substr(1));          Glib::filename_display_basename(this->filename) + "' ...",
2354              file_is_changed = false;          *this
2355          }      );
2356      } catch (RIFF::Exception e) {  #if HAS_GTKMM_SHOW_ALL_CHILDREN
2357          file_structure_changed_signal.emit(this->file);      progress_dialog->show_all();
2358          Glib::ustring txt = _("Could not save file: ") + e.Message;  #endif
2359          Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);      saver = new Saver(this->file); //FIXME: memory leak!
2360          msg.run();      saver->signal_progress().connect(
2361          return false;          sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2362      }      saver->signal_finished().connect(
2363      std::cout << "Saving file done\n" << std::flush;          sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2364        saver->signal_error().connect(
2365            sigc::mem_fun(*this, &MainWindow::on_saver_error));
2366        saver->launch();
2367    
2368        return true;
2369    }
2370    
2371    void MainWindow::on_saver_progress()
2372    {
2373        progress_dialog->set_fraction(saver->get_progress());
2374    }
2375    
2376    void MainWindow::on_saver_error()
2377    {
2378        saver->join();
2379        file_structure_changed_signal.emit(this->file);
2380        Glib::ustring txt = _("Could not save file: ") + saver->error_message;
2381        Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
2382        msg.run();
2383    }
2384    
2385    void MainWindow::on_saver_finished()
2386    {
2387        saver->join();
2388        this->file = saver->gig;
2389        this->filename = saver->filename;
2390        current_gig_dir = Glib::path_get_dirname(filename);
2391        set_title(Glib::filename_display_basename(filename));
2392        file_has_name = true;
2393        file_is_changed = false;
2394        std::cout << "Saving file done. Importing queued samples now ...\n" << std::flush;
2395      __import_queued_samples();      __import_queued_samples();
2396        std::cout << "Importing queued samples done.\n" << std::flush;
2397    
2398      file_structure_changed_signal.emit(this->file);      file_structure_changed_signal.emit(this->file);
2399      return true;  
2400        __refreshEntireGUI();
2401        progress_dialog->hide();
2402  }  }
2403    
2404  void MainWindow::on_action_file_save_as()  void MainWindow::on_action_file_save_as()
# Line 1003  void MainWindow::on_action_file_save_as( Line 2410  void MainWindow::on_action_file_save_as(
2410  bool MainWindow::file_save_as()  bool MainWindow::file_save_as()
2411  {  {
2412      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);      Gtk::FileChooserDialog dialog(*this, _("Save as"), Gtk::FILE_CHOOSER_ACTION_SAVE);
2413    #if HAS_GTKMM_STOCK
2414      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
2415      dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);      dialog.add_button(Gtk::Stock::SAVE, Gtk::RESPONSE_OK);
2416    #else
2417        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
2418        dialog.add_button(_("_Save"), Gtk::RESPONSE_OK);
2419    #endif
2420      dialog.set_default_response(Gtk::RESPONSE_OK);      dialog.set_default_response(Gtk::RESPONSE_OK);
2421      dialog.set_do_overwrite_confirmation();      dialog.set_do_overwrite_confirmation();
2422    
# Line 1033  bool MainWindow::file_save_as() Line 2445  bool MainWindow::file_save_as()
2445      }      }
2446    
2447      // show warning in the dialog      // show warning in the dialog
2448      Gtk::HBox descriptionArea;      HBox descriptionArea;
2449      descriptionArea.set_spacing(15);      descriptionArea.set_spacing(15);
2450      Gtk::Image warningIcon(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));      Gtk::Image warningIcon;
2451        warningIcon.set_from_icon_name("dialog-warning",
2452                                       Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
2453      descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);      descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
2454  #if GTKMM_MAJOR_VERSION < 3  #if GTKMM_MAJOR_VERSION < 3
2455      view::WrapLabel description;      view::WrapLabel description;
# Line 1052  bool MainWindow::file_save_as() Line 2466  bool MainWindow::file_save_as()
2466            "same .gig file will end up in corrupted sample wave data!\n")            "same .gig file will end up in corrupted sample wave data!\n")
2467      );      );
2468      descriptionArea.pack_start(description);      descriptionArea.pack_start(description);
2469    #if USE_GTKMM_BOX
2470        dialog.get_content_area()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2471    #else
2472      dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);      dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
2473    #endif
2474    #if HAS_GTKMM_SHOW_ALL_CHILDREN
2475      descriptionArea.show_all();      descriptionArea.show_all();
2476    #endif
2477    
2478      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
2479          file_structure_to_be_changed_signal.emit(this->file);          dialog.hide();
2480          try {          std::string filename = dialog.get_filename();
2481              std::string filename = dialog.get_filename();          if (!Glib::str_has_suffix(filename, ".gig")) {
2482              if (!Glib::str_has_suffix(filename, ".gig")) {              filename += ".gig";
                 filename += ".gig";  
             }  
             printf("filename=%s\n", filename.c_str());  
             file->Save(filename);  
             this->filename = filename;  
             current_gig_dir = Glib::path_get_dirname(filename);  
             set_title(Glib::filename_display_basename(filename));  
             file_has_name = true;  
             file_is_changed = false;  
         } catch (RIFF::Exception e) {  
             file_structure_changed_signal.emit(this->file);  
             Glib::ustring txt = _("Could not save file: ") + e.Message;  
             Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);  
             msg.run();  
             return false;  
2483          }          }
2484          __import_queued_samples();          printf("filename=%s\n", filename.c_str());
2485          file_structure_changed_signal.emit(this->file);  
2486            progress_dialog = new ProgressDialog( //FIXME: memory leak!
2487                _("Saving") +  Glib::ustring(" '") +
2488                Glib::filename_display_basename(filename) + "' ...",
2489                *this
2490            );
2491    #if HAS_GTKMM_SHOW_ALL_CHILDREN
2492            progress_dialog->show_all();
2493    #endif
2494    
2495            saver = new Saver(file, filename); //FIXME: memory leak!
2496            saver->signal_progress().connect(
2497                sigc::mem_fun(*this, &MainWindow::on_saver_progress));
2498            saver->signal_finished().connect(
2499                sigc::mem_fun(*this, &MainWindow::on_saver_finished));
2500            saver->signal_error().connect(
2501                sigc::mem_fun(*this, &MainWindow::on_saver_error));
2502            saver->launch();
2503    
2504          return true;          return true;
2505      }      }
2506      return false;      return false;
# Line 1087  bool MainWindow::file_save_as() Line 2510  bool MainWindow::file_save_as()
2510  void MainWindow::__import_queued_samples() {  void MainWindow::__import_queued_samples() {
2511      std::cout << "Starting sample import\n" << std::flush;      std::cout << "Starting sample import\n" << std::flush;
2512      Glib::ustring error_files;      Glib::ustring error_files;
2513      printf("Samples to import: %d\n", m_SampleImportQueue.size());      printf("Samples to import: %d\n", int(m_SampleImportQueue.size()));
2514      for (std::list<SampleImportItem>::iterator iter = m_SampleImportQueue.begin();      for (std::map<gig::Sample*, SampleImportItem>::iterator iter = m_SampleImportQueue.begin();
2515           iter != m_SampleImportQueue.end(); ) {           iter != m_SampleImportQueue.end(); ) {
2516          printf("Importing sample %s\n",(*iter).sample_path.c_str());          printf("Importing sample %s\n",iter->second.sample_path.c_str());
2517          SF_INFO info;          SF_INFO info;
2518          info.format = 0;          info.format = 0;
2519          SNDFILE* hFile = sf_open((*iter).sample_path.c_str(), SFM_READ, &info);          SNDFILE* hFile = sf_open(iter->second.sample_path.c_str(), SFM_READ, &info);
2520          sf_command(hFile, SFC_SET_SCALE_FLOAT_INT_READ, 0, SF_TRUE);          sf_command(hFile, SFC_SET_SCALE_FLOAT_INT_READ, 0, SF_TRUE);
2521          try {          try {
2522              if (!hFile) throw std::string(_("could not open file"));              if (!hFile) throw std::string(_("could not open file"));
# Line 1116  void MainWindow::__import_queued_samples Line 2539  void MainWindow::__import_queued_samples
2539                      throw std::string(_("format not supported")); // unsupported subformat (yet?)                      throw std::string(_("format not supported")); // unsupported subformat (yet?)
2540              }              }
2541    
2542                // reset write position for sample
2543                iter->first->SetPos(0);
2544    
2545              const int bufsize = 10000;              const int bufsize = 10000;
2546              switch (bitdepth) {              switch (bitdepth) {
2547                  case 16: {                  case 16: {
# Line 1125  void MainWindow::__import_queued_samples Line 2551  void MainWindow::__import_queued_samples
2551                          // libsndfile does the conversion for us (if needed)                          // libsndfile does the conversion for us (if needed)
2552                          int n = sf_readf_short(hFile, buffer, bufsize);                          int n = sf_readf_short(hFile, buffer, bufsize);
2553                          // write from buffer directly (physically) into .gig file                          // write from buffer directly (physically) into .gig file
2554                          iter->gig_sample->Write(buffer, n);                          iter->first->Write(buffer, n);
2555                          cnt -= n;                          cnt -= n;
2556                      }                      }
2557                      delete[] buffer;                      delete[] buffer;
# Line 1145  void MainWindow::__import_queued_samples Line 2571  void MainWindow::__import_queued_samples
2571                              dstbuf[j++] = srcbuf[i] >> 24;                              dstbuf[j++] = srcbuf[i] >> 24;
2572                          }                          }
2573                          // write from buffer directly (physically) into .gig file                          // write from buffer directly (physically) into .gig file
2574                          iter->gig_sample->Write(dstbuf, n);                          iter->first->Write(dstbuf, n);
2575                          cnt -= n;                          cnt -= n;
2576                      }                      }
2577                      delete[] srcbuf;                      delete[] srcbuf;
# Line 1156  void MainWindow::__import_queued_samples Line 2582  void MainWindow::__import_queued_samples
2582              // cleanup              // cleanup
2583              sf_close(hFile);              sf_close(hFile);
2584              // let the sampler re-cache the sample if needed              // let the sampler re-cache the sample if needed
2585              sample_changed_signal.emit(iter->gig_sample);              sample_changed_signal.emit(iter->first);
2586              // on success we remove the sample from the import queue,              // on success we remove the sample from the import queue,
2587              // otherwise keep it, maybe it works the next time ?              // otherwise keep it, maybe it works the next time ?
2588              std::list<SampleImportItem>::iterator cur = iter;              std::map<gig::Sample*, SampleImportItem>::iterator cur = iter;
2589              ++iter;              ++iter;
2590              m_SampleImportQueue.erase(cur);              m_SampleImportQueue.erase(cur);
2591          } catch (std::string what) {          } catch (std::string what) {
2592              // remember the files that made trouble (and their cause)              // remember the files that made trouble (and their cause)
2593              if (!error_files.empty()) error_files += "\n";              if (!error_files.empty()) error_files += "\n";
2594              error_files += (*iter).sample_path += " (" + what + ")";              error_files += iter->second.sample_path += " (" + what + ")";
2595              ++iter;              ++iter;
2596          }          }
2597      }      }
# Line 1179  void MainWindow::__import_queued_samples Line 2605  void MainWindow::__import_queued_samples
2605    
2606  void MainWindow::on_action_file_properties()  void MainWindow::on_action_file_properties()
2607  {  {
2608      propDialog.show();      fileProps.show();
2609      propDialog.deiconify();      fileProps.deiconify();
2610  }  }
2611    
2612  void MainWindow::on_action_warn_user_on_extensions() {  void MainWindow::on_action_warn_user_on_extensions() {
# Line 1188  void MainWindow::on_action_warn_user_on_ Line 2614  void MainWindow::on_action_warn_user_on_
2614          !Settings::singleton()->warnUserOnExtensions;          !Settings::singleton()->warnUserOnExtensions;
2615  }  }
2616    
2617    void MainWindow::on_action_show_tooltips() {
2618        Settings::singleton()->showTooltips =
2619            !Settings::singleton()->showTooltips;
2620    
2621        on_show_tooltips_changed();
2622    }
2623    
2624    void MainWindow::on_show_tooltips_changed() {
2625        const bool b = Settings::singleton()->showTooltips;
2626    
2627        dimreg_label.set_has_tooltip(b);
2628        dimreg_all_regions.set_has_tooltip(b);
2629        dimreg_all_dimregs.set_has_tooltip(b);
2630        dimreg_stereo.set_has_tooltip(b);
2631    
2632        // Not doing this here, we let onQueryTreeViewTooltip() handle this per cell
2633        //m_TreeView.set_has_tooltip(b);
2634    
2635        m_TreeViewSamples.set_has_tooltip(b);
2636        m_TreeViewScripts.set_has_tooltip(b);
2637    
2638        set_has_tooltip(b);
2639    }
2640    
2641    void MainWindow::on_action_sync_sampler_instrument_selection() {
2642        Settings::singleton()->syncSamplerInstrumentSelection =
2643            !Settings::singleton()->syncSamplerInstrumentSelection;
2644    }
2645    
2646    void MainWindow::on_action_move_root_note_with_region_moved() {
2647        Settings::singleton()->moveRootNoteWithRegionMoved =
2648            !Settings::singleton()->moveRootNoteWithRegionMoved;
2649    }
2650    
2651  void MainWindow::on_action_help_about()  void MainWindow::on_action_help_about()
2652  {  {
2653      Gtk::AboutDialog dialog;      Gtk::AboutDialog dialog;
# Line 1197  void MainWindow::on_action_help_about() Line 2657  void MainWindow::on_action_help_about()
2657      dialog.set_name("Gigedit");      dialog.set_name("Gigedit");
2658  #endif  #endif
2659      dialog.set_version(VERSION);      dialog.set_version(VERSION);
2660      dialog.set_copyright("Copyright (C) 2006-2014 Andreas Persson");      dialog.set_copyright("Copyright (C) 2006-2019 Andreas Persson");
2661      const std::string sComment =      const std::string sComment =
2662          _("Built " __DATE__ "\nUsing ") +          _("Built " __DATE__ "\nUsing ") +
2663          ::gig::libraryName() + " " + ::gig::libraryVersion() + "\n\n" +          ::gig::libraryName() + " " + ::gig::libraryVersion() + "\n\n" +
# Line 1208  void MainWindow::on_action_help_about() Line 2668  void MainWindow::on_action_help_about()
2668              "backup your Gigasampler/GigaStudio files before editing them with "              "backup your Gigasampler/GigaStudio files before editing them with "
2669              "this application.\n"              "this application.\n"
2670              "\n"              "\n"
2671              "Please report bugs to: http://bugs.linuxsampler.org"              "Please report bugs to: https://bugs.linuxsampler.org"
2672          );          );
2673      dialog.set_comments(sComment.c_str());      dialog.set_comments(sComment.c_str());
2674      dialog.set_website("http://www.linuxsampler.org");      dialog.set_website("https://www.linuxsampler.org");
2675      dialog.set_website_label("http://www.linuxsampler.org");      dialog.set_website_label("https://www.linuxsampler.org");
2676        dialog.set_position(Gtk::WIN_POS_CENTER);
2677      dialog.run();      dialog.run();
2678  }  }
2679    
2680  PropDialog::PropDialog()  FilePropDialog::FilePropDialog()
2681      : eFileFormat(_("File Format")),      : eFileFormat(_("File Format")),
2682        eName(_("Name")),        eName(_("Name")),
2683        eCreationDate(_("Creation date")),        eCreationDate(_("Creation date")),
# Line 1234  PropDialog::PropDialog() Line 2695  PropDialog::PropDialog()
2695        eSourceForm(_("Source form")),        eSourceForm(_("Source form")),
2696        eCommissioned(_("Commissioned")),        eCommissioned(_("Commissioned")),
2697        eSubject(_("Subject")),        eSubject(_("Subject")),
2698    #if HAS_GTKMM_STOCK
2699        quitButton(Gtk::Stock::CLOSE),        quitButton(Gtk::Stock::CLOSE),
2700    #else
2701          quitButton(_("_Close")),
2702    #endif
2703        table(2, 1),        table(2, 1),
2704        m_file(NULL)        m_file(NULL)
2705  {  {
2706        if (!Settings::singleton()->autoRestoreWindowDimension) {
2707            set_default_size(470, 390);
2708            set_position(Gtk::WIN_POS_MOUSE);
2709        }
2710    
2711      set_title(_("File Properties"));      set_title(_("File Properties"));
2712      eName.set_width_chars(50);      eName.set_width_chars(50);
2713    
2714        connect(eFileFormat, &FilePropDialog::set_FileFormat);
2715      connect(eName, &DLS::Info::Name);      connect(eName, &DLS::Info::Name);
2716      connect(eCreationDate, &DLS::Info::CreationDate);      connect(eCreationDate, &DLS::Info::CreationDate);
2717      connect(eComments, &DLS::Info::Comments);      connect(eComments, &DLS::Info::Comments);
# Line 1276  PropDialog::PropDialog() Line 2747  PropDialog::PropDialog()
2747      table.add(eCommissioned);      table.add(eCommissioned);
2748      table.add(eSubject);      table.add(eSubject);
2749    
2750    #if USE_GTKMM_GRID
2751        table.set_column_spacing(5);
2752    #else
2753      table.set_col_spacings(5);      table.set_col_spacings(5);
2754    #endif
2755    
2756      add(vbox);      add(vbox);
2757    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2758        table.set_margin(5);
2759    #else
2760      table.set_border_width(5);      table.set_border_width(5);
2761    #endif
2762      vbox.add(table);      vbox.add(table);
2763      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);
2764      buttonBox.set_layout(Gtk::BUTTONBOX_END);      buttonBox.set_layout(Gtk::BUTTONBOX_END);
2765    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
2766        buttonBox.set_margin(5);
2767    #else
2768      buttonBox.set_border_width(5);      buttonBox.set_border_width(5);
2769    #endif
2770      buttonBox.show();      buttonBox.show();
2771      buttonBox.pack_start(quitButton);      buttonBox.pack_start(quitButton);
2772      quitButton.set_can_default();      quitButton.set_can_default();
2773      quitButton.grab_focus();      quitButton.grab_focus();
2774      quitButton.signal_clicked().connect(      quitButton.signal_clicked().connect(
2775          sigc::mem_fun(*this, &PropDialog::hide));          sigc::mem_fun(*this, &FilePropDialog::hide));
     eFileFormat.signal_value_changed().connect(  
         sigc::mem_fun(*this, &PropDialog::onFileFormatChanged));  
2776    
2777      quitButton.show();      quitButton.show();
2778      vbox.show();      vbox.show();
2779    #if HAS_GTKMM_SHOW_ALL_CHILDREN
2780      show_all_children();      show_all_children();
2781    #endif
2782  }  }
2783    
2784  void PropDialog::set_file(gig::File* file)  void FilePropDialog::set_file(gig::File* file)
2785  {  {
2786      m_file = file;      m_file = file;
2787        update(file->pInfo);
2788    
2789      // update file format version combo box      // update file format version combo box
2790      const std::string sGiga = "Gigasampler/GigaStudio v";      const std::string sGiga = "Gigasampler/GigaStudio v";
# Line 1307  void PropDialog::set_file(gig::File* fil Line 2792  void PropDialog::set_file(gig::File* fil
2792      std::vector<std::string> txts;      std::vector<std::string> txts;
2793      std::vector<int> values;      std::vector<int> values;
2794      txts.push_back(sGiga + "2"); values.push_back(2);      txts.push_back(sGiga + "2"); values.push_back(2);
2795      txts.push_back(sGiga + "3/v4"); values.push_back(3);      txts.push_back(sGiga + "3"); values.push_back(3);
2796      if (major != 2 && major != 3) {      txts.push_back(sGiga + "4"); values.push_back(4);
2797        if (major < 2 || major > 4) {
2798          txts.push_back(sGiga + ToString(major)); values.push_back(major);          txts.push_back(sGiga + ToString(major)); values.push_back(major);
2799      }      }
2800      std::vector<const char*> texts;      std::vector<const char*> texts;
2801      for (int i = 0; i < txts.size(); ++i) texts.push_back(txts[i].c_str());      for (int i = 0; i < txts.size(); ++i) texts.push_back(txts[i].c_str());
2802      texts.push_back(NULL); values.push_back(0);      texts.push_back(NULL); values.push_back(0);
2803    
2804        update_model++;
2805      eFileFormat.set_choices(&texts[0], &values[0]);      eFileFormat.set_choices(&texts[0], &values[0]);
2806      eFileFormat.set_value(major);      eFileFormat.set_value(major);
2807        update_model--;
2808  }  }
2809    
2810  void PropDialog::onFileFormatChanged() {  void FilePropDialog::set_FileFormat(int value)
     const int major = eFileFormat.get_value();  
     if (m_file) m_file->pVersion->major = major;  
 }  
   
 void PropDialog::set_info(DLS::Info* info)  
2811  {  {
2812      update(info);      m_file->pVersion->major = value;
2813  }  }
2814    
2815    
# Line 1357  void InstrumentProps::set_MIDIProgram(ui Line 2841  void InstrumentProps::set_MIDIProgram(ui
2841  }  }
2842    
2843  InstrumentProps::InstrumentProps() :  InstrumentProps::InstrumentProps() :
2844    #if HAS_GTKMM_STOCK
2845      quitButton(Gtk::Stock::CLOSE),      quitButton(Gtk::Stock::CLOSE),
2846    #else
2847        quitButton(_("_Close")),
2848    #endif
2849      table(2,1),      table(2,1),
2850      eName(_("Name")),      eName(_("Name")),
2851      eIsDrum(_("Is drum")),      eIsDrum(_("Is drum")),
# Line 1367  InstrumentProps::InstrumentProps() : Line 2855  InstrumentProps::InstrumentProps() :
2855      eGainPlus6(_("Gain +6dB"), eAttenuation, -6),      eGainPlus6(_("Gain +6dB"), eAttenuation, -6),
2856      eEffectSend(_("Effect send"), 0, 65535),      eEffectSend(_("Effect send"), 0, 65535),
2857      eFineTune(_("Fine tune"), -8400, 8400),      eFineTune(_("Fine tune"), -8400, 8400),
2858      ePitchbendRange(_("Pitchbend range"), 0, 12),      ePitchbendRange(_("Pitchbend range"), 0, 48),
2859      ePianoReleaseMode(_("Piano release mode")),      ePianoReleaseMode(_("Piano release mode")),
2860      eDimensionKeyRangeLow(_("Keyswitching range low")),      eDimensionKeyRangeLow(_("Keyswitching range low")),
2861      eDimensionKeyRangeHigh(_("Keyswitching range high"))      eDimensionKeyRangeHigh(_("Keyswitching range high")),
2862  {      table2(2,1),
2863        eName2(_("Name")),
2864        eCreationDate(_("Creation date")),
2865        eComments(_("Comments")),
2866        eProduct(_("Product")),
2867        eCopyright(_("Copyright")),
2868        eArtists(_("Artists")),
2869        eGenre(_("Genre")),
2870        eKeywords(_("Keywords")),
2871        eEngineer(_("Engineer")),
2872        eTechnician(_("Technician")),
2873        eSoftware(_("Software")),
2874        eMedium(_("Medium")),
2875        eSource(_("Source")),
2876        eSourceForm(_("Source form")),
2877        eCommissioned(_("Commissioned")),
2878        eSubject(_("Subject"))
2879    {
2880        if (!Settings::singleton()->autoRestoreWindowDimension) {
2881            //set_default_size(470, 390);
2882            set_position(Gtk::WIN_POS_MOUSE);
2883        }
2884    
2885      set_title(_("Instrument Properties"));      set_title(_("Instrument Properties"));
2886    
2887        tabs.append_page(vbox[1], _("Settings"));
2888        tabs.append_page(vbox[2], _("Info"));
2889    
2890      eDimensionKeyRangeLow.set_tip(      eDimensionKeyRangeLow.set_tip(
2891          _("start of the keyboard area which should switch the "          _("start of the keyboard area which should switch the "
2892            "\"keyswitching\" dimension")            "\"keyswitching\" dimension")
# Line 1398  InstrumentProps::InstrumentProps() : Line 2911  InstrumentProps::InstrumentProps() :
2911    
2912      eName.signal_value_changed().connect(sig_name_changed.make_slot());      eName.signal_value_changed().connect(sig_name_changed.make_slot());
2913    
2914        connect(eName2, &InstrumentProps::set_Name);
2915        connectLambda(eCreationDate, [this](gig::String s) {
2916            m->pInfo->CreationDate = s;
2917        });
2918        connectLambda(eComments, [this](gig::String s) {
2919            m->pInfo->Comments = s;
2920        });
2921        connectLambda(eProduct, [this](gig::String s) {
2922            m->pInfo->Product = s;
2923        });
2924        connectLambda(eCopyright, [this](gig::String s) {
2925            m->pInfo->Copyright = s;
2926        });
2927        connectLambda(eArtists, [this](gig::String s) {
2928            m->pInfo->Artists = s;
2929        });
2930        connectLambda(eGenre, [this](gig::String s) {
2931            m->pInfo->Genre = s;
2932        });
2933        connectLambda(eKeywords, [this](gig::String s) {
2934            m->pInfo->Keywords = s;
2935        });
2936        connectLambda(eEngineer, [this](gig::String s) {
2937            m->pInfo->Engineer = s;
2938        });
2939        connectLambda(eTechnician, [this](gig::String s) {
2940            m->pInfo->Technician = s;
2941        });
2942        connectLambda(eSoftware, [this](gig::String s) {
2943            m->pInfo->Software = s;
2944        });
2945        connectLambda(eMedium, [this](gig::String s) {
2946            m->pInfo->Medium = s;
2947        });
2948        connectLambda(eSource, [this](gig::String s) {
2949            m->pInfo->Source = s;
2950        });
2951        connectLambda(eSourceForm, [this](gig::String s) {
2952            m->pInfo->SourceForm = s;
2953        });
2954        connectLambda(eCommissioned, [this](gig::String s) {
2955            m->pInfo->Commissioned = s;
2956        });
2957        connectLambda(eSubject, [this](gig::String s) {
2958            m->pInfo->Subject = s;
2959        });
2960    
2961        // tab 1
2962    #if USE_GTKMM_GRID
2963        table.set_column_spacing(5);
2964    #else
2965      table.set_col_spacings(5);      table.set_col_spacings(5);
2966    #endif
2967      table.add(eName);      table.add(eName);
2968      table.add(eIsDrum);      table.add(eIsDrum);
2969      table.add(eMIDIBank);      table.add(eMIDIBank);
# Line 1413  InstrumentProps::InstrumentProps() : Line 2977  InstrumentProps::InstrumentProps() :
2977      table.add(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
2978      table.add(eDimensionKeyRangeHigh);      table.add(eDimensionKeyRangeHigh);
2979    
2980      add(vbox);      // tab 2
2981    #if USE_GTKMM_GRID
2982        table2.set_column_spacing(5);
2983    #else
2984        table2.set_col_spacings(5);
2985    #endif
2986        table2.add(eName2);
2987        table2.add(eCreationDate);
2988        table2.add(eComments);
2989        table2.add(eProduct);
2990        table2.add(eCopyright);
2991        table2.add(eArtists);
2992        table2.add(eGenre);
2993        table2.add(eKeywords);
2994        table2.add(eEngineer);
2995        table2.add(eTechnician);
2996        table2.add(eSoftware);
2997        table2.add(eMedium);
2998        table2.add(eSource);
2999        table2.add(eSourceForm);
3000        table2.add(eCommissioned);
3001        table2.add(eSubject);
3002    
3003        add(vbox[0]);
3004    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3005        table.set_margin(5);
3006    #else
3007      table.set_border_width(5);      table.set_border_width(5);
3008      vbox.pack_start(table);  #endif
3009        vbox[1].pack_start(table);
3010        vbox[2].pack_start(table2);
3011      table.show();      table.show();
3012      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);      table2.show();
3013        vbox[0].pack_start(tabs);
3014        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3015      buttonBox.set_layout(Gtk::BUTTONBOX_END);      buttonBox.set_layout(Gtk::BUTTONBOX_END);
3016    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3017        buttonBox.set_margin(5);
3018    #else
3019      buttonBox.set_border_width(5);      buttonBox.set_border_width(5);
3020    #endif
3021      buttonBox.show();      buttonBox.show();
3022      buttonBox.pack_start(quitButton);      buttonBox.pack_start(quitButton);
3023      quitButton.set_can_default();      quitButton.set_can_default();
# Line 1429  InstrumentProps::InstrumentProps() : Line 3027  InstrumentProps::InstrumentProps() :
3027          sigc::mem_fun(*this, &InstrumentProps::hide));          sigc::mem_fun(*this, &InstrumentProps::hide));
3028    
3029      quitButton.show();      quitButton.show();
3030      vbox.show();      vbox[0].show();
3031    #if HAS_GTKMM_SHOW_ALL_CHILDREN
3032      show_all_children();      show_all_children();
3033    #endif
3034  }  }
3035    
3036  void InstrumentProps::set_instrument(gig::Instrument* instrument)  void InstrumentProps::set_instrument(gig::Instrument* instrument)
# Line 1438  void InstrumentProps::set_instrument(gig Line 3038  void InstrumentProps::set_instrument(gig
3038      update(instrument);      update(instrument);
3039    
3040      update_model++;      update_model++;
3041    
3042        // tab 1
3043      eName.set_value(instrument->pInfo->Name);      eName.set_value(instrument->pInfo->Name);
3044      eIsDrum.set_value(instrument->IsDrum);      eIsDrum.set_value(instrument->IsDrum);
3045      eMIDIBank.set_value(instrument->MIDIBank);      eMIDIBank.set_value(instrument->MIDIBank);
3046      eMIDIProgram.set_value(instrument->MIDIProgram);      eMIDIProgram.set_value(instrument->MIDIProgram);
3047        // tab 2
3048        eName2.set_value(instrument->pInfo->Name);
3049        eCreationDate.set_value(instrument->pInfo->CreationDate);
3050        eComments.set_value(instrument->pInfo->Comments);
3051        eProduct.set_value(instrument->pInfo->Product);
3052        eCopyright.set_value(instrument->pInfo->Copyright);
3053        eArtists.set_value(instrument->pInfo->Artists);
3054        eGenre.set_value(instrument->pInfo->Genre);
3055        eKeywords.set_value(instrument->pInfo->Keywords);
3056        eEngineer.set_value(instrument->pInfo->Engineer);
3057        eTechnician.set_value(instrument->pInfo->Technician);
3058        eSoftware.set_value(instrument->pInfo->Software);
3059        eMedium.set_value(instrument->pInfo->Medium);
3060        eSource.set_value(instrument->pInfo->Source);
3061        eSourceForm.set_value(instrument->pInfo->SourceForm);
3062        eCommissioned.set_value(instrument->pInfo->Commissioned);
3063        eSubject.set_value(instrument->pInfo->Subject);
3064    
3065        update_model--;
3066    }
3067    
3068    
3069    SampleProps::SampleProps() :
3070    #if HAS_GTKMM_STOCK
3071        quitButton(Gtk::Stock::CLOSE),
3072    #else
3073        quitButton(_("_Close")),
3074    #endif
3075        table(2,1),
3076        eName(_("Name")),
3077        eUnityNote(_("Unity Note")),
3078        eSampleGroup(_("Sample Group")),
3079        eSampleFormatInfo(_("Sample Format")),
3080        eSampleID("Sample ID"),
3081        eChecksum("Wave Data CRC-32"),
3082        eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
3083        eLoopStart(_("Loop start position"), 0, 9999999),
3084        eLoopLength(_("Loop size"), 0, 9999999),
3085        eLoopType(_("Loop type")),
3086        eLoopPlayCount(_("Playback count")),
3087        table2(2,1),
3088        eName2(_("Name")),
3089        eCreationDate(_("Creation date")),
3090        eComments(_("Comments")),
3091        eProduct(_("Product")),
3092        eCopyright(_("Copyright")),
3093        eArtists(_("Artists")),
3094        eGenre(_("Genre")),
3095        eKeywords(_("Keywords")),
3096        eEngineer(_("Engineer")),
3097        eTechnician(_("Technician")),
3098        eSoftware(_("Software")),
3099        eMedium(_("Medium")),
3100        eSource(_("Source")),
3101        eSourceForm(_("Source form")),
3102        eCommissioned(_("Commissioned")),
3103        eSubject(_("Subject"))
3104    {
3105        if (!Settings::singleton()->autoRestoreWindowDimension) {
3106            //set_default_size(470, 390);
3107            set_position(Gtk::WIN_POS_MOUSE);
3108        }
3109    
3110        set_title(_("Sample Properties"));
3111    
3112        tabs.append_page(vbox[1], _("Settings"));
3113        tabs.append_page(vbox[2], _("Info"));
3114    
3115        connect(eName, &SampleProps::set_Name);
3116        connect(eUnityNote, &gig::Sample::MIDIUnityNote);
3117        connect(eLoopsCount, &gig::Sample::Loops);
3118        connectLambda(eLoopStart, [this](uint32_t start){
3119            m->LoopStart = start;
3120            m->LoopEnd = start + m->LoopSize;
3121        });
3122        connectLambda(eLoopLength, [this](uint32_t length){
3123            m->LoopSize = length;
3124            m->LoopEnd = m->LoopStart + length;
3125        });
3126        {
3127            const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
3128            static const gig::loop_type_t values[] = {
3129                gig::loop_type_normal,
3130                gig::loop_type_bidirectional,
3131                gig::loop_type_backward
3132            };
3133            eLoopType.set_choices(choices, values);
3134        }
3135        connect(eLoopType, &gig::Sample::LoopType);
3136        connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
3137    
3138        eName.signal_value_changed().connect(sig_name_changed.make_slot());
3139    
3140        connect(eName2, &SampleProps::set_Name);
3141        connectLambda(eCreationDate, [this](gig::String s) {
3142            m->pInfo->CreationDate = s;
3143        });
3144        connectLambda(eComments, [this](gig::String s) {
3145            m->pInfo->Comments = s;
3146        });
3147        connectLambda(eProduct, [this](gig::String s) {
3148            m->pInfo->Product = s;
3149        });
3150        connectLambda(eCopyright, [this](gig::String s) {
3151            m->pInfo->Copyright = s;
3152        });
3153        connectLambda(eArtists, [this](gig::String s) {
3154            m->pInfo->Artists = s;
3155        });
3156        connectLambda(eGenre, [this](gig::String s) {
3157            m->pInfo->Genre = s;
3158        });
3159        connectLambda(eKeywords, [this](gig::String s) {
3160            m->pInfo->Keywords = s;
3161        });
3162        connectLambda(eEngineer, [this](gig::String s) {
3163            m->pInfo->Engineer = s;
3164        });
3165        connectLambda(eTechnician, [this](gig::String s) {
3166            m->pInfo->Technician = s;
3167        });
3168        connectLambda(eSoftware, [this](gig::String s) {
3169            m->pInfo->Software = s;
3170        });
3171        connectLambda(eMedium, [this](gig::String s) {
3172            m->pInfo->Medium = s;
3173        });
3174        connectLambda(eSource, [this](gig::String s) {
3175            m->pInfo->Source = s;
3176        });
3177        connectLambda(eSourceForm, [this](gig::String s) {
3178            m->pInfo->SourceForm = s;
3179        });
3180        connectLambda(eCommissioned, [this](gig::String s) {
3181            m->pInfo->Commissioned = s;
3182        });
3183        connectLambda(eSubject, [this](gig::String s) {
3184            m->pInfo->Subject = s;
3185        });
3186    
3187        // tab 1
3188    #if USE_GTKMM_GRID
3189        table.set_column_spacing(5);
3190    #else
3191        table.set_col_spacings(5);
3192    #endif
3193        table.add(eName);
3194        table.add(eUnityNote);
3195        table.add(eSampleGroup);
3196        table.add(eSampleFormatInfo);
3197        table.add(eSampleID);
3198        table.add(eChecksum);
3199        table.add(eLoopsCount);
3200        table.add(eLoopStart);
3201        table.add(eLoopLength);
3202        table.add(eLoopType);
3203        table.add(eLoopPlayCount);
3204    
3205        // tab 2
3206    #if USE_GTKMM_GRID
3207        table2.set_column_spacing(5);
3208    #else
3209        table2.set_col_spacings(5);
3210    #endif
3211        table2.add(eName2);
3212        table2.add(eCreationDate);
3213        table2.add(eComments);
3214        table2.add(eProduct);
3215        table2.add(eCopyright);
3216        table2.add(eArtists);
3217        table2.add(eGenre);
3218        table2.add(eKeywords);
3219        table2.add(eEngineer);
3220        table2.add(eTechnician);
3221        table2.add(eSoftware);
3222        table2.add(eMedium);
3223        table2.add(eSource);
3224        table2.add(eSourceForm);
3225        table2.add(eCommissioned);
3226        table2.add(eSubject);
3227    
3228        add(vbox[0]);
3229    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3230        table.set_margin(5);
3231    #else
3232        table.set_border_width(5);
3233    #endif
3234        vbox[1].pack_start(table);
3235        vbox[2].pack_start(table2);
3236        table.show();
3237        table2.show();
3238        vbox[0].pack_start(tabs);
3239        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3240        buttonBox.set_layout(Gtk::BUTTONBOX_END);
3241    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3242        buttonBox.set_margin(5);
3243    #else
3244        buttonBox.set_border_width(5);
3245    #endif
3246        buttonBox.show();
3247        buttonBox.pack_start(quitButton);
3248        quitButton.set_can_default();
3249        quitButton.grab_focus();
3250    
3251        quitButton.signal_clicked().connect(
3252            sigc::mem_fun(*this, &SampleProps::hide));
3253    
3254        quitButton.show();
3255        vbox[0].show();
3256    #if HAS_GTKMM_SHOW_ALL_CHILDREN
3257        show_all_children();
3258    #endif
3259    }
3260    
3261    void SampleProps::set_sample(gig::Sample* sample)
3262    {
3263        update(sample);
3264    
3265        update_model++;
3266    
3267        // tab 1
3268        eName.set_value(sample->pInfo->Name);
3269        eUnityNote.set_value(sample->MIDIUnityNote);
3270        // show sample group name
3271        {
3272            Glib::ustring s = "---";
3273            if (sample && sample->GetGroup())
3274                s = sample->GetGroup()->Name;
3275            eSampleGroup.text.set_text(s);
3276        }
3277        // assemble sample format info string
3278        {
3279            Glib::ustring s;
3280            if (sample) {
3281                switch (sample->Channels) {
3282                    case 1: s = _("Mono"); break;
3283                    case 2: s = _("Stereo"); break;
3284                    default:
3285                        s = ToString(sample->Channels) + _(" audio channels");
3286                        break;
3287                }
3288                s += " " + ToString(sample->BitDepth) + " Bits";
3289                s += " " + ToString(sample->SamplesPerSecond/1000) + "."
3290                         + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
3291            } else {
3292                s = _("No sample assigned to this dimension region.");
3293            }
3294            eSampleFormatInfo.text.set_text(s);
3295        }
3296        // generate sample's memory address pointer string
3297        {
3298            Glib::ustring s;
3299            if (sample) {
3300                char buf[64] = {};
3301                snprintf(buf, sizeof(buf), "%p", sample);
3302                s = buf;
3303            } else {
3304                s = "---";
3305            }
3306            eSampleID.text.set_text(s);
3307        }
3308        // generate raw wave form data CRC-32 checksum string
3309        {
3310            Glib::ustring s = "---";
3311            if (sample) {
3312                char buf[64] = {};
3313                snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
3314                s = buf;
3315            }
3316            eChecksum.text.set_text(s);
3317        }
3318        eLoopsCount.set_value(sample->Loops);
3319        eLoopStart.set_value(sample->LoopStart);
3320        eLoopLength.set_value(sample->LoopSize);
3321        eLoopType.set_value(sample->LoopType);
3322        eLoopPlayCount.set_value(sample->LoopPlayCount);
3323        // tab 2
3324        eName2.set_value(sample->pInfo->Name);
3325        eCreationDate.set_value(sample->pInfo->CreationDate);
3326        eComments.set_value(sample->pInfo->Comments);
3327        eProduct.set_value(sample->pInfo->Product);
3328        eCopyright.set_value(sample->pInfo->Copyright);
3329        eArtists.set_value(sample->pInfo->Artists);
3330        eGenre.set_value(sample->pInfo->Genre);
3331        eKeywords.set_value(sample->pInfo->Keywords);
3332        eEngineer.set_value(sample->pInfo->Engineer);
3333        eTechnician.set_value(sample->pInfo->Technician);
3334        eSoftware.set_value(sample->pInfo->Software);
3335        eMedium.set_value(sample->pInfo->Medium);
3336        eSource.set_value(sample->pInfo->Source);
3337        eSourceForm.set_value(sample->pInfo->SourceForm);
3338        eCommissioned.set_value(sample->pInfo->Commissioned);
3339        eSubject.set_value(sample->pInfo->Subject);
3340    
3341        update_model--;
3342    }
3343    
3344    void SampleProps::set_Name(const gig::String& name)
3345    {
3346        m->pInfo->Name = name;
3347    }
3348    
3349    void SampleProps::update_name()
3350    {
3351        update_model++;
3352        eName.set_value(m->pInfo->Name);
3353      update_model--;      update_model--;
3354  }  }
3355    
# Line 1475  void MainWindow::updateSampleRefCountMap Line 3383  void MainWindow::updateSampleRefCountMap
3383      }      }
3384  }  }
3385    
3386    bool MainWindow::onQueryTreeViewTooltip(int x, int y, bool keyboardTip, const Glib::RefPtr<Gtk::Tooltip>& tooltip) {
3387        Gtk::TreeModel::iterator iter;
3388        if (!m_TreeView.get_tooltip_context_iter(x, y, keyboardTip, iter)) {
3389            return false;
3390        }
3391        Gtk::TreeModel::Path path(iter);
3392        Gtk::TreeModel::Row row = *iter;
3393        Gtk::TreeViewColumn* pointedColumn = NULL;
3394        // resolve the precise table column the mouse points to
3395        {
3396            Gtk::TreeModel::Path path; // unused
3397            int cellX, cellY; // unused
3398            m_TreeView.get_path_at_pos(x, y, path, pointedColumn, cellX, cellY);
3399        }
3400        Gtk::TreeViewColumn* scriptsColumn = m_TreeView.get_column(2);
3401        if (pointedColumn == scriptsColumn) { // mouse hovers scripts column ...
3402            // show the script(s) assigned to the hovered instrument as tooltip
3403            tooltip->set_markup( row[m_Columns.m_col_tooltip] );
3404            m_TreeView.set_tooltip_cell(tooltip, &path, scriptsColumn, NULL);
3405        } else {
3406            // if beginners' tooltips is disabled then don't show the following one
3407            if (!Settings::singleton()->showTooltips)
3408                return false;
3409            // yeah, a beginners tooltip
3410            tooltip->set_text(_(
3411                "Right click here for actions on instruments & MIDI Rules. "
3412                "Drag & drop to change the order of instruments."
3413            ));
3414            m_TreeView.set_tooltip_cell(tooltip, &path, pointedColumn, NULL);
3415        }
3416        return true;
3417    }
3418    
3419    static Glib::ustring scriptTooltipFor(gig::Instrument* instrument, int index) {
3420        Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3421        const int iScriptSlots = instrument->ScriptSlotCount();
3422        Glib::ustring tooltip = "<u>(" + ToString(index) + ") “"  + name + "”</u>\n\n";
3423        if (!iScriptSlots)
3424            tooltip += "<span foreground='red'><i>No script assigned</i></span>";
3425        else {
3426            for (int i = 0; i < iScriptSlots; ++i) {
3427                tooltip += "• " + ToString(i+1) + ". Script: “<span foreground='#46DEFF'><b>" +
3428                           instrument->GetScriptOfSlot(i)->Name + "</b></span>”";
3429                if (i + 1 < iScriptSlots) tooltip += "\n\n";
3430            }
3431        }
3432        return tooltip;
3433    }
3434    
3435  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)  void MainWindow::load_gig(gig::File* gig, const char* filename, bool isSharedInstrument)
3436  {  {
3437      file = 0;      file = 0;
3438      set_file_is_shared(isSharedInstrument);      set_file_is_shared(isSharedInstrument);
3439    
3440      this->filename = filename ? filename : _("Unsaved Gig File");      this->filename =
3441            (filename && strlen(filename) > 0) ?
3442                filename : (!gig->GetFileName().empty()) ?
3443                    gig->GetFileName() : _("Unsaved Gig File");
3444      set_title(Glib::filename_display_basename(this->filename));      set_title(Glib::filename_display_basename(this->filename));
3445      file_has_name = filename;      file_has_name = filename;
3446      file_is_changed = false;      file_is_changed = false;
3447    
3448      propDialog.set_file(gig);      fileProps.set_file(gig);
     propDialog.set_info(gig->pInfo);  
3449    
3450      instrument_name_connection.block();      instrument_name_connection.block();
3451        int index = 0;
3452      for (gig::Instrument* instrument = gig->GetFirstInstrument() ; instrument ;      for (gig::Instrument* instrument = gig->GetFirstInstrument() ; instrument ;
3453           instrument = gig->GetNextInstrument()) {           instrument = gig->GetNextInstrument(), ++index) {
3454          Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));          Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
3455            const int iScriptSlots = instrument->ScriptSlotCount();
3456    
3457          Gtk::TreeModel::iterator iter = m_refTreeModel->append();          Gtk::TreeModel::iterator iter = m_refTreeModel->append();
3458          Gtk::TreeModel::Row row = *iter;          Gtk::TreeModel::Row row = *iter;
3459            row[m_Columns.m_col_nr] = index;
3460          row[m_Columns.m_col_name] = name;          row[m_Columns.m_col_name] = name;
3461          row[m_Columns.m_col_instr] = instrument;          row[m_Columns.m_col_instr] = instrument;
3462            row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3463            row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
3464    
3465    #if !USE_GTKMM_BUILDER
3466          add_instrument_to_menu(name);          add_instrument_to_menu(name);
3467    #endif
3468      }      }
3469      instrument_name_connection.unblock();      instrument_name_connection.unblock();
3470    #if !USE_GTKMM_BUILDER
3471      uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments")->show();      uiManager->get_widget("/MenuBar/MenuInstrument/AllInstruments")->show();
3472    #endif
3473    
3474      updateSampleRefCountMap(gig);      updateSampleRefCountMap(gig);
3475    
# Line 1567  bool MainWindow::instr_props_set_instrum Line 3535  bool MainWindow::instr_props_set_instrum
3535  {  {
3536      instrumentProps.signal_name_changed().clear();      instrumentProps.signal_name_changed().clear();
3537    
3538      Gtk::TreeModel::const_iterator it =      std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
3539          m_TreeView.get_selection()->get_selected();      if (rows.empty()) {
3540            instrumentProps.hide();
3541            return false;
3542        }
3543        //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3544        Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
3545      if (it) {      if (it) {
3546          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
3547          gig::Instrument* instrument = row[m_Columns.m_col_instr];          gig::Instrument* instrument = row[m_Columns.m_col_instr];
# Line 1585  bool MainWindow::instr_props_set_instrum Line 3558  bool MainWindow::instr_props_set_instrum
3558      } else {      } else {
3559          instrumentProps.hide();          instrumentProps.hide();
3560      }      }
3561      return it;      //NOTE: explicit boolean cast required for GTKMM4 development branch here
3562        return it ? true : false;
3563  }  }
3564    
3565  void MainWindow::show_instr_props()  void MainWindow::show_instr_props()
# Line 1604  void MainWindow::instr_name_changed_by_i Line 3578  void MainWindow::instr_name_changed_by_i
3578      gig::Instrument* instrument = row[m_Columns.m_col_instr];      gig::Instrument* instrument = row[m_Columns.m_col_instr];
3579      Glib::ustring gigname(gig_to_utf8(instrument->pInfo->Name));      Glib::ustring gigname(gig_to_utf8(instrument->pInfo->Name));
3580      if (gigname != name) {      if (gigname != name) {
3581            Gtk::TreeModel::Path path(*it);
3582            const int index = path[0];
3583          row[m_Columns.m_col_name] = gigname;          row[m_Columns.m_col_name] = gigname;
3584            row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
3585        }
3586    }
3587    
3588    bool MainWindow::sample_props_set_sample()
3589    {
3590        sampleProps.signal_name_changed().clear();
3591    
3592        std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
3593        if (rows.empty()) {
3594            sampleProps.hide();
3595            return false;
3596        }
3597        //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3598        Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
3599        if (it) {
3600            Gtk::TreeModel::Row row = *it;
3601            gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3602    
3603            sampleProps.set_sample(sample);
3604    
3605            // make sure sample tree is updated when user changes the
3606            // sample name in sample properties window
3607            sampleProps.signal_name_changed().connect(
3608                sigc::bind(
3609                    sigc::mem_fun(*this,
3610                        &MainWindow::sample_name_changed_by_sample_props
3611                    ), it
3612                )
3613            );
3614        } else {
3615            sampleProps.hide();
3616        }
3617        //NOTE: explicit boolean cast required for GTKMM4 development branch here
3618        return it ? true : false;
3619    }
3620    
3621    void MainWindow::show_sample_props()
3622    {
3623        if (sample_props_set_sample()) {
3624            sampleProps.show();
3625            sampleProps.deiconify();
3626        }
3627    }
3628    
3629    void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
3630    {
3631        Gtk::TreeModel::Row row = *it;
3632        Glib::ustring name = row[m_SamplesModel.m_col_name];
3633    
3634        gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3635        Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
3636        if (gigname != name) {
3637            Gtk::TreeModel::Path path(*it);
3638            row[m_SamplesModel.m_col_name] = gigname;
3639      }      }
3640  }  }
3641    
# Line 1621  void MainWindow::show_midi_rules() Line 3652  void MainWindow::show_midi_rules()
3652  void MainWindow::show_script_slots() {  void MainWindow::show_script_slots() {
3653      if (!file) return;      if (!file) return;
3654      // get selected instrument      // get selected instrument
3655      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      std::vector<Gtk::TreeModel::Path> rows = m_TreeView.get_selection()->get_selected_rows();
3656      Gtk::TreeModel::iterator it = sel->get_selected();      if (rows.empty()) return;
3657        Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
3658      if (!it) return;      if (!it) return;
3659      Gtk::TreeModel::Row row = *it;      Gtk::TreeModel::Row row = *it;
3660      gig::Instrument* instrument = row[m_Columns.m_col_instr];      gig::Instrument* instrument = row[m_Columns.m_col_instr];
# Line 1630  void MainWindow::show_script_slots() { Line 3662  void MainWindow::show_script_slots() {
3662    
3663      ScriptSlots* window = new ScriptSlots;      ScriptSlots* window = new ScriptSlots;
3664      window->setInstrument(instrument);      window->setInstrument(instrument);
3665        window->signal_script_slots_changed().connect(
3666            sigc::mem_fun(*this, &MainWindow::onScriptSlotsModified)
3667        );
3668      //window->reparent(*this);      //window->reparent(*this);
3669      window->show();      window->show();
3670  }  }
3671    
3672    void MainWindow::onScriptSlotsModified(gig::Instrument* pInstrument) {
3673        if (!pInstrument) return;
3674        const int iScriptSlots = pInstrument->ScriptSlotCount();
3675    
3676        //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!
3677        //Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
3678        Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
3679    
3680        for (int i = 0; i < model->children().size(); ++i) {
3681            Gtk::TreeModel::Row row = model->children()[i];
3682            if (row[m_Columns.m_col_instr] != pInstrument) continue;
3683            row[m_Columns.m_col_scripts] = iScriptSlots ? ToString(iScriptSlots) : "";
3684            row[m_Columns.m_col_tooltip] = scriptTooltipFor(pInstrument, i);
3685            break;
3686        }
3687    
3688        // causes the sampler to reload the instrument with the new script
3689        on_sel_change();
3690    }
3691    
3692    void MainWindow::assignScript(gig::Script* pScript) {
3693        if (!pScript) {
3694            printf("assignScript() : !script\n");
3695            return;
3696        }
3697        printf("assignScript('%s')\n", pScript->Name.c_str());
3698    
3699        gig::Instrument* pInstrument = get_instrument();
3700        if (!pInstrument) {
3701            printf("!instrument\n");
3702            return;
3703        }
3704    
3705        pInstrument->AddScriptSlot(pScript);
3706    
3707        onScriptSlotsModified(pInstrument);
3708    }
3709    
3710    void MainWindow::dropAllScriptSlots() {
3711        gig::Instrument* pInstrument = get_instrument();
3712        if (!pInstrument) {
3713            printf("!instrument\n");
3714            return;
3715        }
3716    
3717        const int iScriptSlots = pInstrument->ScriptSlotCount();
3718        for (int i = iScriptSlots - 1; i >= 0; --i)
3719            pInstrument->RemoveScriptSlot(i);
3720    
3721        onScriptSlotsModified(pInstrument);
3722    }
3723    
3724    void MainWindow::on_action_refresh_all() {
3725        __refreshEntireGUI();
3726    }
3727    
3728  void MainWindow::on_action_view_status_bar() {  void MainWindow::on_action_view_status_bar() {
3729    #if USE_GLIB_ACTION
3730        bool active = false;
3731        m_actionToggleStatusBar->get_state(active);
3732        // for some reason toggle state does not change automatically
3733        active = !active;
3734        m_actionToggleStatusBar->change_state(active);
3735        if (active)
3736            m_StatusBar.show();
3737        else
3738            m_StatusBar.hide();
3739    #else
3740      Gtk::CheckMenuItem* item =      Gtk::CheckMenuItem* item =
3741          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/Statusbar"));
3742      if (!item) {      if (!item) {
# Line 1643  void MainWindow::on_action_view_status_b Line 3745  void MainWindow::on_action_view_status_b
3745      }      }
3746      if (item->get_active()) m_StatusBar.show();      if (item->get_active()) m_StatusBar.show();
3747      else                    m_StatusBar.hide();      else                    m_StatusBar.hide();
3748    #endif
3749    }
3750    
3751    void MainWindow::on_auto_restore_win_dim() {
3752    #if USE_GLIB_ACTION
3753        bool active = false;
3754        m_actionToggleRestoreWinDim->get_state(active);
3755        // for some reason toggle state does not change automatically
3756        active = !active;
3757        m_actionToggleRestoreWinDim->change_state(active);
3758        Settings::singleton()->autoRestoreWindowDimension = active;
3759    #else
3760        Gtk::CheckMenuItem* item =
3761            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/AutoRestoreWinDim"));
3762        if (!item) {
3763            std::cerr << "/MenuBar/MenuView/AutoRestoreWinDim == NULL\n";
3764            return;
3765        }
3766        Settings::singleton()->autoRestoreWindowDimension = item->get_active();
3767    #endif
3768    }
3769    
3770    void MainWindow::on_save_with_temporary_file() {
3771    #if USE_GLIB_ACTION
3772        bool active = false;
3773        m_actionToggleSaveWithTempFile->get_state(active);
3774        // for some reason toggle state does not change automatically
3775        active = !active;
3776        m_actionToggleSaveWithTempFile->change_state(active);
3777        Settings::singleton()->saveWithTemporaryFile = active;
3778    #else
3779        Gtk::CheckMenuItem* item =
3780            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuSettings/SaveWithTemporaryFile"));
3781        if (!item) {
3782            std::cerr << "/MenuBar/MenuSettings/SaveWithTemporaryFile == NULL\n";
3783            return;
3784        }
3785        Settings::singleton()->saveWithTemporaryFile = item->get_active();
3786    #endif
3787  }  }
3788    
3789  bool MainWindow::is_copy_samples_unity_note_enabled() const {  bool MainWindow::is_copy_samples_unity_note_enabled() const {
3790    #if USE_GLIB_ACTION
3791        bool active = false;
3792        m_actionToggleCopySampleUnity->get_state(active);
3793        return active;
3794    #else
3795      Gtk::CheckMenuItem* item =      Gtk::CheckMenuItem* item =
3796          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleUnity"));          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleUnity"));
3797      if (!item) {      if (!item) {
# Line 1653  bool MainWindow::is_copy_samples_unity_n Line 3799  bool MainWindow::is_copy_samples_unity_n
3799          return true;          return true;
3800      }      }
3801      return item->get_active();      return item->get_active();
3802    #endif
3803  }  }
3804    
3805  bool MainWindow::is_copy_samples_fine_tune_enabled() const {  bool MainWindow::is_copy_samples_fine_tune_enabled() const {
3806    #if USE_GLIB_ACTION
3807        bool active = false;
3808        m_actionToggleCopySampleTune->get_state(active);
3809        return active;
3810    #else
3811      Gtk::CheckMenuItem* item =      Gtk::CheckMenuItem* item =
3812          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleTune"));          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleTune"));
3813      if (!item) {      if (!item) {
# Line 1663  bool MainWindow::is_copy_samples_fine_tu Line 3815  bool MainWindow::is_copy_samples_fine_tu
3815          return true;          return true;
3816      }      }
3817      return item->get_active();      return item->get_active();
3818    #endif
3819  }  }
3820    
3821  bool MainWindow::is_copy_samples_loop_enabled() const {  bool MainWindow::is_copy_samples_loop_enabled() const {
3822    #if USE_GLIB_ACTION
3823        bool active = false;
3824        m_actionToggleCopySampleLoop->get_state(active);
3825        return active;
3826    #else
3827      Gtk::CheckMenuItem* item =      Gtk::CheckMenuItem* item =
3828          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));          dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuEdit/CopySampleLoop"));
3829      if (!item) {      if (!item) {
# Line 1673  bool MainWindow::is_copy_samples_loop_en Line 3831  bool MainWindow::is_copy_samples_loop_en
3831          return true;          return true;
3832      }      }
3833      return item->get_active();      return item->get_active();
3834    #endif
3835  }  }
3836    
3837  void MainWindow::on_button_release(GdkEventButton* button)  #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
3838  {  bool MainWindow::on_button_release(Gdk::EventButton& _button) {
3839        GdkEventButton* button = _button.gobj();
3840    #else
3841    void MainWindow::on_button_release(GdkEventButton* button) {
3842    #endif
3843      if (button->type == GDK_2BUTTON_PRESS) {      if (button->type == GDK_2BUTTON_PRESS) {
3844          show_instr_props();          show_instr_props();
3845      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3846          // gig v2 files have no midi rules          // gig v2 files have no midi rules
3847          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
3848    #if USE_GTKMM_BUILDER
3849            m_actionMIDIRules->property_enabled() = bEnabled;
3850    #else
3851          static_cast<Gtk::MenuItem*>(          static_cast<Gtk::MenuItem*>(
3852              uiManager->get_widget("/MenuBar/MenuInstrument/MidiRules"))->set_sensitive(              uiManager->get_widget("/MenuBar/MenuInstrument/MidiRules"))->set_sensitive(
3853                  bEnabled                  bEnabled
# Line 1690  void MainWindow::on_button_release(GdkEv Line 3856  void MainWindow::on_button_release(GdkEv
3856              uiManager->get_widget("/PopupMenu/MidiRules"))->set_sensitive(              uiManager->get_widget("/PopupMenu/MidiRules"))->set_sensitive(
3857                  bEnabled                  bEnabled
3858              );              );
3859    #endif
3860          popup_menu->popup(button->button, button->time);          popup_menu->popup(button->button, button->time);
3861      }      }
3862    #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
3863        return false;
3864    #endif
3865  }  }
3866    
3867    #if !USE_GTKMM_BUILDER
3868  void MainWindow::on_instrument_selection_change(Gtk::RadioMenuItem* item) {  void MainWindow::on_instrument_selection_change(Gtk::RadioMenuItem* item) {
3869      if (item->get_active()) {      if (item->get_active()) {
3870          const std::vector<Gtk::Widget*> children =          const std::vector<Gtk::Widget*> children =
# Line 1708  void MainWindow::on_instrument_selection Line 3879  void MainWindow::on_instrument_selection
3879          }          }
3880      }      }
3881  }  }
3882    #endif
3883    
3884    void MainWindow::select_instrument(gig::Instrument* instrument) {
3885        if (!instrument) return;
3886    
3887        //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!
3888        Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
3889        //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
3890    
3891        for (int i = 0; i < model->children().size(); ++i) {
3892            Gtk::TreeModel::Row row = model->children()[i];
3893            if (row[m_Columns.m_col_instr] == instrument) {
3894                // select and show the respective instrument in the list view
3895                show_intruments_tab();
3896                m_TreeView.get_selection()->unselect_all();
3897                
3898    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3899                auto iterSel = model->children()[i].get_iter();
3900                m_TreeView.get_selection()->select(iterSel);
3901    #else
3902                m_TreeView.get_selection()->select(model->children()[i]);
3903    #endif
3904                std::vector<Gtk::TreeModel::Path> rows =
3905                    m_TreeView.get_selection()->get_selected_rows();
3906                if (!rows.empty())
3907                    m_TreeView.scroll_to_row(rows[0]);
3908                on_sel_change(); // the regular instrument selection change callback
3909            }
3910        }
3911    }
3912    
3913    /// Returns true if requested dimension region was successfully selected and scrolled to in the list view, false on error.
3914    bool MainWindow::select_dimension_region(gig::DimensionRegion* dimRgn) {
3915        gig::Region* pRegion = (gig::Region*) dimRgn->GetParent();
3916        gig::Instrument* pInstrument = (gig::Instrument*) pRegion->GetParent();
3917    
3918        //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!
3919        Glib::RefPtr<Gtk::TreeModel> model = m_TreeView.get_model();
3920        //Glib::RefPtr<Gtk::TreeModel> model = m_refTreeModelFilter->get_model();
3921    
3922        for (int i = 0; i < model->children().size(); ++i) {
3923            Gtk::TreeModel::Row row = model->children()[i];
3924            if (row[m_Columns.m_col_instr] == pInstrument) {
3925                // select and show the respective instrument in the list view
3926                show_intruments_tab();
3927                m_TreeView.get_selection()->unselect_all();
3928    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3929                auto iterSel = model->children()[i].get_iter();
3930                m_TreeView.get_selection()->select(iterSel);
3931    #else
3932                m_TreeView.get_selection()->select(model->children()[i]);
3933    #endif
3934                std::vector<Gtk::TreeModel::Path> rows =
3935                    m_TreeView.get_selection()->get_selected_rows();
3936                if (!rows.empty())
3937                    m_TreeView.scroll_to_row(rows[0]);
3938                on_sel_change(); // the regular instrument selection change callback
3939    
3940                // select respective region in the region selector
3941                m_RegionChooser.set_region(pRegion);
3942    
3943                // select and show the respective dimension region in the editor
3944                //update_dimregs();
3945                if (!m_DimRegionChooser.select_dimregion(dimRgn)) return false;
3946                //dimreg_edit.set_dim_region(dimRgn);
3947    
3948                return true;
3949            }
3950        }
3951    
3952        return false;
3953    }
3954    
3955    void MainWindow::select_sample(gig::Sample* sample) {
3956        Glib::RefPtr<Gtk::TreeModel> model = m_TreeViewSamples.get_model();
3957        for (int g = 0; g < model->children().size(); ++g) {
3958            Gtk::TreeModel::Row rowGroup = model->children()[g];
3959            for (int s = 0; s < rowGroup.children().size(); ++s) {
3960                Gtk::TreeModel::Row rowSample = rowGroup.children()[s];
3961                if (rowSample[m_SamplesModel.m_col_sample] == sample) {
3962                    show_samples_tab();
3963                    m_TreeViewSamples.get_selection()->unselect_all();
3964    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3965                    auto iterSel = rowGroup.children()[s].get_iter();
3966                    m_TreeViewSamples.get_selection()->select(iterSel);
3967    #else
3968                    m_TreeViewSamples.get_selection()->select(rowGroup.children()[s]);
3969    #endif
3970                    std::vector<Gtk::TreeModel::Path> rows =
3971                        m_TreeViewSamples.get_selection()->get_selected_rows();
3972                    if (rows.empty()) return;
3973                    m_TreeViewSamples.scroll_to_row(rows[0]);
3974                    return;
3975                }
3976            }
3977        }
3978    }
3979    
3980    #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
3981    bool MainWindow::on_sample_treeview_button_release(Gdk::EventButton& _button) {
3982        GdkEventButton* button = _button.gobj();
3983    #else
3984  void MainWindow::on_sample_treeview_button_release(GdkEventButton* button) {  void MainWindow::on_sample_treeview_button_release(GdkEventButton* button) {
3985    #endif
3986      if (button->type == GDK_BUTTON_PRESS && button->button == 3) {      if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3987            // by default if Ctrl keys is pressed down, then a mouse right-click
3988            // does not select the respective row, so we must assure this
3989            // programmatically ...
3990            /*{
3991                Gtk::TreeModel::Path path;
3992                Gtk::TreeViewColumn* pColumn = NULL;
3993                int cellX, cellY;
3994                bool bSuccess = m_TreeViewSamples.get_path_at_pos(
3995                    (int)button->x, (int)button->y,
3996                    path, pColumn, cellX, cellY
3997                );
3998                if (bSuccess) {
3999                    if (m_TreeViewSamples.get_selection()->count_selected_rows() <= 0) {
4000                        printf("not selected !!!\n");
4001                        m_TreeViewSamples.get_selection()->select(path);
4002                    }
4003                }
4004            }*/
4005    
4006    #if !USE_GTKMM_BUILDER
4007          Gtk::Menu* sample_popup =          Gtk::Menu* sample_popup =
4008              dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/SamplePopupMenu"));              dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/SamplePopupMenu"));
4009    #endif
4010    
4011          // update enabled/disabled state of sample popup items          // update enabled/disabled state of sample popup items
4012          Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();          Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4013          Gtk::TreeModel::iterator it = sel->get_selected();          std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4014          bool group_selected  = false;          const int n = rows.size();
4015          bool sample_selected = false;          int nGroups  = 0;
4016          if (it) {          int nSamples = 0;
4017            for (int r = 0; r < n; ++r) {
4018                Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4019                if (!it) continue;
4020              Gtk::TreeModel::Row row = *it;              Gtk::TreeModel::Row row = *it;
4021              group_selected  = row[m_SamplesModel.m_col_group];              if (row[m_SamplesModel.m_col_group]) nGroups++;
4022              sample_selected = row[m_SamplesModel.m_col_sample];              if (row[m_SamplesModel.m_col_sample]) nSamples++;
4023          }          }
4024            
4025                #if USE_GTKMM_BUILDER
4026            m_actionSampleProperties->property_enabled() = (n == 1);
4027            m_actionAddSample->property_enabled() = (n);
4028            m_actionAddSampleGroup->property_enabled() = (file);
4029            m_actionViewSampleRefs->property_enabled() = (nSamples == 1);
4030            m_actionRemoveSample->property_enabled() = (n);
4031            m_actionReplaceSample->property_enabled() = (nSamples == 1);
4032    #else
4033          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/SampleProperties"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/SampleProperties"))->
4034              set_sensitive(group_selected || sample_selected);              set_sensitive(n == 1);
4035          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddSample"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddSample"))->
4036              set_sensitive(group_selected || sample_selected);              set_sensitive(n);
4037          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddGroup"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/AddGroup"))->
4038              set_sensitive(file);              set_sensitive(file);
4039          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/ShowSampleRefs"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/ShowSampleRefs"))->
4040              set_sensitive(sample_selected);              set_sensitive(nSamples == 1);
4041          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/RemoveSample"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/SamplePopupMenu/RemoveSample"))->
4042              set_sensitive(group_selected || sample_selected);              set_sensitive(n);
4043    #endif
4044          // show sample popup          // show sample popup
4045          sample_popup->popup(button->button, button->time);          sample_popup->popup(button->button, button->time);
4046    
4047    #if !USE_GTKMM_BUILDER
4048          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/SampleProperties"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/SampleProperties"))->
4049              set_sensitive(group_selected || sample_selected);              set_sensitive(n == 1);
4050          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddSample"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddSample"))->
4051              set_sensitive(group_selected || sample_selected);              set_sensitive(n);
4052          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddGroup"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/AddGroup"))->
4053              set_sensitive(file);              set_sensitive(file);
4054          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/ShowSampleRefs"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/ShowSampleRefs"))->
4055              set_sensitive(sample_selected);              set_sensitive(nSamples == 1);
4056          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/RemoveSample"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuSample/RemoveSample"))->
4057              set_sensitive(group_selected || sample_selected);              set_sensitive(n);
4058    #endif
4059      }      }
4060        
4061    #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
4062        return false;
4063    #endif
4064  }  }
4065    
4066    #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
4067    bool MainWindow::on_script_treeview_button_release(Gdk::EventButton& _button) {
4068        GdkEventButton* button = _button.gobj();
4069    #else
4070  void MainWindow::on_script_treeview_button_release(GdkEventButton* button) {  void MainWindow::on_script_treeview_button_release(GdkEventButton* button) {
4071    #endif
4072      if (button->type == GDK_BUTTON_PRESS && button->button == 3) {      if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
4073    #if !USE_GTKMM_BUILDER
4074          Gtk::Menu* script_popup =          Gtk::Menu* script_popup =
4075              dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/ScriptPopupMenu"));              dynamic_cast<Gtk::Menu*>(uiManager->get_widget("/ScriptPopupMenu"));
4076    #endif
4077          // update enabled/disabled state of sample popup items          // update enabled/disabled state of sample popup items
4078          Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();          Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewScripts.get_selection();
4079          Gtk::TreeModel::iterator it = sel->get_selected();          Gtk::TreeModel::iterator it = sel->get_selected();
# Line 1765  void MainWindow::on_script_treeview_butt Line 4084  void MainWindow::on_script_treeview_butt
4084              group_selected  = row[m_ScriptsModel.m_col_group];              group_selected  = row[m_ScriptsModel.m_col_group];
4085              script_selected = row[m_ScriptsModel.m_col_script];              script_selected = row[m_ScriptsModel.m_col_script];
4086          }          }
4087    #if USE_GTKMM_BUILDER
4088            m_actionAddScript->property_enabled() = (group_selected || script_selected);
4089            m_actionAddScriptGroup->property_enabled() = (file);
4090            m_actionEditScript->property_enabled() = (script_selected);
4091            m_actionRemoveScript->property_enabled() = (group_selected || script_selected);
4092    #else
4093          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScript"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScript"))->
4094              set_sensitive(group_selected || script_selected);              set_sensitive(group_selected || script_selected);
4095          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScriptGroup"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/AddScriptGroup"))->
# Line 1773  void MainWindow::on_script_treeview_butt Line 4098  void MainWindow::on_script_treeview_butt
4098              set_sensitive(script_selected);                  set_sensitive(script_selected);    
4099          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/RemoveScript"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/ScriptPopupMenu/RemoveScript"))->
4100              set_sensitive(group_selected || script_selected);              set_sensitive(group_selected || script_selected);
4101    #endif
4102          // show sample popup          // show sample popup
4103          script_popup->popup(button->button, button->time);          script_popup->popup(button->button, button->time);
4104    
4105    #if !USE_GTKMM_BUILDER
4106          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScript"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScript"))->
4107              set_sensitive(group_selected || script_selected);              set_sensitive(group_selected || script_selected);
4108          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScriptGroup"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/AddScriptGroup"))->
# Line 1784  void MainWindow::on_script_treeview_butt Line 4111  void MainWindow::on_script_treeview_butt
4111              set_sensitive(script_selected);                  set_sensitive(script_selected);    
4112          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/RemoveScript"))->          dynamic_cast<Gtk::MenuItem*>(uiManager->get_widget("/MenuBar/MenuScript/RemoveScript"))->
4113              set_sensitive(group_selected || script_selected);              set_sensitive(group_selected || script_selected);
4114    #endif
4115        }
4116    #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
4117        return false;
4118    #endif
4119    }
4120    
4121    void MainWindow::updateScriptListOfMenu() {
4122        // remove all entries from "Assign Script" menu
4123        {
4124            const std::vector<Gtk::Widget*> children = assign_scripts_menu->get_children();
4125            for (int i = 0; i < children.size(); ++i) {
4126                Gtk::Widget* child = children[i];
4127                assign_scripts_menu->remove(*child);
4128                delete child;
4129            }
4130        }
4131    
4132        int iTotalScripts = 0;
4133    
4134        if (!file) goto noScripts;
4135    
4136        // add all configured macros as menu items to the "Macro" menu
4137        for (int iGroup = 0; file->GetScriptGroup(iGroup); ++iGroup) {
4138            gig::ScriptGroup* pGroup = file->GetScriptGroup(iGroup);
4139            for (int iScript = 0; pGroup->GetScript(iScript); ++iScript, ++iTotalScripts) {
4140                gig::Script* pScript = pGroup->GetScript(iScript);
4141                std::string name = pScript->Name;
4142    
4143                Gtk::MenuItem* item = new Gtk::MenuItem(name);
4144                item->signal_activate().connect(
4145                    sigc::bind(
4146                        sigc::mem_fun(*this, &MainWindow::assignScript), pScript
4147                    )
4148                );
4149                assign_scripts_menu->append(*item);
4150                item->set_accel_path("<Scripts>/script_" + ToString(iTotalScripts));
4151                //item->set_tooltip_text(comment);
4152            }
4153        }
4154    
4155        noScripts:
4156    
4157        // if there are no macros configured at all, then show a dummy entry instead
4158        if (!iTotalScripts) {
4159            Gtk::MenuItem* item = new Gtk::MenuItem(_("No Scripts"));
4160            item->set_sensitive(false);
4161            assign_scripts_menu->append(*item);
4162      }      }
4163    
4164        // add separator line to menu
4165        assign_scripts_menu->append(*new Gtk::SeparatorMenuItem);
4166    
4167        {
4168            Gtk::MenuItem* item = new Gtk::MenuItem(_("Unassign All Scripts"));
4169            item->signal_activate().connect(
4170                sigc::mem_fun(*this, &MainWindow::dropAllScriptSlots)
4171            );
4172            assign_scripts_menu->append(*item);
4173            item->set_accel_path("<Scripts>/DropAllScriptSlots");
4174        }
4175    
4176    #if HAS_GTKMM_SHOW_ALL_CHILDREN
4177        assign_scripts_menu->show_all_children();
4178    #endif
4179  }  }
4180    
4181    #if !USE_GTKMM_BUILDER
4182  Gtk::RadioMenuItem* MainWindow::add_instrument_to_menu(  Gtk::RadioMenuItem* MainWindow::add_instrument_to_menu(
4183      const Glib::ustring& name, int position) {      const Glib::ustring& name, int position) {
4184    
# Line 1810  Gtk::RadioMenuItem* MainWindow::add_inst Line 4202  Gtk::RadioMenuItem* MainWindow::add_inst
4202              item));              item));
4203      return item;      return item;
4204  }  }
4205    #endif
4206    
4207    #if !USE_GTKMM_BUILDER
4208  void MainWindow::remove_instrument_from_menu(int index) {  void MainWindow::remove_instrument_from_menu(int index) {
4209      const std::vector<Gtk::Widget*> children =      const std::vector<Gtk::Widget*> children =
4210          instrument_menu->get_children();          instrument_menu->get_children();
# Line 1818  void MainWindow::remove_instrument_from_ Line 4212  void MainWindow::remove_instrument_from_
4212      instrument_menu->remove(*child);      instrument_menu->remove(*child);
4213      delete child;      delete child;
4214  }  }
4215    #endif
4216    
4217  void MainWindow::add_instrument(gig::Instrument* instrument) {  void MainWindow::add_instrument(gig::Instrument* instrument) {
4218      const Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));      const Glib::ustring name(gig_to_utf8(instrument->pInfo->Name));
# Line 1826  void MainWindow::add_instrument(gig::Ins Line 4221  void MainWindow::add_instrument(gig::Ins
4221      instrument_name_connection.block();      instrument_name_connection.block();
4222      Gtk::TreeModel::iterator iterInstr = m_refTreeModel->append();      Gtk::TreeModel::iterator iterInstr = m_refTreeModel->append();
4223      Gtk::TreeModel::Row rowInstr = *iterInstr;      Gtk::TreeModel::Row rowInstr = *iterInstr;
4224        const int index = m_refTreeModel->children().size() - 1;
4225        rowInstr[m_Columns.m_col_nr] = index;
4226      rowInstr[m_Columns.m_col_name] = name;      rowInstr[m_Columns.m_col_name] = name;
4227      rowInstr[m_Columns.m_col_instr] = instrument;      rowInstr[m_Columns.m_col_instr] = instrument;
4228        rowInstr[m_Columns.m_col_scripts] = "";
4229        rowInstr[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
4230      instrument_name_connection.unblock();      instrument_name_connection.unblock();
4231    
4232    #if !USE_GTKMM_BUILDER
4233      add_instrument_to_menu(name);      add_instrument_to_menu(name);
4234    #endif
4235      m_TreeView.get_selection()->select(iterInstr);      select_instrument(instrument);
   
4236      file_changed();      file_changed();
4237  }  }
4238    
# Line 1854  void MainWindow::on_action_duplicate_ins Line 4253  void MainWindow::on_action_duplicate_ins
4253      // retrieve the currently selected instrument      // retrieve the currently selected instrument
4254      // (being the original instrument to be duplicated)      // (being the original instrument to be duplicated)
4255      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
4256      Gtk::TreeModel::iterator itSelection = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4257      if (!itSelection) return;      for (int r = 0; r < rows.size(); ++r) {
4258      Gtk::TreeModel::Row row = *itSelection;          Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
4259      gig::Instrument* instrOrig = row[m_Columns.m_col_instr];          if (it) {
4260      if (!instrOrig) return;              Gtk::TreeModel::Row row = *it;
4261                gig::Instrument* instrOrig = row[m_Columns.m_col_instr];
4262      // duplicate the orginal instrument              if (instrOrig) {
4263      gig::Instrument* instrNew = file->AddDuplicateInstrument(instrOrig);                  // duplicate the orginal instrument
4264      instrNew->pInfo->Name =                  gig::Instrument* instrNew = file->AddDuplicateInstrument(instrOrig);
4265          instrOrig->pInfo->Name +                  instrNew->pInfo->Name =
4266          gig_from_utf8(Glib::ustring(" (") + _("Copy") + ")");                      instrOrig->pInfo->Name +
4267                        gig_from_utf8(Glib::ustring(" (") + _("Copy") + ")");
4268    
4269      add_instrument(instrNew);                  add_instrument(instrNew);
4270                }
4271            }
4272        }
4273  }  }
4274    
4275  void MainWindow::on_action_remove_instrument() {  void MainWindow::on_action_remove_instrument() {
# Line 1883  void MainWindow::on_action_remove_instru Line 4286  void MainWindow::on_action_remove_instru
4286      }      }
4287    
4288      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
4289      Gtk::TreeModel::iterator it = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4290      if (it) {      for (int r = rows.size() - 1; r >= 0; --r) {
4291            Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
4292            if (!it) continue;
4293          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
4294          gig::Instrument* instr = row[m_Columns.m_col_instr];          gig::Instrument* instr = row[m_Columns.m_col_instr];
4295          try {          try {
# Line 1895  void MainWindow::on_action_remove_instru Line 4300  void MainWindow::on_action_remove_instru
4300              if (instr) file->DeleteInstrument(instr);              if (instr) file->DeleteInstrument(instr);
4301              file_changed();              file_changed();
4302    
4303    #if !USE_GTKMM_BUILDER
4304              remove_instrument_from_menu(index);              remove_instrument_from_menu(index);
4305    #endif
4306    
4307              // remove row from instruments tree view              // remove row from instruments tree view
4308              m_refTreeModel->erase(it);              m_refTreeModel->erase(it);
4309                // update "Nr" column of all instrument rows
4310                {
4311                    int index = 0;
4312                    for (Gtk::TreeModel::iterator it = m_refTreeModel->children().begin();
4313                         it != m_refTreeModel->children().end(); ++it, ++index)
4314                    {
4315                        Gtk::TreeModel::Row row = *it;
4316                        gig::Instrument* instrument = row[m_Columns.m_col_instr];
4317                        row[m_Columns.m_col_nr] = index;
4318                        row[m_Columns.m_col_tooltip] = scriptTooltipFor(instrument, index);
4319                    }
4320                }
4321    
4322  #if GTKMM_MAJOR_VERSION < 3  #if GTKMM_MAJOR_VERSION < 3
4323              // select another instrument (in gtk3 this is done              // select another instrument (in gtk3 this is done
# Line 1926  void MainWindow::on_action_remove_instru Line 4345  void MainWindow::on_action_remove_instru
4345  }  }
4346    
4347  void MainWindow::on_action_sample_properties() {  void MainWindow::on_action_sample_properties() {
4348      //TODO: show a dialog where the selected sample's properties can be edited      show_sample_props();
     Gtk::MessageDialog msg(  
         *this, _("Sorry, yet to be implemented!"), false, Gtk::MESSAGE_INFO  
     );  
     msg.run();  
4349  }  }
4350    
4351  void MainWindow::on_action_add_script_group() {  void MainWindow::on_action_add_script_group() {
# Line 1996  void MainWindow::on_action_edit_script() Line 4411  void MainWindow::on_action_edit_script()
4411      if (!script) return;      if (!script) return;
4412    
4413      ScriptEditor* editor = new ScriptEditor;      ScriptEditor* editor = new ScriptEditor;
4414        editor->signal_script_to_be_changed.connect(
4415            signal_script_to_be_changed.make_slot()
4416        );
4417        editor->signal_script_changed.connect(
4418            signal_script_changed.make_slot()
4419        );
4420      editor->setScript(script);      editor->setScript(script);
4421      //editor->reparent(*this);      //editor->reparent(*this);
4422      editor->show();      editor->show();
# Line 2061  void MainWindow::on_action_add_group() { Line 4482  void MainWindow::on_action_add_group() {
4482      file_changed();      file_changed();
4483  }  }
4484    
4485    void MainWindow::on_action_replace_sample() {
4486        add_or_replace_sample(true);
4487    }
4488    
4489  void MainWindow::on_action_add_sample() {  void MainWindow::on_action_add_sample() {
4490        add_or_replace_sample(false);
4491    }
4492    
4493    void MainWindow::add_or_replace_sample(bool replace) {
4494      if (!file) return;      if (!file) return;
4495      // get selected group  
4496        // get selected group (and probably selected sample)
4497      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4498      Gtk::TreeModel::iterator it = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4499        if (rows.empty()) return;
4500        Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
4501      if (!it) return;      if (!it) return;
4502      Gtk::TreeModel::Row row = *it;      Gtk::TreeModel::Row row = *it;
4503        gig::Sample* sample = NULL;
4504      gig::Group* group = row[m_SamplesModel.m_col_group];      gig::Group* group = row[m_SamplesModel.m_col_group];
4505      if (!group) { // not a group, but a sample is selected (probably)      if (!group) { // not a group, but a sample is selected (probably)
4506          gig::Sample* sample = row[m_SamplesModel.m_col_sample];          if (replace) sample = row[m_SamplesModel.m_col_sample];
4507          if (!sample) return;          if (!row[m_SamplesModel.m_col_sample]) return;
4508          it = row.parent(); // resolve parent (that is the sample's group)          it = row.parent(); // resolve parent (that is the sample's group)
4509          if (!it) return;          if (!it) return;
4510          row = *it;          if (!replace) row = *it;
4511          group = row[m_SamplesModel.m_col_group];          group = (*it)[m_SamplesModel.m_col_group];
4512          if (!group) return;          if (!group) return;
4513      }      }
4514        if (replace && !sample) return;
4515    
4516      // show 'browse for file' dialog      // show 'browse for file' dialog
4517      Gtk::FileChooserDialog dialog(*this, _("Add Sample(s)"));      Gtk::FileChooserDialog dialog(*this, replace ? _("Replace Sample with") : _("Add Sample(s)"));
4518    #if HAS_GTKMM_STOCK
4519      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4520      dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);      dialog.add_button(Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
4521      dialog.set_select_multiple(true);  #else
4522        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4523        dialog.add_button(_("_Open"), Gtk::RESPONSE_OK);
4524    #endif
4525        dialog.set_select_multiple(!replace); // allow multi audio file selection only when adding new samples, does not make sense when replacing a specific sample
4526    
4527      // matches all file types supported by libsndfile      // matches all file types supported by libsndfile
4528  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
# Line 2124  void MainWindow::on_action_add_sample() Line 4564  void MainWindow::on_action_add_sample()
4564          dialog.set_current_folder(current_sample_dir);          dialog.set_current_folder(current_sample_dir);
4565      }      }
4566      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
4567            dialog.hide();
4568          current_sample_dir = dialog.get_current_folder();          current_sample_dir = dialog.get_current_folder();
4569          Glib::ustring error_files;          Glib::ustring error_files;
4570          std::vector<std::string> filenames = dialog.get_filenames();          std::vector<std::string> filenames = dialog.get_filenames();
4571          for (std::vector<std::string>::iterator iter = filenames.begin();          for (std::vector<std::string>::iterator iter = filenames.begin();
4572               iter != filenames.end(); ++iter) {               iter != filenames.end(); ++iter) {
4573              printf("Adding sample %s\n",(*iter).c_str());              printf("Adding sample %s\n",(*iter).c_str());
4574              // use libsndfile to retrieve file informations              // use libsndfile to retrieve file information
4575              SF_INFO info;              SF_INFO info;
4576              info.format = 0;              info.format = 0;
4577              SNDFILE* hFile = sf_open((*iter).c_str(), SFM_READ, &info);              SNDFILE* hFile = sf_open((*iter).c_str(), SFM_READ, &info);
# Line 2153  void MainWindow::on_action_add_sample() Line 4594  void MainWindow::on_action_add_sample()
4594                          sf_close(hFile); // close sound file                          sf_close(hFile); // close sound file
4595                          throw std::string(_("format not supported")); // unsupported subformat (yet?)                          throw std::string(_("format not supported")); // unsupported subformat (yet?)
4596                  }                  }
4597                  // add a new sample to the .gig file                  // add a new sample to the .gig file (if adding is requested actually)
4598                  gig::Sample* sample = file->AddSample();                  if (!replace) sample = file->AddSample();
4599                  // file name without path                  // file name without path
4600                  Glib::ustring filename = Glib::filename_display_basename(*iter);                  Glib::ustring filename = Glib::filename_display_basename(*iter);
4601                  // remove file extension if there is one                  // remove file extension if there is one
# Line 2205  void MainWindow::on_action_add_sample() Line 4646  void MainWindow::on_action_add_sample()
4646                  // physically when File::Save() is called)                  // physically when File::Save() is called)
4647                  sample->Resize(info.frames);                  sample->Resize(info.frames);
4648                  // make sure sample is part of the selected group                  // make sure sample is part of the selected group
4649                  group->AddSample(sample);                  if (!replace) group->AddSample(sample);
4650                  // schedule that physical resize and sample import                  // schedule that physical resize and sample import
4651                  // (data copying), performed when "Save" is requested                  // (data copying), performed when "Save" is requested
4652                  SampleImportItem sched_item;                  SampleImportItem sched_item;
4653                  sched_item.gig_sample  = sample;                  sched_item.gig_sample  = sample;
4654                  sched_item.sample_path = *iter;                  sched_item.sample_path = *iter;
4655                  m_SampleImportQueue.push_back(sched_item);                  m_SampleImportQueue[sample] = sched_item;
4656                  // add sample to the tree view                  // add sample to the tree view
4657                  Gtk::TreeModel::iterator iterSample =                  if (replace) {
4658                      m_refSamplesTreeModel->append(row.children());                      row[m_SamplesModel.m_col_name] = gig_to_utf8(sample->pInfo->Name);
4659                  Gtk::TreeModel::Row rowSample = *iterSample;                  } else {
4660                  rowSample[m_SamplesModel.m_col_name] =                      Gtk::TreeModel::iterator iterSample =
4661                      gig_to_utf8(sample->pInfo->Name);                          m_refSamplesTreeModel->append(row.children());
4662                  rowSample[m_SamplesModel.m_col_sample] = sample;                      Gtk::TreeModel::Row rowSample = *iterSample;
4663                  rowSample[m_SamplesModel.m_col_group]  = NULL;                      rowSample[m_SamplesModel.m_col_name] =
4664                            gig_to_utf8(sample->pInfo->Name);
4665                        rowSample[m_SamplesModel.m_col_sample] = sample;
4666                        rowSample[m_SamplesModel.m_col_group]  = NULL;
4667                    }
4668                  // close sound file                  // close sound file
4669                  sf_close(hFile);                  sf_close(hFile);
4670                  file_changed();                  file_changed();
# Line 2230  void MainWindow::on_action_add_sample() Line 4675  void MainWindow::on_action_add_sample()
4675          }          }
4676          // show error message box when some file(s) could not be opened / added          // show error message box when some file(s) could not be opened / added
4677          if (!error_files.empty()) {          if (!error_files.empty()) {
4678              Glib::ustring txt = _("Could not add the following sample(s):\n") + error_files;              Glib::ustring txt =
4679                    (replace
4680                        ? _("Failed to replace sample with:\n")
4681                        : _("Could not add the following sample(s):\n"))
4682                    + error_files;
4683              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);              Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
4684              msg.run();              msg.run();
4685          }          }
# Line 2263  void MainWindow::on_action_replace_all_s Line 4712  void MainWindow::on_action_replace_all_s
4712      Gtk::Label description(str);      Gtk::Label description(str);
4713      description.set_line_wrap();      description.set_line_wrap();
4714  #endif  #endif
4715      Gtk::HBox entryArea;      HBox entryArea;
4716      Gtk::Label entryLabel( _("Add filename extension: "), Gtk::ALIGN_START);      Gtk::Label entryLabel( _("Add filename extension: "), Gtk::ALIGN_START);
4717      Gtk::Entry postfixEntryBox;      Gtk::Entry postfixEntryBox;
4718      postfixEntryBox.set_text(".wav");      postfixEntryBox.set_text(".wav");
4719      entryArea.pack_start(entryLabel);      entryArea.pack_start(entryLabel);
4720      entryArea.pack_start(postfixEntryBox);      entryArea.pack_start(postfixEntryBox);
4721    #if USE_GTKMM_BOX
4722        dialog.get_content_area()->pack_start(description, Gtk::PACK_SHRINK);
4723        dialog.get_content_area()->pack_start(entryArea, Gtk::PACK_SHRINK);
4724    #else
4725      dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);      dialog.get_vbox()->pack_start(description, Gtk::PACK_SHRINK);
4726      dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);      dialog.get_vbox()->pack_start(entryArea, Gtk::PACK_SHRINK);
4727    #endif
4728      description.show();      description.show();
4729    
4730    #if HAS_GTKMM_SHOW_ALL_CHILDREN
4731      entryArea.show_all();      entryArea.show_all();
4732    #else
4733        entryArea.show();
4734    #endif
4735    
4736    #if HAS_GTKMM_STOCK
4737      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
4738    #else
4739        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
4740    #endif
4741      dialog.add_button(_("Select"), Gtk::RESPONSE_OK);      dialog.add_button(_("Select"), Gtk::RESPONSE_OK);
4742      dialog.set_select_multiple(false);      dialog.set_select_multiple(false);
4743      if (current_sample_dir != "") {      if (current_sample_dir != "") {
# Line 2281  void MainWindow::on_action_replace_all_s Line 4745  void MainWindow::on_action_replace_all_s
4745      }      }
4746      if (dialog.run() == Gtk::RESPONSE_OK)      if (dialog.run() == Gtk::RESPONSE_OK)
4747      {      {
4748            dialog.hide();
4749          current_sample_dir = dialog.get_current_folder();          current_sample_dir = dialog.get_current_folder();
4750          Glib::ustring error_files;          Glib::ustring error_files;
4751          std::string folder = dialog.get_filename();          std::string folder = dialog.get_filename();
# Line 2297  void MainWindow::on_action_replace_all_s Line 4762  void MainWindow::on_action_replace_all_s
4762              try              try
4763              {              {
4764                  if (!hFile) throw std::string(_("could not open file"));                  if (!hFile) throw std::string(_("could not open file"));
                 int bitdepth;  
4765                  switch (info.format & 0xff) {                  switch (info.format & 0xff) {
4766                      case SF_FORMAT_PCM_S8:                      case SF_FORMAT_PCM_S8:
4767                      case SF_FORMAT_PCM_16:                      case SF_FORMAT_PCM_16:
4768                      case SF_FORMAT_PCM_U8:                      case SF_FORMAT_PCM_U8:
                         bitdepth = 16;  
                         break;  
4769                      case SF_FORMAT_PCM_24:                      case SF_FORMAT_PCM_24:
4770                      case SF_FORMAT_PCM_32:                      case SF_FORMAT_PCM_32:
4771                      case SF_FORMAT_FLOAT:                      case SF_FORMAT_FLOAT:
4772                      case SF_FORMAT_DOUBLE:                      case SF_FORMAT_DOUBLE:
                         bitdepth = 24;  
4773                          break;                          break;
4774                      default:                      default:
4775                          sf_close(hFile);                          sf_close(hFile);
# Line 2317  void MainWindow::on_action_replace_all_s Line 4778  void MainWindow::on_action_replace_all_s
4778                  SampleImportItem sched_item;                  SampleImportItem sched_item;
4779                  sched_item.gig_sample  = sample;                  sched_item.gig_sample  = sample;
4780                  sched_item.sample_path = filename;                  sched_item.sample_path = filename;
4781                  m_SampleImportQueue.push_back(sched_item);                  m_SampleImportQueue[sample] = sched_item;
4782                  sf_close(hFile);                  sf_close(hFile);
4783                  file_changed();                  file_changed();
4784              }              }
# Line 2341  void MainWindow::on_action_replace_all_s Line 4802  void MainWindow::on_action_replace_all_s
4802  void MainWindow::on_action_remove_sample() {  void MainWindow::on_action_remove_sample() {
4803      if (!file) return;      if (!file) return;
4804      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
4805      Gtk::TreeModel::iterator it = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4806      if (it) {      for (int r = rows.size() - 1; r >= 0; --r) {
4807            Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[r]);
4808            if (!it) continue;
4809          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::Row row = *it;
4810          gig::Group* group   = row[m_SamplesModel.m_col_group];          gig::Group* group   = row[m_SamplesModel.m_col_group];
4811          gig::Sample* sample = row[m_SamplesModel.m_col_sample];          gig::Sample* sample = row[m_SamplesModel.m_col_sample];
# Line 2367  void MainWindow::on_action_remove_sample Line 4830  void MainWindow::on_action_remove_sample
4830                  // if sample(s) were just previously added, remove                  // if sample(s) were just previously added, remove
4831                  // them from the import queue                  // them from the import queue
4832                  for (std::list<gig::Sample*>::iterator member = members.begin();                  for (std::list<gig::Sample*>::iterator member = members.begin();
4833                       member != members.end(); ++member) {                       member != members.end(); ++member)
4834                      for (std::list<SampleImportItem>::iterator iter = m_SampleImportQueue.begin();                  {
4835                           iter != m_SampleImportQueue.end(); ++iter) {                      if (m_SampleImportQueue.count(*member)) {
4836                          if ((*iter).gig_sample == *member) {                          printf("Removing previously added sample '%s' from group '%s'\n",
4837                              printf("Removing previously added sample '%s' from group '%s'\n",                                 m_SampleImportQueue[sample].sample_path.c_str(), name.c_str());
4838                                     (*iter).sample_path.c_str(), name.c_str());                          m_SampleImportQueue.erase(*member);
                             m_SampleImportQueue.erase(iter);  
                             break;  
                         }  
4839                      }                      }
4840                  }                  }
4841                  file_changed();                  file_changed();
# Line 2390  void MainWindow::on_action_remove_sample Line 4850  void MainWindow::on_action_remove_sample
4850                  samples_removed_signal.emit();                  samples_removed_signal.emit();
4851                  // if sample was just previously added, remove it from                  // if sample was just previously added, remove it from
4852                  // the import queue                  // the import queue
4853                  for (std::list<SampleImportItem>::iterator iter = m_SampleImportQueue.begin();                  if (m_SampleImportQueue.count(sample)) {
4854                       iter != m_SampleImportQueue.end(); ++iter) {                      printf("Removing previously added sample '%s'\n",
4855                      if ((*iter).gig_sample == sample) {                             m_SampleImportQueue[sample].sample_path.c_str());
4856                          printf("Removing previously added sample '%s'\n",                      m_SampleImportQueue.erase(sample);
                                (*iter).sample_path.c_str());  
                         m_SampleImportQueue.erase(iter);  
                         break;  
                     }  
4857                  }                  }
4858                  dimreg_changed();                  dimreg_changed();
4859                  file_changed();                  file_changed();
# Line 2414  void MainWindow::on_action_remove_sample Line 4870  void MainWindow::on_action_remove_sample
4870      }      }
4871  }  }
4872    
4873    void MainWindow::on_action_remove_unused_samples() {
4874        if (!file) return;
4875    
4876        // collect all samples that are not referenced by any instrument
4877        std::list<gig::Sample*> lsamples;
4878        for (int iSample = 0; file->GetSample(iSample); ++iSample) {
4879            gig::Sample* sample = file->GetSample(iSample);
4880            bool isUsed = false;
4881            for (gig::Instrument* instrument = file->GetFirstInstrument(); instrument;
4882                                  instrument = file->GetNextInstrument())
4883            {
4884                for (gig::Region* rgn = instrument->GetFirstRegion(); rgn;
4885                                  rgn = instrument->GetNextRegion())
4886                {
4887                    for (int i = 0; i < 256; ++i) {
4888                        if (!rgn->pDimensionRegions[i]) continue;
4889                        if (rgn->pDimensionRegions[i]->pSample != sample) continue;
4890                        isUsed = true;
4891                        goto endOfRefSearch;
4892                    }
4893                }
4894            }
4895            endOfRefSearch:
4896            if (!isUsed) lsamples.push_back(sample);
4897        }
4898    
4899        if (lsamples.empty()) return;
4900    
4901        // notify everybody that we're going to remove these samples
4902        samples_to_be_removed_signal.emit(lsamples);
4903    
4904        // remove collected samples
4905        try {
4906            for (std::list<gig::Sample*>::iterator itSample = lsamples.begin();
4907                 itSample != lsamples.end(); ++itSample)
4908            {
4909                gig::Sample* sample = *itSample;
4910                // remove sample from the .gig file
4911                file->DeleteSample(sample);
4912                // if sample was just previously added, remove it from the import queue
4913                if (m_SampleImportQueue.count(sample)) {
4914                    printf("Removing previously added sample '%s'\n",
4915                           m_SampleImportQueue[sample].sample_path.c_str());
4916                    m_SampleImportQueue.erase(sample);
4917                }
4918            }
4919        } catch (RIFF::Exception e) {
4920            // show error message
4921            Gtk::MessageDialog msg(*this, e.Message.c_str(), false, Gtk::MESSAGE_ERROR);
4922            msg.run();
4923        }
4924    
4925        // notify everybody that we're done with removal
4926        samples_removed_signal.emit();
4927    
4928        dimreg_changed();
4929        file_changed();
4930        __refreshEntireGUI();
4931    }
4932    
4933  // see comment on on_sample_treeview_drag_begin()  // see comment on on_sample_treeview_drag_begin()
4934  void MainWindow::on_scripts_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)  void MainWindow::on_scripts_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
4935  {  {
# Line 2440  void MainWindow::on_scripts_treeview_dra Line 4956  void MainWindow::on_scripts_treeview_dra
4956                         sizeof(script)/*length of data in bytes*/);                         sizeof(script)/*length of data in bytes*/);
4957  }  }
4958    
4959    // see comment on on_sample_treeview_drag_begin()
4960    void MainWindow::on_instruments_treeview_drag_begin(const Glib::RefPtr<Gdk::DragContext>& context)
4961    {
4962        first_call_to_drag_data_get = true;
4963    }
4964    
4965    void MainWindow::on_instruments_treeview_drag_data_get(const Glib::RefPtr<Gdk::DragContext>&,
4966                                                           Gtk::SelectionData& selection_data, guint, guint)
4967    {
4968        if (!first_call_to_drag_data_get) return;
4969        first_call_to_drag_data_get = false;
4970    
4971        // get selected source instrument
4972        gig::Instrument* src = NULL;
4973        {
4974            Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
4975            std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
4976            if (!rows.empty()) {
4977                Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[0]);
4978                if (it) {
4979                    Gtk::TreeModel::Row row = *it;
4980                    src = row[m_Columns.m_col_instr];
4981                }
4982            }
4983        }
4984        if (!src) return;
4985    
4986        // pass the source gig::Instrument as pointer
4987        selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&src,
4988                           sizeof(src)/*length of data in bytes*/);
4989    }
4990    
4991    void MainWindow::on_instruments_treeview_drop_drag_data_received(
4992        const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
4993        const Gtk::SelectionData& selection_data, guint, guint time)
4994    {
4995        gig::Instrument* src = *((gig::Instrument**) selection_data.get_data());
4996        if (!src || selection_data.get_length() != sizeof(gig::Instrument*))
4997            return;
4998    
4999        gig::Instrument* dst = NULL;
5000        {
5001            Gtk::TreeModel::Path path;
5002            const bool found = m_TreeView.get_path_at_pos(x, y, path);
5003            if (!found) return;
5004    
5005            Gtk::TreeModel::iterator iter = m_refTreeModel->get_iter(path);
5006            if (!iter) return;
5007            Gtk::TreeModel::Row row = *iter;
5008            dst = row[m_Columns.m_col_instr];
5009        }
5010        if (!dst) return;
5011    
5012        //printf("dragdrop received src=%s dst=%s\n", src->pInfo->Name.c_str(), dst->pInfo->Name.c_str());
5013        src->MoveTo(dst);
5014        __refreshEntireGUI();
5015        select_instrument(src);
5016    }
5017    
5018  // For some reason drag_data_get gets called two times for each  // For some reason drag_data_get gets called two times for each
5019  // drag'n'drop (at least when target is an Entry). This work-around  // drag'n'drop (at least when target is an Entry). This work-around
5020  // makes sure the code in drag_data_get and drop_drag_data_received is  // makes sure the code in drag_data_get and drop_drag_data_received is
# Line 2458  void MainWindow::on_sample_treeview_drag Line 5033  void MainWindow::on_sample_treeview_drag
5033      // get selected sample      // get selected sample
5034      gig::Sample* sample = NULL;      gig::Sample* sample = NULL;
5035      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5036      Gtk::TreeModel::iterator it = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5037      if (it) {      if (!rows.empty()) {
5038          Gtk::TreeModel::Row row = *it;          Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5039          sample = row[m_SamplesModel.m_col_sample];          if (it) {
5040                Gtk::TreeModel::Row row = *it;
5041                sample = row[m_SamplesModel.m_col_sample];
5042            }
5043      }      }
5044      // pass the gig::Sample as pointer      // pass the gig::Sample as pointer
5045      selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&sample,      selection_data.set(selection_data.get_target(), 0/*unused*/, (const guchar*)&sample,
# Line 2566  void MainWindow::sample_name_changed(con Line 5144  void MainWindow::sample_name_changed(con
5144              file_changed();              file_changed();
5145          }          }
5146      }      }
5147        // change name in the sample properties window
5148        if (sampleProps.get_sample() == sample && sample) {
5149            sampleProps.set_sample(sample);
5150        }
5151  }  }
5152    
5153  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
# Line 2601  void MainWindow::script_double_clicked(c Line 5183  void MainWindow::script_double_clicked(c
5183      if (!script) return;      if (!script) return;
5184    
5185      ScriptEditor* editor = new ScriptEditor;      ScriptEditor* editor = new ScriptEditor;
5186        editor->signal_script_to_be_changed.connect(
5187            signal_script_to_be_changed.make_slot()
5188        );
5189        editor->signal_script_changed.connect(
5190            signal_script_changed.make_slot()
5191        );
5192      editor->setScript(script);      editor->setScript(script);
5193      //editor->reparent(*this);      //editor->reparent(*this);
5194      editor->show();      editor->show();
# Line 2612  void MainWindow::instrument_name_changed Line 5200  void MainWindow::instrument_name_changed
5200      Gtk::TreeModel::Row row = *iter;      Gtk::TreeModel::Row row = *iter;
5201      Glib::ustring name = row[m_Columns.m_col_name];      Glib::ustring name = row[m_Columns.m_col_name];
5202    
5203    #if !USE_GTKMM_BUILDER
5204      // change name in instrument menu      // change name in instrument menu
5205      int index = path[0];      int index = path[0];
5206      const std::vector<Gtk::Widget*> children = instrument_menu->get_children();      const std::vector<Gtk::Widget*> children = instrument_menu->get_children();
# Line 2624  void MainWindow::instrument_name_changed Line 5213  void MainWindow::instrument_name_changed
5213          item->set_active();          item->set_active();
5214  #endif  #endif
5215      }      }
5216    #endif
5217    
5218      // change name in gig      // change name in gig
5219      gig::Instrument* instrument = row[m_Columns.m_col_instr];      gig::Instrument* instrument = row[m_Columns.m_col_instr];
# Line 2640  void MainWindow::instrument_name_changed Line 5230  void MainWindow::instrument_name_changed
5230      }      }
5231  }  }
5232    
5233    bool MainWindow::instrument_row_visible(const Gtk::TreeModel::const_iterator& iter) {
5234        if (!iter)
5235            return true;
5236    
5237        Glib::ustring pattern = m_searchText.get_text().lowercase();
5238        trim(pattern);
5239        if (pattern.empty()) return true;
5240    
5241    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
5242        //HACK: on GTKMM4 development branch const_iterator cannot be easily converted to iterator, probably going to be fixed before final GTKMM4 release though.
5243        Gtk::TreeModel::Row row = **(Gtk::TreeModel::iterator*)(&iter);
5244    #else
5245        Gtk::TreeModel::Row row = *iter;
5246    #endif
5247        Glib::ustring name = row[m_Columns.m_col_name];
5248        name = name.lowercase();
5249    
5250        std::vector<Glib::ustring> tokens = Glib::Regex::split_simple(" ", pattern);
5251        for (int t = 0; t < tokens.size(); ++t)
5252            if (name.find(tokens[t]) == Glib::ustring::npos)
5253                return false;
5254    
5255        return true;
5256    }
5257    
5258  void MainWindow::on_action_combine_instruments() {  void MainWindow::on_action_combine_instruments() {
5259      CombineInstrumentsDialog* d = new CombineInstrumentsDialog(*this, file);      CombineInstrumentsDialog* d = new CombineInstrumentsDialog(*this, file);
5260    
5261        // take over selection from instruments list view for the combine dialog's
5262        // list view as pre-selection
5263        std::set<int> indeces;
5264        {
5265            Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeView.get_selection();
5266            std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5267            for (int r = 0; r < rows.size(); ++r) {
5268                Gtk::TreeModel::iterator it = m_refTreeModel->get_iter(rows[r]);
5269                if (it) {
5270                    Gtk::TreeModel::Row row = *it;
5271                    int index = row[m_Columns.m_col_nr];
5272                    indeces.insert(index);
5273                }
5274            }
5275        }
5276        d->setSelectedInstruments(indeces);
5277    
5278    #if HAS_GTKMM_SHOW_ALL_CHILDREN
5279      d->show_all();      d->show_all();
5280      d->resize(500, 400);  #else
5281        d->show();
5282    #endif
5283      d->run();      d->run();
5284      if (d->fileWasChanged()) {      if (d->fileWasChanged()) {
5285          // update GUI with new instrument just created          // update GUI with new instrument just created
# Line 2654  void MainWindow::on_action_combine_instr Line 5290  void MainWindow::on_action_combine_instr
5290    
5291  void MainWindow::on_action_view_references() {  void MainWindow::on_action_view_references() {
5292      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();      Glib::RefPtr<Gtk::TreeSelection> sel = m_TreeViewSamples.get_selection();
5293      Gtk::TreeModel::iterator it = sel->get_selected();      std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
5294        if (rows.empty()) return;
5295        Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
5296      if (!it) return;      if (!it) return;
5297      Gtk::TreeModel::Row row = *it;      Gtk::TreeModel::Row row = *it;
5298      gig::Sample* sample = row[m_SamplesModel.m_col_sample];      gig::Sample* sample = row[m_SamplesModel.m_col_sample];
# Line 2662  void MainWindow::on_action_view_referenc Line 5300  void MainWindow::on_action_view_referenc
5300    
5301      ReferencesView* d = new ReferencesView(*this);      ReferencesView* d = new ReferencesView(*this);
5302      d->setSample(sample);      d->setSample(sample);
5303        d->dimension_region_selected.connect(
5304            sigc::mem_fun(*this, &MainWindow::select_dimension_region)
5305        );
5306    #if HAS_GTKMM_SHOW_ALL_CHILDREN
5307      d->show_all();      d->show_all();
5308    #else
5309        d->show();
5310    #endif
5311      d->resize(500, 400);      d->resize(500, 400);
5312      d->run();      d->run();
5313      delete d;      delete d;
# Line 2735  void MainWindow::mergeFiles(const std::v Line 5380  void MainWindow::mergeFiles(const std::v
5380          );          );
5381      }      }
5382    
5383      // Note: requires that this file already has a filename !      // Finally save gig file persistently to disk ...
5384      this->file->Save();      //NOTE: requires that this gig file already has a filename !
5385        {
5386            std::cout << "Saving file\n" << std::flush;
5387            file_structure_to_be_changed_signal.emit(this->file);
5388    
5389            progress_dialog = new ProgressDialog( //FIXME: memory leak!
5390                _("Saving") +  Glib::ustring(" '") +
5391                Glib::filename_display_basename(this->filename) + "' ...",
5392                *this
5393            );
5394    #if HAS_GTKMM_SHOW_ALL_CHILDREN
5395            progress_dialog->show_all();
5396    #else
5397            progress_dialog->show();
5398    #endif
5399            saver = new Saver(this->file); //FIXME: memory leak!
5400            saver->signal_progress().connect(
5401                sigc::mem_fun(*this, &MainWindow::on_saver_progress));
5402            saver->signal_finished().connect(
5403                sigc::mem_fun(*this, &MainWindow::on_saver_finished));
5404            saver->signal_error().connect(
5405                sigc::mem_fun(*this, &MainWindow::on_saver_error));
5406            saver->launch();
5407        }
5408  }  }
5409    
5410  void MainWindow::on_action_merge_files() {  void MainWindow::on_action_merge_files() {
# Line 2754  void MainWindow::on_action_merge_files() Line 5422  void MainWindow::on_action_merge_files()
5422      }      }
5423    
5424      Gtk::FileChooserDialog dialog(*this, _("Merge .gig files"));      Gtk::FileChooserDialog dialog(*this, _("Merge .gig files"));
5425    #if HAS_GTKMM_STOCK
5426      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);      dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
5427    #else
5428        dialog.add_button(_("_Cancel"), Gtk::RESPONSE_CANCEL);
5429    #endif
5430      dialog.add_button(_("Merge"), Gtk::RESPONSE_OK);      dialog.add_button(_("Merge"), Gtk::RESPONSE_OK);
5431      dialog.set_default_response(Gtk::RESPONSE_CANCEL);      dialog.set_default_response(Gtk::RESPONSE_CANCEL);
5432  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2  #if (GTKMM_MAJOR_VERSION == 2 && GTKMM_MINOR_VERSION < 90) || GTKMM_MAJOR_VERSION < 2
# Line 2771  void MainWindow::on_action_merge_files() Line 5443  void MainWindow::on_action_merge_files()
5443      dialog.set_select_multiple(true);      dialog.set_select_multiple(true);
5444    
5445      // show warning in the file picker dialog      // show warning in the file picker dialog
5446      Gtk::HBox descriptionArea;      HBox descriptionArea;
5447      descriptionArea.set_spacing(15);      descriptionArea.set_spacing(15);
5448      Gtk::Image warningIcon(Gtk::Stock::DIALOG_WARNING, Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));      Gtk::Image warningIcon;
5449        warningIcon.set_from_icon_name("dialog-warning",
5450                                       Gtk::IconSize(Gtk::ICON_SIZE_DIALOG));
5451      descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);      descriptionArea.pack_start(warningIcon, Gtk::PACK_SHRINK);
5452  #if GTKMM_MAJOR_VERSION < 3  #if GTKMM_MAJOR_VERSION < 3
5453      view::WrapLabel description;      view::WrapLabel description;
# Line 2792  void MainWindow::on_action_merge_files() Line 5466  void MainWindow::on_action_merge_files()
5466          "will accordingly be stored separately in the target .gig file!"          "will accordingly be stored separately in the target .gig file!"
5467      ));      ));
5468      descriptionArea.pack_start(description);      descriptionArea.pack_start(description);
5469    #if USE_GTKMM_BOX
5470    # warning No description area implemented for dialog on GTKMM 3
5471    #else
5472      dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);      dialog.get_vbox()->pack_start(descriptionArea, Gtk::PACK_SHRINK);
5473    #endif
5474    #if HAS_GTKMM_SHOW_ALL_CHILDREN
5475      descriptionArea.show_all();      descriptionArea.show_all();
5476    #else
5477        descriptionArea.show();
5478    #endif
5479    
5480      if (dialog.run() == Gtk::RESPONSE_OK) {      if (dialog.run() == Gtk::RESPONSE_OK) {
5481          printf("on_action_merge_files self=%x\n", Glib::Threads::Thread::self());          dialog.hide();
5482    #ifdef GLIB_THREADS
5483            printf("on_action_merge_files self=%p\n",
5484                   static_cast<void*>(Glib::Threads::Thread::self()));
5485    #else
5486            std::cout << "on_action_merge_files self=" <<
5487                std::this_thread::get_id() << "\n";
5488    #endif
5489          std::vector<std::string> filenames = dialog.get_filenames();          std::vector<std::string> filenames = dialog.get_filenames();
5490    
5491          // merge the selected files to the currently open .gig file          // merge the selected files to the currently open .gig file
# Line 2808  void MainWindow::on_action_merge_files() Line 5497  void MainWindow::on_action_merge_files()
5497          }          }
5498    
5499          // update GUI          // update GUI
5500          __refreshEntireGUI();                  __refreshEntireGUI();
5501      }      }
5502  }  }
5503    
# Line 2826  void MainWindow::set_file_is_shared(bool Line 5515  void MainWindow::set_file_is_shared(bool
5515              Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)              Gdk::Pixbuf::create_from_xpm_data(status_detached_xpm)
5516          );          );
5517      }      }
5518    
5519        {
5520    #if USE_GTKMM_BUILDER
5521            m_actionToggleSyncSamplerSelection->property_enabled() = b;
5522    #else
5523            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
5524                uiManager->get_widget("/MenuBar/MenuSettings/SyncSamplerInstrumentSelection"));
5525            if (item) item->set_sensitive(b);
5526    #endif
5527        }
5528  }  }
5529    
5530  void MainWindow::on_sample_ref_count_incremented(gig::Sample* sample, int offset) {  void MainWindow::on_sample_ref_count_incremented(gig::Sample* sample, int offset) {
# Line 2854  void MainWindow::on_samples_to_be_remove Line 5553  void MainWindow::on_samples_to_be_remove
5553      // just in case a new sample is added later with exactly the same memory      // just in case a new sample is added later with exactly the same memory
5554      // address, which would lead to incorrect refcount if not deleted here      // address, which would lead to incorrect refcount if not deleted here
5555      for (std::list<gig::Sample*>::const_iterator it = samples.begin();      for (std::list<gig::Sample*>::const_iterator it = samples.begin();
5556           it != samples.end(); it != samples.end())           it != samples.end(); ++it)
5557      {      {
5558          sample_ref_count.erase(*it);          sample_ref_count.erase(*it);
5559      }      }
# Line 2872  void MainWindow::show_scripts_tab() { Line 5571  void MainWindow::show_scripts_tab() {
5571      m_TreeViewNotebook.set_current_page(2);      m_TreeViewNotebook.set_current_page(2);
5572  }  }
5573    
5574    void MainWindow::select_instrument_by_dir(int dir) {
5575        if (!file) return;
5576        gig::Instrument* pInstrument = get_instrument();
5577        if (!pInstrument) {
5578            select_instrument( file->GetInstrument(0) );
5579            return;
5580        }
5581        for (int i = 0; file->GetInstrument(i); ++i) {
5582            if (file->GetInstrument(i) == pInstrument) {
5583                select_instrument( file->GetInstrument(i + dir) );
5584                return;
5585            }
5586        }
5587    }
5588    
5589    void MainWindow::select_prev_instrument() {
5590        select_instrument_by_dir(-1);
5591    }
5592    
5593    void MainWindow::select_next_instrument() {
5594        select_instrument_by_dir(1);
5595    }
5596    
5597    void MainWindow::select_prev_region() {
5598        m_RegionChooser.select_prev_region();
5599    }
5600    
5601    void MainWindow::select_next_region() {
5602        m_RegionChooser.select_next_region();
5603    }
5604    
5605    void MainWindow::select_next_dim_rgn_zone() {
5606        if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5607        m_DimRegionChooser.select_next_dimzone();
5608    }
5609    
5610    void MainWindow::select_prev_dim_rgn_zone() {
5611        if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5612        m_DimRegionChooser.select_prev_dimzone();
5613    }
5614    
5615    void MainWindow::select_add_next_dim_rgn_zone() {
5616        m_DimRegionChooser.select_next_dimzone(true);
5617    }
5618    
5619    void MainWindow::select_add_prev_dim_rgn_zone() {
5620        m_DimRegionChooser.select_prev_dimzone(true);
5621    }
5622    
5623    void MainWindow::select_prev_dimension() {
5624        if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5625        m_DimRegionChooser.select_prev_dimension();
5626    }
5627    
5628    void MainWindow::select_next_dimension() {
5629        if (m_DimRegionChooser.has_focus()) return; // avoid conflict with key stroke handler of DimenionRegionChooser
5630        m_DimRegionChooser.select_next_dimension();
5631    }
5632    
5633    #define CLIPBOARD_DIMENSIONREGION_TARGET \
5634        ("libgig.DimensionRegion." + m_serializationArchive.rawDataFormat())
5635    
5636    void MainWindow::copy_selected_dimrgn() {
5637        gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5638        if (!pDimRgn) {
5639            updateClipboardPasteAvailable();
5640            updateClipboardCopyAvailable();
5641            return;
5642        }
5643    
5644        std::vector<Gtk::TargetEntry> targets;
5645        targets.push_back( Gtk::TargetEntry(CLIPBOARD_DIMENSIONREGION_TARGET) );
5646    
5647        Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5648        clipboard->set(
5649            targets,
5650            sigc::mem_fun(*this, &MainWindow::on_clipboard_get),
5651            sigc::mem_fun(*this, &MainWindow::on_clipboard_clear)
5652        );
5653    
5654        m_serializationArchive.serialize(pDimRgn);
5655    
5656        updateClipboardPasteAvailable();
5657    }
5658    
5659    void MainWindow::paste_copied_dimrgn() {
5660        Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5661        clipboard->request_contents(
5662            CLIPBOARD_DIMENSIONREGION_TARGET,
5663            sigc::mem_fun(*this, &MainWindow::on_clipboard_received)
5664        );
5665        updateClipboardPasteAvailable();
5666    }
5667    
5668    void MainWindow::adjust_clipboard_content() {
5669        MacroEditor* editor = new MacroEditor();
5670        editor->setMacro(&m_serializationArchive, true);
5671        editor->show();
5672    }
5673    
5674    void MainWindow::updateClipboardPasteAvailable() {
5675        Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get();
5676        clipboard->request_targets(
5677            sigc::mem_fun(*this, &MainWindow::on_clipboard_received_targets)
5678        );
5679    }
5680    
5681    void MainWindow::updateClipboardCopyAvailable() {
5682        bool bDimensionRegionCopyIsPossible = m_DimRegionChooser.get_main_dimregion();
5683    #if USE_GTKMM_BUILDER
5684        m_actionCopyDimRgn->property_enabled() = bDimensionRegionCopyIsPossible;
5685    #else
5686        static_cast<Gtk::MenuItem*>(
5687            uiManager->get_widget("/MenuBar/MenuEdit/CopyDimRgn")
5688        )->set_sensitive(bDimensionRegionCopyIsPossible);
5689    #endif
5690    }
5691    
5692    #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
5693    void MainWindow::on_clipboard_owner_change(Gdk::EventOwnerChange& event) {
5694    #else
5695    void MainWindow::on_clipboard_owner_change(GdkEventOwnerChange* event) {
5696    #endif
5697        updateClipboardPasteAvailable();
5698    }
5699    
5700    void MainWindow::on_clipboard_get(Gtk::SelectionData& selection_data, guint /*info*/) {
5701        const std::string target = selection_data.get_target();
5702        if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5703            selection_data.set(
5704                CLIPBOARD_DIMENSIONREGION_TARGET, 8 /* "format": probably unused*/,
5705                &m_serializationArchive.rawData()[0],
5706                m_serializationArchive.rawData().size()
5707            );
5708        } else {
5709            std::cerr << "Clipboard: content for unknown target '" << target << "' requested\n";
5710        }
5711    }
5712    
5713    void MainWindow::on_clipboard_clear() {
5714        m_serializationArchive.clear();
5715        updateClipboardPasteAvailable();
5716        updateClipboardCopyAvailable();
5717    }
5718    
5719    //NOTE: Might throw exception !!!
5720    void MainWindow::applyMacro(Serialization::Archive& macro) {
5721        gig::DimensionRegion* pDimRgn = m_DimRegionChooser.get_main_dimregion();
5722        if (!pDimRgn) return;
5723    
5724        for (std::set<gig::DimensionRegion*>::iterator itDimReg = dimreg_edit.dimregs.begin();
5725             itDimReg != dimreg_edit.dimregs.end(); ++itDimReg)
5726        {
5727            gig::DimensionRegion* pDimRgn = *itDimReg;
5728            DimRegionChangeGuard(this, pDimRgn);
5729            macro.deserialize(pDimRgn);
5730        }
5731        //region_changed()
5732        file_changed();
5733        dimreg_changed();
5734    }
5735    
5736    void MainWindow::on_clipboard_received(const Gtk::SelectionData& selection_data) {
5737        const std::string target = selection_data.get_target();
5738        if (target == CLIPBOARD_DIMENSIONREGION_TARGET) {
5739            Glib::ustring errorText;
5740            try {
5741                m_serializationArchive.decode(
5742                    selection_data.get_data(), selection_data.get_length()
5743                );
5744                applyMacro(m_serializationArchive);
5745            } catch (Serialization::Exception e) {
5746                errorText = e.Message;
5747            } catch (...) {
5748                errorText = _("Unknown exception while pasting DimensionRegion");
5749            }
5750            if (!errorText.empty()) {
5751                Glib::ustring txt = _("Pasting DimensionRegion failed:\n") + errorText;
5752                Gtk::MessageDialog msg(*this, txt, false, Gtk::MESSAGE_ERROR);
5753                msg.run();
5754            }
5755        }
5756    }
5757    
5758    void MainWindow::on_clipboard_received_targets(const std::vector<Glib::ustring>& targets) {
5759        const bool bDimensionRegionPasteIsPossible =
5760            std::find(targets.begin(), targets.end(),
5761                      CLIPBOARD_DIMENSIONREGION_TARGET) != targets.end();
5762    
5763    #if USE_GTKMM_BUILDER
5764        m_actionPasteDimRgn->property_enabled() = bDimensionRegionPasteIsPossible;
5765        m_actionAdjustClipboard->property_enabled() = bDimensionRegionPasteIsPossible;
5766    #else
5767        static_cast<Gtk::MenuItem*>(
5768            uiManager->get_widget("/MenuBar/MenuEdit/PasteDimRgn")
5769        )->set_sensitive(bDimensionRegionPasteIsPossible);
5770    
5771        static_cast<Gtk::MenuItem*>(
5772            uiManager->get_widget("/MenuBar/MenuEdit/AdjustClipboard")
5773        )->set_sensitive(bDimensionRegionPasteIsPossible);
5774    #endif
5775    }
5776    
5777  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {  sigc::signal<void, gig::File*>& MainWindow::signal_file_structure_to_be_changed() {
5778      return file_structure_to_be_changed_signal;      return file_structure_to_be_changed_signal;
5779  }  }
# Line 2927  sigc::signal<void, int/*key*/, int/*velo Line 5829  sigc::signal<void, int/*key*/, int/*velo
5829  sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {  sigc::signal<void, int/*key*/, int/*velocity*/>& MainWindow::signal_keyboard_key_released() {
5830      return m_RegionChooser.signal_keyboard_key_released();      return m_RegionChooser.signal_keyboard_key_released();
5831  }  }
5832    
5833    sigc::signal<void, gig::Instrument*>& MainWindow::signal_switch_sampler_instrument() {
5834        return switch_sampler_instrument_signal;
5835    }

Legend:
Removed from v.2664  
changed lines
  Added in v.3637

  ViewVC Help
Powered by ViewVC