MIDI2LRApplication Class Reference

Inheritance diagram for MIDI2LRApplication:

Public Member Functions
void	anotherInstanceStarted (const juce::String &command_line) override
void	anotherInstanceStarted (const juce::String &command_line) override
const juce::String	getApplicationName () override
const juce::String	getApplicationName () override
const juce::String	getApplicationVersion () override
const juce::String	getApplicationVersion () override
void	initialise (const juce::String &command_line) override
void	initialise (const juce::String &command_line) override
bool	moreThanOneInstanceAllowed () noexcept override
bool	moreThanOneInstanceAllowed () noexcept override
void	shutdown () override
void	shutdown () override
void	systemRequestedQuit () override
void	systemRequestedQuit () override
void	unhandledException (const std::exception *e, const juce::String &source_filename, int line_number) override
void	unhandledException (const std::exception *e, const juce::String &source_filename, int line_number) override

Private Member Functions
void	DefaultProfileSave () noexcept
void	DefaultProfileSave () noexcept
void	InitializeThreads ()
void	InitializeThreads ()
void	LinkControlsModels () noexcept
void	LinkControlsModels () noexcept
void	LoadControlsModel ()
void	LoadControlsModel ()
void	SaveControlsModel () const noexcept
void	SaveControlsModel () const noexcept
void	SetAppFont () const noexcept
void	SetAppFont () const noexcept
void	SetupUi ()
void	SetupUi ()
void	StartServices ()
void	StartServices ()
void	StartThread (std::future< void > &thread, const char *threadName)
void	StartThread (std::future< void > &thread, const char *threadName)
void	StopServices ()
void	StopServices ()

Private Attributes
const CommandSet	command_set_ {}
ControlsModel	controls_model_ {}
Devices	devices_ {}
const LookAndFeelMIDI2LR	dummy1_
const SetLogger	dummy_ {}
asio::executor_work_guard< asio::io_context::executor_type >	guard_
asio::io_context	io_context_ {}
std::future< void >	io_thread0_
std::future< void >	io_thread1_
LrIpcIn	lr_ipc_in_ {controls_model_, profile_manager_, profile_, midi_sender_, io_context_}
LrIpcOut	lr_ipc_out_
std::unique_ptr< MainWindow >	main_window_ {nullptr}
MidiReceiver	midi_receiver_ {devices_}
MidiSender	midi_sender_ {devices_}
Profile	profile_ {command_set_}
ProfileManager	profile_manager_ {controls_model_, profile_, lr_ipc_out_, midi_receiver_}
SettingsManager	settings_manager_ {profile_manager_, lr_ipc_out_}
VersionChecker	version_checker_ {settings_manager_}

Member Function Documentation

anotherInstanceStarted() [1/2]

void MIDI2LRApplication::anotherInstanceStarted ( const juce::String &  command_line )

inlineoverride

   {
      if (command_line == kShutDownString) { systemRequestedQuit(); }
   }

anotherInstanceStarted() [2/2]

void MIDI2LRApplication::anotherInstanceStarted ( const juce::String &  command_line )

inlineoverride

   {
      if (command_line == kShutDownString) { systemRequestedQuit(); }
   }

DefaultProfileSave() [1/2]

void MIDI2LRApplication::DefaultProfileSave ( )

inlineprivatenoexcept

   {
      try {
         const auto file_name {rsj::AppDataFilePath(kDefaultsFile)};
         const auto profile_file {juce::File(file_name.data())};
         profile_.ToXmlFile(profile_file);
         rsj::Log(fmt::format(FMT_STRING("Default profile saved to {}."),
                      profile_file.getFullPathName().toStdString()),
             std::source_location::current());
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

DefaultProfileSave() [2/2]

void MIDI2LRApplication::DefaultProfileSave ( )

inlineprivatenoexcept

   {
      try {
         const auto file_name {rsj::AppDataFilePath(kDefaultsFile)};
         const auto profile_file {juce::File(file_name.data())};
         profile_.ToXmlFile(profile_file);
         rsj::Log(fmt::format(FMT_STRING("Default profile saved to {}."),
                      profile_file.getFullPathName().toStdString()),
             std::source_location::current());
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

getApplicationName() [1/2]

const juce::String MIDI2LRApplication::getApplicationName ( )

inlineoverride

   {
      return ProjectInfo::projectName;
   }

getApplicationName() [2/2]

const juce::String MIDI2LRApplication::getApplicationName ( )

inlineoverride

   {
      return ProjectInfo::projectName;
   }

getApplicationVersion() [1/2]

const juce::String MIDI2LRApplication::getApplicationVersion ( )

inlineoverride

   {
      return ProjectInfo::versionString;
   }

getApplicationVersion() [2/2]

const juce::String MIDI2LRApplication::getApplicationVersion ( )

inlineoverride

   {
      return ProjectInfo::versionString;
   }

initialise() [1/2]

void MIDI2LRApplication::initialise ( const juce::String &  command_line )

inlineoverride

   {
      /*Called when the application starts. This will be called once to let the application do
       * whatever initialization it needs, create its windows, etc. After the method returns, the
       * normal event - dispatch loop will be run, until the quit() method is called, at which
       * point the shutdown() method will be called to let the application clear up anything it
       * needs to delete. If during the initialise() method, the application decides not to
       * start-up after all, it can just call the quit() method and the event loop won't be
       * run. */
      try {
         if (command_line != kShutDownString) {
            InitializeThreads();
            LinkControlsModels();
            /* Need to start main window before ipc so it's already registered its callbacks and can
             * receive messages */
            SetupUi();
            StartServices();
         }
         else {
            quit();
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

initialise() [2/2]

void MIDI2LRApplication::initialise ( const juce::String &  command_line )

inlineoverride

   {
      /*Called when the application starts. This will be called once to let the application do
       * whatever initialization it needs, create its windows, etc. After the method returns, the
       * normal event - dispatch loop will be run, until the quit() method is called, at which
       * point the shutdown() method will be called to let the application clear up anything it
       * needs to delete. If during the initialise() method, the application decides not to
       * start-up after all, it can just call the quit() method and the event loop won't be
       * run. */
      try {
         if (command_line != kShutDownString) {
            InitializeThreads();
            LinkControlsModels();
            /* Need to start main window before ipc so it's already registered its callbacks and can
             * receive messages */
            SetupUi();
            StartServices();
         }
         else {
            quit();
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

InitializeThreads() [1/2]

void MIDI2LRApplication::InitializeThreads ( )

inlineprivate

   {
      MIDI2LR_FAST_FLOATS;
      rsj::LabelThread(MIDI2LR_UC_LITERAL("Main MIDI2LR thread"));
      StartThread(io_thread0_, "io_thread0_");
      StartThread(io_thread1_, "io_thread1_");
   }

InitializeThreads() [2/2]

void MIDI2LRApplication::InitializeThreads ( )

inlineprivate

   {
      MIDI2LR_FAST_FLOATS;
      rsj::LabelThread(MIDI2LR_UC_LITERAL("Main MIDI2LR thread"));
      StartThread(io_thread0_, "io_thread0_");
      StartThread(io_thread1_, "io_thread1_");
   }

LinkControlsModels() [1/2]

void MIDI2LRApplication::LinkControlsModels ( )

inlineprivatenoexcept

   {
      CCoptions::LinkToControlsModel(&controls_model_);
      PWoptions::LinkToControlsModel(&controls_model_);
   }

LinkControlsModels() [2/2]

void MIDI2LRApplication::LinkControlsModels ( )

inlineprivatenoexcept

   {
      CCoptions::LinkToControlsModel(&controls_model_);
      PWoptions::LinkToControlsModel(&controls_model_);
   }

LoadControlsModel() [1/2]

void MIDI2LRApplication::LoadControlsModel ( )

inlineprivate

   {
      try {
         const fs::path px {rsj::AppDataFilePath(kSettingsFileX)};
         if (std::ifstream in_file {px}; in_file.is_open() && !in_file.eof()) {
#pragma warning(suppress : 26414) /* too large to construct on stack */
            const auto iarchive {std::make_unique<cereal::XMLInputArchive>(in_file)};
            (*iarchive)(controls_model_);
            rsj::Log(fmt::format(FMT_STRING("ControlsModel archive in Main loaded from {}."),
                         px.string()),
                std::source_location::current());
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

LoadControlsModel() [2/2]

void MIDI2LRApplication::LoadControlsModel ( )

inlineprivate

   {
      try {
         const fs::path px {rsj::AppDataFilePath(kSettingsFileX)};
         if (std::ifstream in_file {px}; in_file.is_open() && !in_file.eof()) {
#pragma warning(suppress : 26414) /* too large to construct on stack */
            const auto iarchive {std::make_unique<cereal::XMLInputArchive>(in_file)};
            (*iarchive)(controls_model_);
            rsj::Log(fmt::format(FMT_STRING("ControlsModel archive in Main loaded from {}."),
                         px.string()),
                std::source_location::current());
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

moreThanOneInstanceAllowed() [1/2]

bool MIDI2LRApplication::moreThanOneInstanceAllowed ( )

inlineoverridenoexcept

{ return false; }

moreThanOneInstanceAllowed() [2/2]

bool MIDI2LRApplication::moreThanOneInstanceAllowed ( )

inlineoverridenoexcept

{ return false; }

SaveControlsModel() [1/2]

void MIDI2LRApplication::SaveControlsModel ( ) const

inlineprivatenoexcept

   {
      try {
         const fs::path p {rsj::AppDataFilePath(kSettingsFileX)};
         if (std::ofstream outfile {p, std::ios::trunc}; outfile.is_open()) {
#pragma warning(suppress : 26414) /* too large to construct on stack */
            const auto oarchive {std::make_unique<cereal::XMLOutputArchive>(outfile)};
            (*oarchive)(controls_model_);
            rsj::Log(fmt::format(FMT_STRING("ControlsModel archive in Main saved to {}."),
                         p.string()),
                std::source_location::current());
         }
         else {
            rsj::LogAndAlertError(juce::translate("Unable to save settings.xml"),
                "Unable to save settings.xml", std::source_location::current());
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

SaveControlsModel() [2/2]

void MIDI2LRApplication::SaveControlsModel ( ) const

inlineprivatenoexcept

   {
      try {
         const fs::path p {rsj::AppDataFilePath(kSettingsFileX)};
         if (std::ofstream outfile {p, std::ios::trunc}; outfile.is_open()) {
#pragma warning(suppress : 26414) /* too large to construct on stack */
            const auto oarchive {std::make_unique<cereal::XMLOutputArchive>(outfile)};
            (*oarchive)(controls_model_);
            rsj::Log(fmt::format(FMT_STRING("ControlsModel archive in Main saved to {}."),
                         p.string()),
                std::source_location::current());
         }
         else {
            rsj::LogAndAlertError(juce::translate("Unable to save settings.xml"),
                "Unable to save settings.xml", std::source_location::current());
         }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

SetAppFont() [1/2]

void MIDI2LRApplication::SetAppFont ( ) const

inlineprivatenoexcept

   {
      try {
         const auto& lang {rsj::ToLower(command_set_.GetLanguage())};
         const std::unordered_map<std::string, std::pair<std::string, std::string>> font_map {
             {     "ko",                                {"NotoSansKR-Regular.otf", ""}},
             {  "zh_tw",                                {"NotoSansTC-Regular.otf", ""}},
             {  "zh_cn",                                {"NotoSansSC-Regular.otf", ""}},
             {     "ja",                                {"NotoSansJP-Regular.otf", ""}},
             {"default", {"NotoSans-Regular-MIDI2LR.ttf", "NotoSans-Bold-MIDI2LR.ttf"}}
         };
         auto font_pair = font_map.find(lang);
         if (font_pair == font_map.end()) { font_pair = font_map.find("default"); }
         const auto& primary_font_name = font_pair->second.first;
         const auto& bold_font_name = font_pair->second.second;
         LoadFont(primary_font_name, true);
         if (!bold_font_name.empty()) { LoadFont(bold_font_name, false); }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

SetAppFont() [2/2]

void MIDI2LRApplication::SetAppFont ( ) const

inlineprivatenoexcept

   {
      try {
         const auto& lang {rsj::ToLower(command_set_.GetLanguage())};
         const std::unordered_map<std::string, std::pair<std::string, std::string>> font_map {
             {     "ko",                                {"NotoSansKR-Regular.otf", ""}},
             {  "zh_tw",                                {"NotoSansTC-Regular.otf", ""}},
             {  "zh_cn",                                {"NotoSansSC-Regular.otf", ""}},
             {     "ja",                                {"NotoSansJP-Regular.otf", ""}},
             {"default", {"NotoSans-Regular-MIDI2LR.ttf", "NotoSans-Bold-MIDI2LR.ttf"}}
         };
         auto font_pair = font_map.find(lang);
         if (font_pair == font_map.end()) { font_pair = font_map.find("default"); }
         const auto& primary_font_name = font_pair->second.first;
         const auto& bold_font_name = font_pair->second.second;
         LoadFont(primary_font_name, true);
         if (!bold_font_name.empty()) { LoadFont(bold_font_name, false); }
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
      }
   }

SetupUi() [1/2]

void MIDI2LRApplication::SetupUi ( )

inlineprivate

   {
      SetAppFont();
      LoadControlsModel();
      main_window_ = std::make_unique<MainWindow>(getApplicationName(), command_set_, profile_,
          profile_manager_, settings_manager_, lr_ipc_out_, midi_receiver_, midi_sender_);
   }

SetupUi() [2/2]

void MIDI2LRApplication::SetupUi ( )

inlineprivate

   {
      SetAppFont();
      LoadControlsModel();
      main_window_ = std::make_unique<MainWindow>(getApplicationName(), command_set_, profile_,
          profile_manager_, settings_manager_, lr_ipc_out_, midi_receiver_, midi_sender_);
   }

shutdown() [1/2]

void MIDI2LRApplication::shutdown ( )

inlineoverride

   {
      /*Called to allow the application to clear up before exiting. After JUCEApplication::quit()
       * has been called, the event-dispatch loop will terminate, and this method will get called
       * to allow the application to sort itself out. Be careful that nothing happens in this method
       * that might rely on messages being sent, or any kind of window activity, because the message
       * loop is no longer running at this point. */
      StopServices();
      DefaultProfileSave();
      SaveControlsModel();
   }

shutdown() [2/2]

void MIDI2LRApplication::shutdown ( )

inlineoverride

   {
      /*Called to allow the application to clear up before exiting. After JUCEApplication::quit()
       * has been called, the event-dispatch loop will terminate, and this method will get called
       * to allow the application to sort itself out. Be careful that nothing happens in this method
       * that might rely on messages being sent, or any kind of window activity, because the message
       * loop is no longer running at this point. */
      StopServices();
      DefaultProfileSave();
      SaveControlsModel();
   }

StartServices() [1/2]

void MIDI2LRApplication::StartServices ( )

inlineprivate

   {
      midi_receiver_.Start();
      midi_sender_.Start();
      lr_ipc_out_.Start();
      lr_ipc_in_.Start();
      version_checker_.Start();
   }

StartServices() [2/2]

void MIDI2LRApplication::StartServices ( )

inlineprivate

   {
      midi_receiver_.Start();
      midi_sender_.Start();
      lr_ipc_out_.Start();
      lr_ipc_in_.Start();
      version_checker_.Start();
   }

StartThread() [1/2]

void MIDI2LRApplication::StartThread ( std::future< void > &  thread, const char *  threadName  )

inlineprivate

   {
      thread = std::async(std::launch::async, [this, threadName] {
#ifdef _WIN32
         const auto uwr = ww898::utf::convz<wchar_t>(threadName);
         rsj::LabelThread(uwr.c_str());
#else
         rsj::LabelThread(threadName);
#endif
         MIDI2LR_FAST_FLOATS;
         if constexpr (kNdebug) { io_context_.run(); }
         else {
            rsj::Log(fmt::format(FMT_STRING("{} ran {} handlers."), threadName, io_context_.run()),
                std::source_location::current());
         }
      });
   }

StartThread() [2/2]

void MIDI2LRApplication::StartThread ( std::future< void > &  thread, const char *  threadName  )

inlineprivate

   {
      thread = std::async(std::launch::async, [this, threadName] {
#ifdef _WIN32
         const auto uwr = ww898::utf::convz<wchar_t>(threadName);
         rsj::LabelThread(uwr.c_str());
#else
         rsj::LabelThread(threadName);
#endif
         MIDI2LR_FAST_FLOATS;
         if constexpr (kNdebug) { io_context_.run(); }
         else {
            rsj::Log(fmt::format(FMT_STRING("{} ran {} handlers."), threadName, io_context_.run()),
                std::source_location::current());
         }
      });
   }

StopServices() [1/2]

void MIDI2LRApplication::StopServices ( )

inlineprivate

   {
      /*Primary goals: 1) remove callbacks in LR_IPC_Out and MIDIReceiver before the callee is
       * destroyed, 2) stop additional threads in VersionChecker, LR_IPC_In, LR_IPC_Out and
       * MIDIReceiver. Add to this list if new threads or callback lists are developed in this
       * app. */
      midi_receiver_.Stop();
      lr_ipc_in_.Stop();
      lr_ipc_out_.Stop();
      version_checker_.Stop();
      io_context_.stop();
   }

StopServices() [2/2]

void MIDI2LRApplication::StopServices ( )

inlineprivate

   {
      /*Primary goals: 1) remove callbacks in LR_IPC_Out and MIDIReceiver before the callee is
       * destroyed, 2) stop additional threads in VersionChecker, LR_IPC_In, LR_IPC_Out and
       * MIDIReceiver. Add to this list if new threads or callback lists are developed in this
       * app. */
      midi_receiver_.Stop();
      lr_ipc_in_.Stop();
      lr_ipc_out_.Stop();
      version_checker_.Stop();
      io_context_.stop();
   }

systemRequestedQuit() [1/2]

void MIDI2LRApplication::systemRequestedQuit ( )

inlineoverride

   {
      /*This is called when the application is being asked to quit: you can ignore this request
       * and let the application carry on running, or call quit() to allow the application to
       * close. */
      try {
         constinit static std::once_flag of; /* function might be called twice during LR shutdown */
         std::call_once(of, [this] {
            if (profile_.ProfileUnsaved() && main_window_) {
               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."))) {
                  main_window_->SaveProfile();
               }
            }
            quit();
         });
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

systemRequestedQuit() [2/2]

void MIDI2LRApplication::systemRequestedQuit ( )

inlineoverride

   {
      /*This is called when the application is being asked to quit: you can ignore this request
       * and let the application carry on running, or call quit() to allow the application to
       * close. */
      try {
         constinit static std::once_flag of; /* function might be called twice during LR shutdown */
         std::call_once(of, [this] {
            if (profile_.ProfileUnsaved() && main_window_) {
               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."))) {
                  main_window_->SaveProfile();
               }
            }
            quit();
         });
      }
      catch (const std::exception& e) {
         rsj::ExceptionResponse(e, std::source_location::current());
         throw;
      }
   }

unhandledException() [1/2]

void MIDI2LRApplication::unhandledException ( const std::exception *  e, const juce::String &  source_filename, int  line_number  )

inlineoverride

   {
      /* If any unhandled exceptions make it through to the message dispatch loop, this callback
       * will be triggered, in case you want to log them or do some other type of error-handling. If
       * the type of exception is derived from the std::exception class, the pointer passed-in will
       * be valid. If the exception is of unknown type, this pointer will be null. */
      try {
         if (e) {
            const auto msgt {juce::translate("unhandled exception").toStdString()
                             + " {}, {} line {}. Total uncaught {}."};
            rsj::LogAndAlertError(fmt::format(msgt, e->what(), source_filename.toStdString(),
                                      line_number, std::uncaught_exceptions()),
                fmt::format(FMT_STRING("Unhandled exception {}, {} line {}. Total uncaught {}."),
                    e->what(), source_filename.toStdString(), line_number,
                    std::uncaught_exceptions()),
                std::source_location::current());
         }
         else {
            const auto msgt {juce::translate("unhandled exception").toStdString()
                             + " {} line {}. Total uncaught {}."};
            rsj::LogAndAlertError(fmt::format(msgt, source_filename.toStdString(), line_number,
                                      std::uncaught_exceptions()),
                fmt::format(FMT_STRING("Unhandled exception {} line {}. Total uncaught {}."),
                    source_filename.toStdString(), line_number, std::uncaught_exceptions()),
                std::source_location::current());
         }
      }
      catch (...) {
         /* we'll terminate anyway */
         std::terminate();
      }
      /* can't go on with the program */
      std::terminate();
   }

unhandledException() [2/2]

void MIDI2LRApplication::unhandledException ( const std::exception *  e, const juce::String &  source_filename, int  line_number  )

inlineoverride

   {
      /* If any unhandled exceptions make it through to the message dispatch loop, this callback
       * will be triggered, in case you want to log them or do some other type of error-handling. If
       * the type of exception is derived from the std::exception class, the pointer passed-in will
       * be valid. If the exception is of unknown type, this pointer will be null. */
      try {
         if (e) {
            const auto msgt {juce::translate("unhandled exception").toStdString()
                             + " {}, {} line {}. Total uncaught {}."};
            rsj::LogAndAlertError(fmt::format(msgt, e->what(), source_filename.toStdString(),
                                      line_number, std::uncaught_exceptions()),
                fmt::format(FMT_STRING("Unhandled exception {}, {} line {}. Total uncaught {}."),
                    e->what(), source_filename.toStdString(), line_number,
                    std::uncaught_exceptions()),
                std::source_location::current());
         }
         else {
            const auto msgt {juce::translate("unhandled exception").toStdString()
                             + " {} line {}. Total uncaught {}."};
            rsj::LogAndAlertError(fmt::format(msgt, source_filename.toStdString(), line_number,
                                      std::uncaught_exceptions()),
                fmt::format(FMT_STRING("Unhandled exception {} line {}. Total uncaught {}."),
                    source_filename.toStdString(), line_number, std::uncaught_exceptions()),
                std::source_location::current());
         }
      }
      catch (...) {
         /* we'll terminate anyway */
         std::terminate();
      }
      /* can't go on with the program */
      std::terminate();
   }

Member Data Documentation

command_set_

const CommandSet MIDI2LRApplication::command_set_ {}

private

{};

controls_model_

ControlsModel MIDI2LRApplication::controls_model_ {}

private

{};

devices_

Devices MIDI2LRApplication::devices_ {}

private

{};

dummy1_

const LookAndFeelMIDI2LR MIDI2LRApplication::dummy1_

private

dummy_

const SetLogger MIDI2LRApplication::dummy_ {}

private

{};

guard_

asio::executor_work_guard< asio::io_context::executor_type > MIDI2LRApplication::guard_

private

Initial value:

{
       asio::make_work_guard(io_context_)}

                                                                                {
       asio::make_work_guard(io_context_)};

io_context_

asio::io_context MIDI2LRApplication::io_context_ {}

private

{};

io_thread0_

std::future< void > MIDI2LRApplication::io_thread0_

private

io_thread1_

std::future< void > MIDI2LRApplication::io_thread1_

private

lr_ipc_in_

LrIpcIn MIDI2LRApplication::lr_ipc_in_ {controls_model_, profile_manager_, profile_, midi_sender_, io_context_}

private

{controls_model_, profile_manager_, profile_, midi_sender_, io_context_};

lr_ipc_out_

LrIpcOut MIDI2LRApplication::lr_ipc_out_

private

Initial value:

{
       command_set_, controls_model_, profile_, midi_sender_, midi_receiver_, io_context_}

                        {
       command_set_, controls_model_, profile_, midi_sender_, midi_receiver_, io_context_};

main_window_

std::unique_ptr< MainWindow > MIDI2LRApplication::main_window_ {nullptr}

private

{nullptr};

midi_receiver_

MidiReceiver MIDI2LRApplication::midi_receiver_ {devices_}

private

{devices_};

midi_sender_

MidiSender MIDI2LRApplication::midi_sender_ {devices_}

private

{devices_};

profile_

Profile MIDI2LRApplication::profile_ {command_set_}

private

{command_set_};

profile_manager_

ProfileManager MIDI2LRApplication::profile_manager_ {controls_model_, profile_, lr_ipc_out_, midi_receiver_}

private

{controls_model_, profile_, lr_ipc_out_, midi_receiver_};

settings_manager_

SettingsManager MIDI2LRApplication::settings_manager_ {profile_manager_, lr_ipc_out_}

private

{profile_manager_, lr_ipc_out_};

version_checker_

VersionChecker MIDI2LRApplication::version_checker_ {settings_manager_}

private

{settings_manager_};

---

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

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