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	AddComponent (juce::Component &component, int x, int y, int width, int height)
void	DisconnectClicked ()
void	handleAsyncUpdate () override
void	LoadClicked ()
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	RemoveAllRowsClicked ()
void	RemoveUnassignedClicked ()
void	RescanClicked ()
void	SettingsClicked ()
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_allrows_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, std::source_location::current());
   throw;
}

~MainContentComponent()

MainContentComponent::~MainContentComponent

(

)

{
   settings_manager_.SetDefaultProfile(profile_name_label_.getText());
   juce::Timer::stopTimer();
}

MainContentComponent() [2/3]

MainContentComponent::MainContentComponent ( const MainContentComponent &  other )

delete

MainContentComponent() [3/3]

MainContentComponent::MainContentComponent ( MainContentComponent &&  other )

delete

Member Function Documentation

AddComponent()

void MainContentComponent::AddComponent ( juce::Component &  component, int  x, int  y, int  width, int  height  )

private

{
   component.setBounds(x, y, width, height);
   ResizableLayout::addToLayout(&component, anchorMidLeft, anchorMidRight);
   juce::Component::addAndMakeVisible(component);
}

DisconnectClicked()

void MainContentComponent::DisconnectClicked ( )

private

{
   if (disconnect_button_.getToggleState()) {
      lr_ipc_out_.SendingStop();
      rsj::Log("Sending halted.", std::source_location::current());
   }
   else {
      lr_ipc_out_.SendingRestart();
      rsj::Log("Sending restarted.", std::source_location::current());
   }
}

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);
      juce::Timer::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, std::source_location::current());
      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 {juce::FontOptions(36.F, juce::Font::bold)});
      title_label_.setComponentEffect(&title_shadow_);
      AddComponent(title_label_, kMainLeft, 10, kFullWidth, 30);
 
      /* Version label */
      StandardLabelSettings(version_label_);
      AddComponent(version_label_, kMainLeft, 40, kFullWidth, 10);
 
      /* 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);
      AddComponent(connection_label_, 200, 15, kConnectionLabelWidth, kStandardHeight);
 
      /* Load button */
      AddComponent(load_button_, kFirstButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      load_button_.onClick = std::bind_front<&MainContentComponent::LoadClicked>(this);
#else
      load_button_.onClick = std::bind_front(&MainContentComponent::LoadClicked, this);
#endif
 
      /* Save button */
      AddComponent(save_button_, kSecondButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      save_button_.onClick = std::bind_front<&MainContentComponent::SaveProfile>(this);
#else
      save_button_.onClick = std::bind_front(&MainContentComponent::SaveProfile, this);
#endif
 
      /* Settings button */
      AddComponent(settings_button_, kThirdButtonX, kTopButtonY, kButtonWidth, kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      settings_button_.onClick = std::bind_front<&MainContentComponent::SettingsClicked>(this);
#else
      settings_button_.onClick = std::bind_front(&MainContentComponent::SettingsClicked, this);
#endif
 
      /* Command Table */
      command_table_.setModel(&command_table_model_);
      AddComponent(command_table_, kMainLeft, kCommandTableY, kFullWidth, kCommandTableHeight);
 
      /* Profile name label */
      StandardLabelSettings(profile_name_label_);
      profile_name_label_.setColour(juce::Label::textColourId, juce::Colours::black);
      profile_name_label_.setJustificationType(juce::Justification::centred);
      AddComponent(profile_name_label_, kMainLeft, kProfileNameY, kLabelWidth, kStandardHeight);
 
      /* Last MIDI command */
      StandardLabelSettings(command_label_);
      AddComponent(command_label_, kCommandLabelX, kCommandLabelY, kLabelWidth, kStandardHeight);
 
      /* Remove row button */
      AddComponent(remove_allrows_button_, kFirstButtonX, kBottomButtonY, kButtonWidth,
          kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      remove_allrows_button_.onClick =
          std::bind_front<&MainContentComponent::RemoveAllRowsClicked>(this);
#else
      remove_allrows_button_.onClick =
          std::bind_front(&MainContentComponent::RemoveAllRowsClicked, this);
#endif
 
      /* Rescan MIDI button */
      AddComponent(rescan_button_, kSecondButtonX, kBottomButtonY, kButtonWidth, kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      rescan_button_.onClick = std::bind_front<&MainContentComponent::RescanClicked>(this);
#else
      rescan_button_.onClick = std::bind_front(&MainContentComponent::RescanClicked, this);
#endif
 
      /* Disconnect button */
      disconnect_button_.setClickingTogglesState(true);
      AddComponent(disconnect_button_, kThirdButtonX, kBottomButtonY, kButtonWidth,
          kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      disconnect_button_.onClick = std::bind_front<&MainContentComponent::DisconnectClicked>(this);
#else
      disconnect_button_.onClick = std::bind_front(&MainContentComponent::DisconnectClicked, this);
#endif
 
      /* Delete unassigned rows */
      AddComponent(remove_unassigned_button_, kFirstButtonX, kBottomButtonY2, kButtonWidth,
          kStandardHeight);
#if __cpp_lib_bind_front >= 202'306L
      remove_unassigned_button_.onClick =
          std::bind_front<&MainContentComponent::RemoveUnassignedClicked>(this);
#else
      remove_unassigned_button_.onClick =
          std::bind_front(&MainContentComponent::RemoveUnassignedClicked, this);
#endif
 
      /* 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 */
      ResizableLayout::activateLayout();
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

LoadClicked()

void MainContentComponent::LoadClicked ( )

private

{
   try {
      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()),
                std::source_location::current());
         }
      }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

LrIpcOutCallback()

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

private

{
   const juce::MessageManagerLock mm_lock; /* as not called in message loop */
   const auto& [text, color] {kConnectionStatus.at({connected, sending_blocked})};
   UpdateConnectionLabel(text, color);
}

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, std::source_location::current());
      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
   g.fillAll(juce::Colours::white);
}

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, std::source_location::current());
      throw;
   }
}

RemoveAllRowsClicked()

void MainContentComponent::RemoveAllRowsClicked ( )

private

{
   if (command_table_.getNumRows() > 0) {
      profile_.RemoveAllRows();
      command_table_.updateContent();
   }
}

RemoveUnassignedClicked()

void MainContentComponent::RemoveUnassignedClicked ( )

private

{
   profile_.RemoveUnassignedMessages();
   command_table_.updateContent();
}

RescanClicked()

void MainContentComponent::RescanClicked ( )

private

{
   /* 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");
}

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);
   }
}

SettingsClicked()

void MainContentComponent::SettingsClicked ( )

private

{
   try {
      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);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

timerCallback()

void MainContentComponent::timerCallback ( )

overrideprivate

{
   /* reset the command label's background to white */
   command_label_.setColour(juce::Label::backgroundColourId, juce::Colours::white);
   juce::Timer::stopTimer();
}

UpdateConnectionLabel()

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

private

{
   connection_label_.setText(juce::translate(text), juce::NotificationType::dontSendNotification);
   connection_label_.setColour(juce::Label::backgroundColourId, colour);
}

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_allrows_button_

juce::TextButton MainContentComponent::remove_allrows_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