MainContentComponent Class Reference

#include <MainComponent.h>

Inheritance diagram for MainContentComponent:

Public Member Functions
	MainContentComponent (const CommandSet &command_set, Profile &profile, ProfileManager &profile_manager, SettingsManager &settings_manager, LrIpcOut &lr_ipc_out, MidiReceiver &midi_receiver, MidiSender &midi_sender)
	MainContentComponent (const MainContentComponent &other)=delete
	MainContentComponent (MainContentComponent &&other)=delete
	~MainContentComponent ()
void	Init ()
MainContentComponent &	operator= (const MainContentComponent &other)=delete
MainContentComponent &	operator= (MainContentComponent &&other)=delete
void	SaveProfile () const

Private Member Functions
void	handleAsyncUpdate () override
void	LrIpcOutCallback (bool, bool)
void	MidiCmdCallback (rsj::MidiMessage mm)
void	paint (juce::Graphics &) override
void	ProfileChanged (juce::XmlElement *xml_element, const juce::String &file_name)
void	timerCallback () override
void	UpdateConnectionLabel (const char *text, juce::Colour colour)

Private Attributes
juce::Label	command_label_ {"Command", ""}
CommandTable	command_table_ {"Table", nullptr}
CommandTableModel	command_table_model_
juce::Label	connection_label_ {"Connection", juce::translate("Not connected to Lightroom")}
juce::TextButton	disconnect_button_ {juce::translate("Halt sending to Lightroom")}
juce::String	last_command_
juce::TextButton	load_button_ {juce::translate("Load")}
LrIpcOut &	lr_ipc_out_
MidiReceiver &	midi_receiver_
MidiSender &	midi_sender_
Profile &	profile_
ProfileManager &	profile_manager_
juce::Label	profile_name_label_ {"ProfileNameLabel", ""}
juce::TextButton	remove_row_button_ {juce::translate("Clear ALL rows")}
juce::TextButton	remove_unassigned_button_ {juce::translate("Remove unassigned rows")}
juce::TextButton	rescan_button_ {juce::translate("Rescan MIDI devices")}
size_t	row_to_select_ {0}
juce::TextButton	save_button_ {juce::translate("Save")}
juce::TextButton	settings_button_ {juce::translate("Settings")}
std::unique_ptr< juce::DialogWindow >	settings_dialog_
SettingsManager &	settings_manager_
juce::Label	title_label_ {"Title", "MIDI2LR"}
juce::DropShadowEffect	title_shadow_
juce::Label	version_label_

Constructor & Destructor Documentation

MainContentComponent() [1/3]

MainContentComponent::MainContentComponent	(	const CommandSet &	command_set,
		Profile &	profile,
		ProfileManager &	profile_manager,
		SettingsManager &	settings_manager,
		LrIpcOut &	lr_ipc_out,
		MidiReceiver &	midi_receiver,
		MidiSender &	midi_sender
	)

    : ResizableLayout{this}, command_table_model_(command_set, profile), lr_ipc_out_{lr_ipc_out},
    midi_receiver_{midi_receiver}, midi_sender_{midi_sender}, profile_(profile),
    profile_manager_(profile_manager), settings_manager_(settings_manager) {
   setSize(kMainWidth, kMainHeight);
}
 
catch (const std::exception& e) {
   rsj::ExceptionResponse(e);
   throw;
}

~MainContentComponent()

MainContentComponent::~MainContentComponent

(

)

{
   settings_manager_.SetDefaultProfile(profile_name_label_.getText());
}

MainContentComponent() [2/3]

MainContentComponent::MainContentComponent ( const MainContentComponent &  other )

delete

MainContentComponent() [3/3]

MainContentComponent::MainContentComponent ( MainContentComponent &&  other )

delete

Member Function Documentation

handleAsyncUpdate()

void MainContentComponent::handleAsyncUpdate ( )

overrideprivate

{
   try {
      /* Update the last command label and set its color to green */
      command_label_.setText(last_command_, juce::NotificationType::dontSendNotification);
      command_label_.setColour(juce::Label::backgroundColourId, juce::Colours::greenyellow);
      startTimer(1000);
      /* Update the command table to add and/or select row corresponding to midi command */
      command_table_.updateContent();
      command_table_.selectRow(gsl::narrow_cast<int>(row_to_select_));
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Init()

void MainContentComponent::Init

(

)

{
   try {
      midi_receiver_.AddCallback(this, &MainContentComponent::MidiCmdCallback);
      lr_ipc_out_.AddCallback(this, &MainContentComponent::LrIpcOutCallback);
      profile_manager_.AddCallback(this, &MainContentComponent::ProfileChanged);
 
      /* Main title */
      StandardLabelSettings(title_label_);
      title_label_.setFont(juce::Font {36.F, juce::Font::bold});
      title_label_.setComponentEffect(&title_shadow_);
      title_label_.setBounds(kMainLeft, 10, kFullWidth, 30);
      addToLayout(&title_label_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(title_label_);
 
      /* Version label */
      StandardLabelSettings(version_label_);
      version_label_.setBounds(kMainLeft, 40, kFullWidth, 10);
      addToLayout(&version_label_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(version_label_);
 
      /* Connection status */
      StandardLabelSettings(connection_label_);
      connection_label_.setColour(juce::Label::textColourId, juce::Colours::black);
      connection_label_.setColour(juce::Label::backgroundColourId, juce::Colours::red);
      connection_label_.setJustificationType(juce::Justification::centred);
      connection_label_.setBounds(200, 15, kConnectionLabelWidth, kStandardHeight);
      addToLayout(&connection_label_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(connection_label_);
 
      /* Load button */
      load_button_.setBounds(kFirstButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
      addToLayout(&load_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(load_button_);
      load_button_.onClick = [this] {
         if (profile_.ProfileUnsaved()) {
            if (juce::NativeMessageBox::showYesNoBox(juce::AlertWindow::WarningIcon,
                    juce::translate("MIDI2LR profiles"),
                    juce::translate("Profile changed. Do you want to save your changes? If you "
                                    "continue without saving, your changes will be lost."))) {
               SaveProfile();
            }
         }
         juce::File profile_directory {settings_manager_.GetProfileDirectory()};
         const auto directory_saved {profile_directory.exists()};
         if (!directory_saved) [[unlikely]] {
            profile_directory = juce::File::getSpecialLocation(juce::File::userDocumentsDirectory);
         }
         juce::FileChooser chooser {
             juce::translate("Open profile"), profile_directory, "*.xml", true};
         if (chooser.browseForFileToOpen()) {
            if (const auto parsed {juce::parseXML(chooser.getResult())}) {
               const auto new_profile {chooser.getResult()};
               lr_ipc_out_.SendCommand(fmt::format(FMT_STRING("ChangedToFullPath {}\n"),
                   new_profile.getFullPathName().toStdString()));
               profile_name_label_.setText(new_profile.getFileName(),
                   juce::NotificationType::dontSendNotification);
               profile_.FromXml(parsed.get());
               command_table_.updateContent();
               command_table_.repaint();
               if (!directory_saved) [[unlikely]] { /* haven't saved a directory yet */
                  settings_manager_.SetProfileDirectory(
                      new_profile.getParentDirectory().getFullPathName());
               }
            }
            else {
               rsj::Log(fmt::format(FMT_STRING("Unable to load profile {}."),
                   chooser.getResult().getFullPathName().toStdString()));
            }
         }
      };
 
      /* Save button */
      save_button_.setBounds(kSecondButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
      addToLayout(&save_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(save_button_);
      save_button_.onClick = [this] { SaveProfile(); };
 
      /* Settings button */
      settings_button_.setBounds(kThirdButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
      addToLayout(&settings_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(settings_button_);
      settings_button_.onClick = [this] {
         juce::DialogWindow::LaunchOptions dialog_options;
         dialog_options.dialogTitle = juce::translate("Settings");
         /* create new object */
         auto component {std::make_unique<SettingsComponent>(settings_manager_)};
         component->Init();
         dialog_options.content.setOwned(component.release());
         dialog_options.content->setSize(400, 300);
         settings_dialog_.reset(dialog_options.create());
         settings_dialog_->setVisible(true);
      };
 
      /* Command Table */
      command_table_.setModel(&command_table_model_);
      command_table_.setBounds(kMainLeft, kCommandTableY, kFullWidth, kCommandTableHeight);
      addToLayout(&command_table_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(command_table_);
 
      /* Profile name label */
      StandardLabelSettings(profile_name_label_);
      profile_name_label_.setColour(juce::Label::textColourId, juce::Colours::black);
      profile_name_label_.setBounds(kMainLeft, kProfileNameY, kLabelWidth, kStandardHeight);
      profile_name_label_.setJustificationType(juce::Justification::centred);
      addToLayout(&profile_name_label_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(profile_name_label_);
 
      /* Last MIDI command */
      StandardLabelSettings(command_label_);
      command_label_.setBounds(kCommandLabelX, kCommandLabelY, kLabelWidth, kStandardHeight);
      addToLayout(&command_label_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(command_label_);
 
      /* Remove row button */
      remove_row_button_.setBounds(kFirstButtonX, kBottomButtonY, kButtonWidth, kStandardHeight);
      addToLayout(&remove_row_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(remove_row_button_);
      remove_row_button_.onClick = [this] {
         if (command_table_.getNumRows() > 0) {
            profile_.RemoveAllRows();
            command_table_.updateContent();
         }
      };
 
      /* Rescan MIDI button */
      rescan_button_.setBounds(kSecondButtonX, kBottomButtonY, kButtonWidth, kStandardHeight);
      addToLayout(&rescan_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(rescan_button_);
      rescan_button_.onClick = [this] {
         /* Re-enumerate MIDI IN and OUT devices */
         midi_receiver_.RescanDevices();
         midi_sender_.RescanDevices();
         /* Send new CC parameters to MIDI Out devices */
         lr_ipc_out_.SendCommand("FullRefresh 1\n");
      };
 
      /* Disconnect button */
      disconnect_button_.setBounds(kThirdButtonX, kBottomButtonY, kButtonWidth, kStandardHeight);
      disconnect_button_.setClickingTogglesState(true);
      addToLayout(&disconnect_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(disconnect_button_);
      disconnect_button_.onClick = [this] {
         if (disconnect_button_.getToggleState()) {
            lr_ipc_out_.SendingStop();
            rsj::Log("Sending halted.");
         }
         else {
            lr_ipc_out_.SendingRestart();
            rsj::Log("Sending restarted.");
         }
      };
 
      /* Delete unassigned rows */
      remove_unassigned_button_.setBounds(kFirstButtonX, kBottomButtonY2, kButtonWidth,
          kStandardHeight);
      addToLayout(&remove_unassigned_button_, anchorMidLeft, anchorMidRight);
      addAndMakeVisible(remove_unassigned_button_);
      remove_unassigned_button_.onClick = [this] {
         profile_.RemoveUnassignedMessages();
         command_table_.updateContent();
      };
 
      /* Try to load a default.xml if the user has not set a profile directory */
      if (settings_manager_.GetProfileDirectory().isEmpty()) {
         const auto filename {rsj::AppDataFilePath(kDefaultsFile)};
         const auto default_profile {juce::File(filename.data())};
         if (const auto parsed {juce::parseXML(default_profile)}) {
            profile_.FromXml(parsed.get());
            command_table_.updateContent();
         }
      }
      else {
         const auto last_prof {settings_manager_.GetDefaultProfile()};
         if (last_prof != juce::String()) { profile_manager_.SwitchToProfile(last_prof); }
         else { /* otherwise use the last profile from the profile directory */
            profile_manager_.SwitchToProfile(0);
         }
      }
 
      /* turn it on */
      activateLayout();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

LrIpcOutCallback()

void MainContentComponent::LrIpcOutCallback ( bool  connected, bool  sending_blocked  )

private

{
   try {
      const juce::MessageManagerLock mm_lock; /* as not called in message loop */
      if (connected) {
         if (sending_blocked) { UpdateConnectionLabel("Sending halted", juce::Colours::yellow); }
         else {
            UpdateConnectionLabel("Connected to Lightroom", juce::Colours::greenyellow);
         }
      }
      else {
         UpdateConnectionLabel("Not connected to Lightroom", juce::Colours::red);
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

MidiCmdCallback()

void MainContentComponent::MidiCmdCallback ( rsj::MidiMessage  mm )

private

{
   try {
      /* Display the MIDI parameters and add/highlight row in table corresponding to the message msg
       * is 1-based for channel, which display expects */
      const rsj::MidiMessageId msg {mm};
      last_command_ = fmt::format(FMT_STRING("{}: {}{} [{}]"), msg.channel, mm.message_type_byte,
          msg.control_number, mm.value);
      profile_.InsertUnassigned(msg);
      row_to_select_ = gsl::narrow_cast<size_t>(profile_.GetRowForMessage(msg));
      triggerAsyncUpdate();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

operator=() [1/2]

MainContentComponent & MainContentComponent::operator= ( const MainContentComponent &  other )

delete

operator=() [2/2]

MainContentComponent & MainContentComponent::operator= ( MainContentComponent &&  other )

delete

paint()

void MainContentComponent::paint ( juce::Graphics &  g )

overrideprivate

{ //-V2009 overridden method
   try {
      g.fillAll(juce::Colours::white);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

ProfileChanged()

void MainContentComponent::ProfileChanged ( juce::XmlElement *  xml_element, const juce::String &  file_name  )

private

{                                  //-V2009 overridden method
   try {
      {
         const juce::MessageManagerLock mm_lock;
         profile_.FromXml(xml_element);
         command_table_.updateContent();
         profile_name_label_.setText(file_name, juce::NotificationType::dontSendNotification);
      }
      /* Send new CC parameters to MIDI Out devices */
      lr_ipc_out_.SendCommand("FullRefresh 1\n");
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

SaveProfile()

void MainContentComponent::SaveProfile

(

)

const

{
   juce::File profile_directory {settings_manager_.GetProfileDirectory()};
   if (!profile_directory.exists()) {
      profile_directory = juce::File::getSpecialLocation(juce::File::userDocumentsDirectory);
   }
   juce::FileChooser chooser {juce::translate("Save profile"), profile_directory, "*.xml", true};
   if (chooser.browseForFileToSave(true)) {
      const auto selected_file {chooser.getResult().withFileExtension("xml")};
      profile_.ToXmlFile(selected_file);
   }
}

timerCallback()

void MainContentComponent::timerCallback ( )

overrideprivate

{
   try {
      /* reset the command label's background to white */
      command_label_.setColour(juce::Label::backgroundColourId, juce::Colours::white);
      juce::Timer::stopTimer();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

UpdateConnectionLabel()

void MainContentComponent::UpdateConnectionLabel ( const char *  text, juce::Colour  colour  )

private

{
   try {
      connection_label_.setText(juce::translate(text),
          juce::NotificationType::dontSendNotification);
      connection_label_.setColour(juce::Label::backgroundColourId, colour);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e);
      throw;
   }
}

Member Data Documentation

command_label_

juce::Label MainContentComponent::command_label_ {"Command", ""}

private

{"Command", ""};

command_table_

CommandTable MainContentComponent::command_table_ {"Table", nullptr}

private

{"Table", nullptr};

command_table_model_

CommandTableModel MainContentComponent::command_table_model_

private

connection_label_

juce::Label MainContentComponent::connection_label_ {"Connection", juce::translate("Not connected to Lightroom")}

private

{"Connection", juce::translate("Not connected to Lightroom")};

disconnect_button_

juce::TextButton MainContentComponent::disconnect_button_ {juce::translate("Halt sending to Lightroom")}

private

{juce::translate("Halt sending to Lightroom")};

last_command_

juce::String MainContentComponent::last_command_

private

load_button_

juce::TextButton MainContentComponent::load_button_ {juce::translate("Load")}

private

{juce::translate("Load")};

lr_ipc_out_

LrIpcOut& MainContentComponent::lr_ipc_out_

private

midi_receiver_

MidiReceiver& MainContentComponent::midi_receiver_

private

midi_sender_

MidiSender& MainContentComponent::midi_sender_

private

profile_

Profile& MainContentComponent::profile_

private

profile_manager_

ProfileManager& MainContentComponent::profile_manager_

private

profile_name_label_

juce::Label MainContentComponent::profile_name_label_ {"ProfileNameLabel", ""}

private

{"ProfileNameLabel", ""};

remove_row_button_

juce::TextButton MainContentComponent::remove_row_button_ {juce::translate("Clear ALL rows")}

private

{juce::translate("Clear ALL rows")};

remove_unassigned_button_

juce::TextButton MainContentComponent::remove_unassigned_button_ {juce::translate("Remove unassigned rows")}

private

{juce::translate("Remove unassigned rows")};

rescan_button_

juce::TextButton MainContentComponent::rescan_button_ {juce::translate("Rescan MIDI devices")}

private

{juce::translate("Rescan MIDI devices")};

row_to_select_

size_t MainContentComponent::row_to_select_ {0}

private

{0};

save_button_

juce::TextButton MainContentComponent::save_button_ {juce::translate("Save")}

private

{juce::translate("Save")};

settings_button_

juce::TextButton MainContentComponent::settings_button_ {juce::translate("Settings")}

private

{juce::translate("Settings")};

settings_dialog_

std::unique_ptr<juce::DialogWindow> MainContentComponent::settings_dialog_

private

settings_manager_

SettingsManager& MainContentComponent::settings_manager_

private

title_label_

juce::Label MainContentComponent::title_label_ {"Title", "MIDI2LR"}

private

{"Title", "MIDI2LR"};

title_shadow_

juce::DropShadowEffect MainContentComponent::title_shadow_

private

version_label_

juce::Label MainContentComponent::version_label_

private

Initial value:

{
       "Version", juce::translate("Version ") + juce::String {ProjectInfo::versionString}}

                            {
       "Version", juce::translate("Version ") + juce::String {ProjectInfo::versionString}};

---

The documentation for this class was generated from the following files:

• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/MainComponent.h
• C:/Users/rsjaf/source/repos/MIDI2LR/src/application/MainComponent.cpp