/[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 3619 by schoenebeck, Tue Oct 1 16:21:28 2019 UTC revision 3711 by schoenebeck, Fri Jan 10 14:22:25 2020 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (C) 2006-2019 Andreas Persson   * Copyright (C) 2006-2020 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 451  MainWindow::MainWindow() : Line 451  MainWindow::MainWindow() :
451          m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);          m_actionGroup->add_action_bool("Statusbar", sigc::mem_fun(*this, &MainWindow::on_action_view_status_bar), true);
452      m_actionToggleRestoreWinDim =      m_actionToggleRestoreWinDim =
453          m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);          m_actionGroup->add_action_bool("AutoRestoreWinDim", sigc::mem_fun(*this, &MainWindow::on_auto_restore_win_dim), Settings::singleton()->autoRestoreWindowDimension);
454        m_actionInstrDoubleClickOpensProps =
455            m_actionGroup->add_action_bool(
456                "OpenInstrPropsByDoubleClick",
457                sigc::mem_fun(*this, &MainWindow::on_instr_double_click_opens_props),
458                Settings::singleton()->instrumentDoubleClickOpensProps
459            );
460      m_actionToggleShowTooltips = m_actionGroup->add_action_bool(      m_actionToggleShowTooltips = m_actionGroup->add_action_bool(
461          "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),          "ShowTooltips", sigc::mem_fun(*this, &MainWindow::on_action_show_tooltips),
462          Settings::singleton()->showTooltips          Settings::singleton()->showTooltips
# Line 478  MainWindow::MainWindow() : Line 484  MainWindow::MainWindow() :
484                           *this, &MainWindow::on_auto_restore_win_dim));                           *this, &MainWindow::on_auto_restore_win_dim));
485    
486      toggle_action =      toggle_action =
487            Gtk::ToggleAction::create("OpenInstrPropsByDoubleClick", _("Instrument Properties by Double Click"));
488        toggle_action->set_active(Settings::singleton()->instrumentDoubleClickOpensProps);
489        actionGroup->add(toggle_action,
490                         sigc::mem_fun(
491                             *this, &MainWindow::on_instr_double_click_opens_props));
492    
493        toggle_action =
494          Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));          Gtk::ToggleAction::create("ShowTooltips", _("Tooltips for Beginners"));
495      toggle_action->set_active(Settings::singleton()->showTooltips);      toggle_action->set_active(Settings::singleton()->showTooltips);
496      actionGroup->add(      actionGroup->add(
# Line 935  MainWindow::MainWindow() : Line 948  MainWindow::MainWindow() :
948          "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"          "          <attribute name='label' translatable='yes'>Auto restore Window Dimensions</attribute>"
949          "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"          "          <attribute name='action'>AppMenu.AutoRestoreWinDim</attribute>"
950          "        </item>"          "        </item>"
951            "        <item id='OpenInstrPropsByDoubleClick'>"
952            "          <attribute name='label' translatable='yes'>Instrument Properties by Double Click</attribute>"
953            "          <attribute name='action'>AppMenu.OpenInstrPropsByDoubleClick</attribute>"
954            "        </item>"
955          "      </section>"          "      </section>"
956          "      <section>"          "      <section>"
957          "        <item id='RefreshAll'>"          "        <item id='RefreshAll'>"
# Line 1163  MainWindow::MainWindow() : Line 1180  MainWindow::MainWindow() :
1180          "      <menuitem action='Statusbar'/>"          "      <menuitem action='Statusbar'/>"
1181          "      <menuitem action='ShowTooltips'/>"          "      <menuitem action='ShowTooltips'/>"
1182          "      <menuitem action='AutoRestoreWinDim'/>"          "      <menuitem action='AutoRestoreWinDim'/>"
1183            "      <menuitem action='OpenInstrPropsByDoubleClick'/>"
1184          "      <separator/>"          "      <separator/>"
1185          "      <menuitem action='RefreshAll'/>"          "      <menuitem action='RefreshAll'/>"
1186          "    </menu>"          "    </menu>"
# Line 1286  MainWindow::MainWindow() : Line 1304  MainWindow::MainWindow() :
1304      }      }
1305      {      {
1306          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(          Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1307                uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
1308            item->set_tooltip_text(_("If checked, double clicking an instrument opens its properties dialog."));
1309        }
1310        {
1311            Gtk::MenuItem* item = dynamic_cast<Gtk::MenuItem*>(
1312              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));              uiManager->get_widget("/MenuBar/MenuTools/CombineInstruments"));
1313          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."));
1314      }      }
# Line 1484  MainWindow::MainWindow() : Line 1507  MainWindow::MainWindow() :
1507          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1508      instrumentProps.signal_changed().connect(      instrumentProps.signal_changed().connect(
1509          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1510      propDialog.signal_changed().connect(      sampleProps.signal_changed().connect(
1511            sigc::mem_fun(*this, &MainWindow::file_changed));
1512        fileProps.signal_changed().connect(
1513          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
1514      midiRules.signal_changed().connect(      midiRules.signal_changed().connect(
1515          sigc::mem_fun(*this, &MainWindow::file_changed));          sigc::mem_fun(*this, &MainWindow::file_changed));
# Line 2603  void MainWindow::__import_queued_samples Line 2628  void MainWindow::__import_queued_samples
2628    
2629  void MainWindow::on_action_file_properties()  void MainWindow::on_action_file_properties()
2630  {  {
2631      propDialog.show();      fileProps.show();
2632      propDialog.deiconify();      fileProps.deiconify();
2633  }  }
2634    
2635  void MainWindow::on_action_warn_user_on_extensions() {  void MainWindow::on_action_warn_user_on_extensions() {
# Line 2675  void MainWindow::on_action_help_about() Line 2700  void MainWindow::on_action_help_about()
2700      dialog.run();      dialog.run();
2701  }  }
2702    
2703  PropDialog::PropDialog()  FilePropDialog::FilePropDialog()
2704      : eFileFormat(_("File Format")),      : eFileFormat(_("File Format")),
2705        eName(_("Name")),        eName(_("Name")),
2706        eCreationDate(_("Creation date")),        eCreationDate(_("Creation date")),
# Line 2709  PropDialog::PropDialog() Line 2734  PropDialog::PropDialog()
2734      set_title(_("File Properties"));      set_title(_("File Properties"));
2735      eName.set_width_chars(50);      eName.set_width_chars(50);
2736    
2737      connect(eFileFormat, &PropDialog::set_FileFormat);      connect(eFileFormat, &FilePropDialog::set_FileFormat);
2738      connect(eName, &DLS::Info::Name);      connect(eName, &DLS::Info::Name);
2739      connect(eCreationDate, &DLS::Info::CreationDate);      connect(eCreationDate, &DLS::Info::CreationDate);
2740      connect(eComments, &DLS::Info::Comments);      connect(eComments, &DLS::Info::Comments);
# Line 2770  PropDialog::PropDialog() Line 2795  PropDialog::PropDialog()
2795      quitButton.set_can_default();      quitButton.set_can_default();
2796      quitButton.grab_focus();      quitButton.grab_focus();
2797      quitButton.signal_clicked().connect(      quitButton.signal_clicked().connect(
2798          sigc::mem_fun(*this, &PropDialog::hide));          sigc::mem_fun(*this, &FilePropDialog::hide));
2799    
2800      quitButton.show();      quitButton.show();
2801      vbox.show();      vbox.show();
# Line 2779  PropDialog::PropDialog() Line 2804  PropDialog::PropDialog()
2804  #endif  #endif
2805  }  }
2806    
2807  void PropDialog::set_file(gig::File* file)  void FilePropDialog::set_file(gig::File* file)
2808  {  {
2809      m_file = file;      m_file = file;
2810      update(file->pInfo);      update(file->pInfo);
# Line 2805  void PropDialog::set_file(gig::File* fil Line 2830  void PropDialog::set_file(gig::File* fil
2830      update_model--;      update_model--;
2831  }  }
2832    
2833  void PropDialog::set_FileFormat(int value)  void FilePropDialog::set_FileFormat(int value)
2834  {  {
2835      m_file->pVersion->major = value;      m_file->pVersion->major = value;
2836  }  }
# Line 2849  InstrumentProps::InstrumentProps() : Line 2874  InstrumentProps::InstrumentProps() :
2874      eIsDrum(_("Is drum")),      eIsDrum(_("Is drum")),
2875      eMIDIBank(_("MIDI bank"), 0, 16383),      eMIDIBank(_("MIDI bank"), 0, 16383),
2876      eMIDIProgram(_("MIDI program")),      eMIDIProgram(_("MIDI program")),
2877      eAttenuation(_("Attenuation"), 0, 96, 0, 1),      eAttenuation(_("Attenuation (dB)"), -96, +96, 0, 1),
     eGainPlus6(_("Gain +6dB"), eAttenuation, -6),  
2878      eEffectSend(_("Effect send"), 0, 65535),      eEffectSend(_("Effect send"), 0, 65535),
2879      eFineTune(_("Fine tune"), -8400, 8400),      eFineTune(_("Fine tune"), -8400, 8400),
2880      ePitchbendRange(_("Pitchbend range"), 0, 48),      ePitchbendRange(_("Pitchbend range (halftones)"), 0, 48),
2881      ePianoReleaseMode(_("Piano release mode")),      ePianoReleaseMode(_("Piano release mode")),
2882      eDimensionKeyRangeLow(_("Keyswitching range low")),      eDimensionKeyRangeLow(_("Keyswitching range low")),
2883      eDimensionKeyRangeHigh(_("Keyswitching range high"))      eDimensionKeyRangeHigh(_("Keyswitching range high")),
2884        table2(2,1),
2885        eName2(_("Name")),
2886        eCreationDate(_("Creation date")),
2887        eComments(_("Comments")),
2888        eProduct(_("Product")),
2889        eCopyright(_("Copyright")),
2890        eArtists(_("Artists")),
2891        eGenre(_("Genre")),
2892        eKeywords(_("Keywords")),
2893        eEngineer(_("Engineer")),
2894        eTechnician(_("Technician")),
2895        eSoftware(_("Software")),
2896        eMedium(_("Medium")),
2897        eSource(_("Source")),
2898        eSourceForm(_("Source form")),
2899        eCommissioned(_("Commissioned")),
2900        eSubject(_("Subject"))
2901  {  {
2902      if (!Settings::singleton()->autoRestoreWindowDimension) {      if (!Settings::singleton()->autoRestoreWindowDimension) {
2903          //set_default_size(470, 390);          //set_default_size(470, 390);
# Line 2865  InstrumentProps::InstrumentProps() : Line 2906  InstrumentProps::InstrumentProps() :
2906    
2907      set_title(_("Instrument Properties"));      set_title(_("Instrument Properties"));
2908    
2909        tabs.append_page(vbox[1], _("Settings"));
2910        tabs.append_page(vbox[2], _("Info"));
2911    
2912      eDimensionKeyRangeLow.set_tip(      eDimensionKeyRangeLow.set_tip(
2913          _("start of the keyboard area which should switch the "          _("start of the keyboard area which should switch the "
2914            "\"keyswitching\" dimension")            "\"keyswitching\" dimension")
# Line 2879  InstrumentProps::InstrumentProps() : Line 2923  InstrumentProps::InstrumentProps() :
2923      connect(eMIDIBank, &InstrumentProps::set_MIDIBank);      connect(eMIDIBank, &InstrumentProps::set_MIDIBank);
2924      connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);      connect(eMIDIProgram, &InstrumentProps::set_MIDIProgram);
2925      connect(eAttenuation, &gig::Instrument::Attenuation);      connect(eAttenuation, &gig::Instrument::Attenuation);
     connect(eGainPlus6, &gig::Instrument::Attenuation);  
2926      connect(eEffectSend, &gig::Instrument::EffectSend);      connect(eEffectSend, &gig::Instrument::EffectSend);
2927      connect(eFineTune, &gig::Instrument::FineTune);      connect(eFineTune, &gig::Instrument::FineTune);
2928      connect(ePitchbendRange, &gig::Instrument::PitchbendRange);      connect(ePitchbendRange, &gig::Instrument::PitchbendRange);
# Line 2889  InstrumentProps::InstrumentProps() : Line 2932  InstrumentProps::InstrumentProps() :
2932    
2933      eName.signal_value_changed().connect(sig_name_changed.make_slot());      eName.signal_value_changed().connect(sig_name_changed.make_slot());
2934    
2935        connect(eName2, &InstrumentProps::set_Name);
2936        connectLambda(eCreationDate, [this](gig::String s) {
2937            m->pInfo->CreationDate = s;
2938        });
2939        connectLambda(eComments, [this](gig::String s) {
2940            m->pInfo->Comments = s;
2941        });
2942        connectLambda(eProduct, [this](gig::String s) {
2943            m->pInfo->Product = s;
2944        });
2945        connectLambda(eCopyright, [this](gig::String s) {
2946            m->pInfo->Copyright = s;
2947        });
2948        connectLambda(eArtists, [this](gig::String s) {
2949            m->pInfo->Artists = s;
2950        });
2951        connectLambda(eGenre, [this](gig::String s) {
2952            m->pInfo->Genre = s;
2953        });
2954        connectLambda(eKeywords, [this](gig::String s) {
2955            m->pInfo->Keywords = s;
2956        });
2957        connectLambda(eEngineer, [this](gig::String s) {
2958            m->pInfo->Engineer = s;
2959        });
2960        connectLambda(eTechnician, [this](gig::String s) {
2961            m->pInfo->Technician = s;
2962        });
2963        connectLambda(eSoftware, [this](gig::String s) {
2964            m->pInfo->Software = s;
2965        });
2966        connectLambda(eMedium, [this](gig::String s) {
2967            m->pInfo->Medium = s;
2968        });
2969        connectLambda(eSource, [this](gig::String s) {
2970            m->pInfo->Source = s;
2971        });
2972        connectLambda(eSourceForm, [this](gig::String s) {
2973            m->pInfo->SourceForm = s;
2974        });
2975        connectLambda(eCommissioned, [this](gig::String s) {
2976            m->pInfo->Commissioned = s;
2977        });
2978        connectLambda(eSubject, [this](gig::String s) {
2979            m->pInfo->Subject = s;
2980        });
2981    
2982        // tab 1
2983  #if USE_GTKMM_GRID  #if USE_GTKMM_GRID
2984      table.set_column_spacing(5);      table.set_column_spacing(5);
2985  #else  #else
2986      table.set_col_spacings(5);      table.set_col_spacings(5);
2987  #endif  #endif
   
2988      table.add(eName);      table.add(eName);
2989      table.add(eIsDrum);      table.add(eIsDrum);
2990      table.add(eMIDIBank);      table.add(eMIDIBank);
2991      table.add(eMIDIProgram);      table.add(eMIDIProgram);
2992      table.add(eAttenuation);      table.add(eAttenuation);
     table.add(eGainPlus6);  
2993      table.add(eEffectSend);      table.add(eEffectSend);
2994      table.add(eFineTune);      table.add(eFineTune);
2995      table.add(ePitchbendRange);      table.add(ePitchbendRange);
# Line 2908  InstrumentProps::InstrumentProps() : Line 2997  InstrumentProps::InstrumentProps() :
2997      table.add(eDimensionKeyRangeLow);      table.add(eDimensionKeyRangeLow);
2998      table.add(eDimensionKeyRangeHigh);      table.add(eDimensionKeyRangeHigh);
2999    
3000      add(vbox);      // tab 2
3001    #if USE_GTKMM_GRID
3002        table2.set_column_spacing(5);
3003    #else
3004        table2.set_col_spacings(5);
3005    #endif
3006        table2.add(eName2);
3007        table2.add(eCreationDate);
3008        table2.add(eComments);
3009        table2.add(eProduct);
3010        table2.add(eCopyright);
3011        table2.add(eArtists);
3012        table2.add(eGenre);
3013        table2.add(eKeywords);
3014        table2.add(eEngineer);
3015        table2.add(eTechnician);
3016        table2.add(eSoftware);
3017        table2.add(eMedium);
3018        table2.add(eSource);
3019        table2.add(eSourceForm);
3020        table2.add(eCommissioned);
3021        table2.add(eSubject);
3022    
3023        add(vbox[0]);
3024  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3025      table.set_margin(5);      table.set_margin(5);
3026  #else  #else
3027      table.set_border_width(5);      table.set_border_width(5);
3028  #endif  #endif
3029      vbox.pack_start(table);      vbox[1].pack_start(table);
3030        vbox[2].pack_start(table2);
3031      table.show();      table.show();
3032      vbox.pack_start(buttonBox, Gtk::PACK_SHRINK);      table2.show();
3033        vbox[0].pack_start(tabs);
3034        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3035      buttonBox.set_layout(Gtk::BUTTONBOX_END);      buttonBox.set_layout(Gtk::BUTTONBOX_END);
3036  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)  #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3037      buttonBox.set_margin(5);      buttonBox.set_margin(5);
# Line 2932  InstrumentProps::InstrumentProps() : Line 3047  InstrumentProps::InstrumentProps() :
3047          sigc::mem_fun(*this, &InstrumentProps::hide));          sigc::mem_fun(*this, &InstrumentProps::hide));
3048    
3049      quitButton.show();      quitButton.show();
3050      vbox.show();      vbox[0].show();
3051  #if HAS_GTKMM_SHOW_ALL_CHILDREN  #if HAS_GTKMM_SHOW_ALL_CHILDREN
3052      show_all_children();      show_all_children();
3053  #endif  #endif
# Line 2943  void InstrumentProps::set_instrument(gig Line 3058  void InstrumentProps::set_instrument(gig
3058      update(instrument);      update(instrument);
3059    
3060      update_model++;      update_model++;
3061    
3062        // tab 1
3063      eName.set_value(instrument->pInfo->Name);      eName.set_value(instrument->pInfo->Name);
3064      eIsDrum.set_value(instrument->IsDrum);      eIsDrum.set_value(instrument->IsDrum);
3065      eMIDIBank.set_value(instrument->MIDIBank);      eMIDIBank.set_value(instrument->MIDIBank);
3066      eMIDIProgram.set_value(instrument->MIDIProgram);      eMIDIProgram.set_value(instrument->MIDIProgram);
3067        // tab 2
3068        eName2.set_value(instrument->pInfo->Name);
3069        eCreationDate.set_value(instrument->pInfo->CreationDate);
3070        eComments.set_value(instrument->pInfo->Comments);
3071        eProduct.set_value(instrument->pInfo->Product);
3072        eCopyright.set_value(instrument->pInfo->Copyright);
3073        eArtists.set_value(instrument->pInfo->Artists);
3074        eGenre.set_value(instrument->pInfo->Genre);
3075        eKeywords.set_value(instrument->pInfo->Keywords);
3076        eEngineer.set_value(instrument->pInfo->Engineer);
3077        eTechnician.set_value(instrument->pInfo->Technician);
3078        eSoftware.set_value(instrument->pInfo->Software);
3079        eMedium.set_value(instrument->pInfo->Medium);
3080        eSource.set_value(instrument->pInfo->Source);
3081        eSourceForm.set_value(instrument->pInfo->SourceForm);
3082        eCommissioned.set_value(instrument->pInfo->Commissioned);
3083        eSubject.set_value(instrument->pInfo->Subject);
3084    
3085        update_model--;
3086    }
3087    
3088    
3089    SampleProps::SampleProps() :
3090    #if HAS_GTKMM_STOCK
3091        quitButton(Gtk::Stock::CLOSE),
3092    #else
3093        quitButton(_("_Close")),
3094    #endif
3095        table(2,1),
3096        eName(_("Name")),
3097        eUnityNote(_("Unity Note")),
3098        eSampleGroup(_("Sample Group")),
3099        eSampleFormatInfo(_("Sample Format")),
3100        eSampleID("Sample ID"),
3101        eChecksum("Wave Data CRC-32"),
3102        eLoopsCount(_("Loops"), 0, 1), // we might support more than 1 loop in future
3103        eLoopStart(_("Loop start position"), 0, 9999999),
3104        eLoopLength(_("Loop size"), 0, 9999999),
3105        eLoopType(_("Loop type")),
3106        eLoopPlayCount(_("Playback count")),
3107        table2(2,1),
3108        eName2(_("Name")),
3109        eCreationDate(_("Creation date")),
3110        eComments(_("Comments")),
3111        eProduct(_("Product")),
3112        eCopyright(_("Copyright")),
3113        eArtists(_("Artists")),
3114        eGenre(_("Genre")),
3115        eKeywords(_("Keywords")),
3116        eEngineer(_("Engineer")),
3117        eTechnician(_("Technician")),
3118        eSoftware(_("Software")),
3119        eMedium(_("Medium")),
3120        eSource(_("Source")),
3121        eSourceForm(_("Source form")),
3122        eCommissioned(_("Commissioned")),
3123        eSubject(_("Subject"))
3124    {
3125        if (!Settings::singleton()->autoRestoreWindowDimension) {
3126            //set_default_size(470, 390);
3127            set_position(Gtk::WIN_POS_MOUSE);
3128        }
3129    
3130        set_title(_("Sample Properties"));
3131    
3132        tabs.append_page(vbox[1], _("Settings"));
3133        tabs.append_page(vbox[2], _("Info"));
3134    
3135        connect(eName, &SampleProps::set_Name);
3136        connect(eUnityNote, &gig::Sample::MIDIUnityNote);
3137        connect(eLoopsCount, &gig::Sample::Loops);
3138        connectLambda(eLoopStart, [this](uint32_t start){
3139            m->LoopStart = start;
3140            m->LoopEnd = start + m->LoopSize;
3141        });
3142        connectLambda(eLoopLength, [this](uint32_t length){
3143            m->LoopSize = length;
3144            m->LoopEnd = m->LoopStart + length;
3145        });
3146        {
3147            const char* choices[] = { _("normal"), _("bidirectional"), _("backward"), 0 };
3148            static const gig::loop_type_t values[] = {
3149                gig::loop_type_normal,
3150                gig::loop_type_bidirectional,
3151                gig::loop_type_backward
3152            };
3153            eLoopType.set_choices(choices, values);
3154        }
3155        connect(eLoopType, &gig::Sample::LoopType);
3156        connect(eLoopPlayCount, &gig::Sample::LoopPlayCount);
3157    
3158        eName.signal_value_changed().connect(sig_name_changed.make_slot());
3159    
3160        connect(eName2, &SampleProps::set_Name);
3161        connectLambda(eCreationDate, [this](gig::String s) {
3162            m->pInfo->CreationDate = s;
3163        });
3164        connectLambda(eComments, [this](gig::String s) {
3165            m->pInfo->Comments = s;
3166        });
3167        connectLambda(eProduct, [this](gig::String s) {
3168            m->pInfo->Product = s;
3169        });
3170        connectLambda(eCopyright, [this](gig::String s) {
3171            m->pInfo->Copyright = s;
3172        });
3173        connectLambda(eArtists, [this](gig::String s) {
3174            m->pInfo->Artists = s;
3175        });
3176        connectLambda(eGenre, [this](gig::String s) {
3177            m->pInfo->Genre = s;
3178        });
3179        connectLambda(eKeywords, [this](gig::String s) {
3180            m->pInfo->Keywords = s;
3181        });
3182        connectLambda(eEngineer, [this](gig::String s) {
3183            m->pInfo->Engineer = s;
3184        });
3185        connectLambda(eTechnician, [this](gig::String s) {
3186            m->pInfo->Technician = s;
3187        });
3188        connectLambda(eSoftware, [this](gig::String s) {
3189            m->pInfo->Software = s;
3190        });
3191        connectLambda(eMedium, [this](gig::String s) {
3192            m->pInfo->Medium = s;
3193        });
3194        connectLambda(eSource, [this](gig::String s) {
3195            m->pInfo->Source = s;
3196        });
3197        connectLambda(eSourceForm, [this](gig::String s) {
3198            m->pInfo->SourceForm = s;
3199        });
3200        connectLambda(eCommissioned, [this](gig::String s) {
3201            m->pInfo->Commissioned = s;
3202        });
3203        connectLambda(eSubject, [this](gig::String s) {
3204            m->pInfo->Subject = s;
3205        });
3206    
3207        // tab 1
3208    #if USE_GTKMM_GRID
3209        table.set_column_spacing(5);
3210    #else
3211        table.set_col_spacings(5);
3212    #endif
3213        table.add(eName);
3214        table.add(eUnityNote);
3215        table.add(eSampleGroup);
3216        table.add(eSampleFormatInfo);
3217        table.add(eSampleID);
3218        table.add(eChecksum);
3219        table.add(eLoopsCount);
3220        table.add(eLoopStart);
3221        table.add(eLoopLength);
3222        table.add(eLoopType);
3223        table.add(eLoopPlayCount);
3224    
3225        // tab 2
3226    #if USE_GTKMM_GRID
3227        table2.set_column_spacing(5);
3228    #else
3229        table2.set_col_spacings(5);
3230    #endif
3231        table2.add(eName2);
3232        table2.add(eCreationDate);
3233        table2.add(eComments);
3234        table2.add(eProduct);
3235        table2.add(eCopyright);
3236        table2.add(eArtists);
3237        table2.add(eGenre);
3238        table2.add(eKeywords);
3239        table2.add(eEngineer);
3240        table2.add(eTechnician);
3241        table2.add(eSoftware);
3242        table2.add(eMedium);
3243        table2.add(eSource);
3244        table2.add(eSourceForm);
3245        table2.add(eCommissioned);
3246        table2.add(eSubject);
3247    
3248        add(vbox[0]);
3249    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3250        table.set_margin(5);
3251    #else
3252        table.set_border_width(5);
3253    #endif
3254        vbox[1].pack_start(table);
3255        vbox[2].pack_start(table2);
3256        table.show();
3257        table2.show();
3258        vbox[0].pack_start(tabs);
3259        vbox[0].pack_start(buttonBox, Gtk::PACK_SHRINK);
3260        buttonBox.set_layout(Gtk::BUTTONBOX_END);
3261    #if GTKMM_MAJOR_VERSION > 3 || (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION > 24)
3262        buttonBox.set_margin(5);
3263    #else
3264        buttonBox.set_border_width(5);
3265    #endif
3266        buttonBox.show();
3267        buttonBox.pack_start(quitButton);
3268        quitButton.set_can_default();
3269        quitButton.grab_focus();
3270    
3271        quitButton.signal_clicked().connect(
3272            sigc::mem_fun(*this, &SampleProps::hide));
3273    
3274        quitButton.show();
3275        vbox[0].show();
3276    #if HAS_GTKMM_SHOW_ALL_CHILDREN
3277        show_all_children();
3278    #endif
3279    }
3280    
3281    void SampleProps::set_sample(gig::Sample* sample)
3282    {
3283        update(sample);
3284    
3285        update_model++;
3286    
3287        // tab 1
3288        eName.set_value(sample->pInfo->Name);
3289        eUnityNote.set_value(sample->MIDIUnityNote);
3290        // show sample group name
3291        {
3292            Glib::ustring s = "---";
3293            if (sample && sample->GetGroup())
3294                s = sample->GetGroup()->Name;
3295            eSampleGroup.text.set_text(s);
3296        }
3297        // assemble sample format info string
3298        {
3299            Glib::ustring s;
3300            if (sample) {
3301                switch (sample->Channels) {
3302                    case 1: s = _("Mono"); break;
3303                    case 2: s = _("Stereo"); break;
3304                    default:
3305                        s = ToString(sample->Channels) + _(" audio channels");
3306                        break;
3307                }
3308                s += " " + ToString(sample->BitDepth) + " Bits";
3309                s += " " + ToString(sample->SamplesPerSecond/1000) + "."
3310                         + ToString((sample->SamplesPerSecond%1000)/100) + " kHz";
3311            } else {
3312                s = _("No sample assigned to this dimension region.");
3313            }
3314            eSampleFormatInfo.text.set_text(s);
3315        }
3316        // generate sample's memory address pointer string
3317        {
3318            Glib::ustring s;
3319            if (sample) {
3320                char buf[64] = {};
3321                snprintf(buf, sizeof(buf), "%p", sample);
3322                s = buf;
3323            } else {
3324                s = "---";
3325            }
3326            eSampleID.text.set_text(s);
3327        }
3328        // generate raw wave form data CRC-32 checksum string
3329        {
3330            Glib::ustring s = "---";
3331            if (sample) {
3332                char buf[64] = {};
3333                snprintf(buf, sizeof(buf), "%x", sample->GetWaveDataCRC32Checksum());
3334                s = buf;
3335            }
3336            eChecksum.text.set_text(s);
3337        }
3338        eLoopsCount.set_value(sample->Loops);
3339        eLoopStart.set_value(sample->LoopStart);
3340        eLoopLength.set_value(sample->LoopSize);
3341        eLoopType.set_value(sample->LoopType);
3342        eLoopPlayCount.set_value(sample->LoopPlayCount);
3343        // tab 2
3344        eName2.set_value(sample->pInfo->Name);
3345        eCreationDate.set_value(sample->pInfo->CreationDate);
3346        eComments.set_value(sample->pInfo->Comments);
3347        eProduct.set_value(sample->pInfo->Product);
3348        eCopyright.set_value(sample->pInfo->Copyright);
3349        eArtists.set_value(sample->pInfo->Artists);
3350        eGenre.set_value(sample->pInfo->Genre);
3351        eKeywords.set_value(sample->pInfo->Keywords);
3352        eEngineer.set_value(sample->pInfo->Engineer);
3353        eTechnician.set_value(sample->pInfo->Technician);
3354        eSoftware.set_value(sample->pInfo->Software);
3355        eMedium.set_value(sample->pInfo->Medium);
3356        eSource.set_value(sample->pInfo->Source);
3357        eSourceForm.set_value(sample->pInfo->SourceForm);
3358        eCommissioned.set_value(sample->pInfo->Commissioned);
3359        eSubject.set_value(sample->pInfo->Subject);
3360    
3361        update_model--;
3362    }
3363    
3364    void SampleProps::set_Name(const gig::String& name)
3365    {
3366        m->pInfo->Name = name;
3367    }
3368    
3369    void SampleProps::update_name()
3370    {
3371        update_model++;
3372        eName.set_value(m->pInfo->Name);
3373      update_model--;      update_model--;
3374  }  }
3375    
# Line 3042  void MainWindow::load_gig(gig::File* gig Line 3465  void MainWindow::load_gig(gig::File* gig
3465      file_has_name = filename;      file_has_name = filename;
3466      file_is_changed = false;      file_is_changed = false;
3467    
3468      propDialog.set_file(gig);      fileProps.set_file(gig);
3469    
3470      instrument_name_connection.block();      instrument_name_connection.block();
3471      int index = 0;      int index = 0;
# Line 3182  void MainWindow::instr_name_changed_by_i Line 3605  void MainWindow::instr_name_changed_by_i
3605      }      }
3606  }  }
3607    
3608    bool MainWindow::sample_props_set_sample()
3609    {
3610        sampleProps.signal_name_changed().clear();
3611    
3612        std::vector<Gtk::TreeModel::Path> rows = m_TreeViewSamples.get_selection()->get_selected_rows();
3613        if (rows.empty()) {
3614            sampleProps.hide();
3615            return false;
3616        }
3617        //NOTE: was const_iterator before, which did not compile with GTKMM4 development branch, probably going to be fixed before final GTKMM4 release though.
3618        Gtk::TreeModel::iterator it = m_refSamplesTreeModel->get_iter(rows[0]);
3619        if (it) {
3620            Gtk::TreeModel::Row row = *it;
3621            gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3622    
3623            sampleProps.set_sample(sample);
3624    
3625            // make sure sample tree is updated when user changes the
3626            // sample name in sample properties window
3627            sampleProps.signal_name_changed().connect(
3628                sigc::bind(
3629                    sigc::mem_fun(*this,
3630                        &MainWindow::sample_name_changed_by_sample_props
3631                    ), it
3632                )
3633            );
3634        } else {
3635            sampleProps.hide();
3636        }
3637        //NOTE: explicit boolean cast required for GTKMM4 development branch here
3638        return it ? true : false;
3639    }
3640    
3641    void MainWindow::show_sample_props()
3642    {
3643        if (sample_props_set_sample()) {
3644            sampleProps.show();
3645            sampleProps.deiconify();
3646        }
3647    }
3648    
3649    void MainWindow::sample_name_changed_by_sample_props(Gtk::TreeModel::iterator& it)
3650    {
3651        Gtk::TreeModel::Row row = *it;
3652        Glib::ustring name = row[m_SamplesModel.m_col_name];
3653    
3654        gig::Sample* sample = row[m_SamplesModel.m_col_sample];
3655        Glib::ustring gigname(gig_to_utf8(sample->pInfo->Name));
3656        if (gigname != name) {
3657            Gtk::TreeModel::Path path(*it);
3658            row[m_SamplesModel.m_col_name] = gigname;
3659        }
3660    }
3661    
3662  void MainWindow::show_midi_rules()  void MainWindow::show_midi_rules()
3663  {  {
3664      if (gig::Instrument* instrument = get_instrument())      if (gig::Instrument* instrument = get_instrument())
# Line 3310  void MainWindow::on_auto_restore_win_dim Line 3787  void MainWindow::on_auto_restore_win_dim
3787  #endif  #endif
3788  }  }
3789    
3790    void MainWindow::on_instr_double_click_opens_props() {
3791    #if USE_GLIB_ACTION
3792        bool active = false;
3793        m_actionInstrDoubleClickOpensProps->get_state(active);
3794        // for some reason toggle state does not change automatically
3795        active = !active;
3796        m_actionInstrDoubleClickOpensProps->change_state(active);
3797        Settings::singleton()->instrumentDoubleClickOpensProps = active;
3798    #else
3799        Gtk::CheckMenuItem* item =
3800            dynamic_cast<Gtk::CheckMenuItem*>(uiManager->get_widget("/MenuBar/MenuView/OpenInstrPropsByDoubleClick"));
3801        if (!item) {
3802            std::cerr << "/MenuBar/MenuView/OpenInstrPropsByDoubleClick == NULL\n";
3803            return;
3804        }
3805        Settings::singleton()->instrumentDoubleClickOpensProps = item->get_active();
3806    #endif
3807    }
3808    
3809  void MainWindow::on_save_with_temporary_file() {  void MainWindow::on_save_with_temporary_file() {
3810  #if USE_GLIB_ACTION  #if USE_GLIB_ACTION
3811      bool active = false;      bool active = false;
# Line 3384  bool MainWindow::on_button_release(Gdk:: Line 3880  bool MainWindow::on_button_release(Gdk::
3880  void MainWindow::on_button_release(GdkEventButton* button) {  void MainWindow::on_button_release(GdkEventButton* button) {
3881  #endif  #endif
3882      if (button->type == GDK_2BUTTON_PRESS) {      if (button->type == GDK_2BUTTON_PRESS) {
3883          show_instr_props();          if (Settings::singleton()->instrumentDoubleClickOpensProps)
3884                show_instr_props();
3885      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {      } else if (button->type == GDK_BUTTON_PRESS && button->button == 3) {
3886          // gig v2 files have no midi rules          // gig v2 files have no midi rules
3887          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);          const bool bEnabled = !(file->pVersion && file->pVersion->major == 2);
# Line 3888  void MainWindow::on_action_remove_instru Line 4385  void MainWindow::on_action_remove_instru
4385  }  }
4386    
4387  void MainWindow::on_action_sample_properties() {  void MainWindow::on_action_sample_properties() {
4388      //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();  
4389  }  }
4390    
4391  void MainWindow::on_action_add_script_group() {  void MainWindow::on_action_add_script_group() {
# Line 4691  void MainWindow::sample_name_changed(con Line 5184  void MainWindow::sample_name_changed(con
5184              file_changed();              file_changed();
5185          }          }
5186      }      }
5187        // change name in the sample properties window
5188        if (sampleProps.get_sample() == sample && sample) {
5189            sampleProps.set_sample(sample);
5190        }
5191  }  }
5192    
5193  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,  void MainWindow::script_name_changed(const Gtk::TreeModel::Path& path,
Legend:
Removed from v.3619  
changed lines
  Added in v.3711
  ViewVC Help
Powered by ViewVC