CommandTableModel Class Reference

#include <CommandTableModel.h>

Inheritance diagram for CommandTableModel:

Public Member Functions
	CommandTableModel (const CommandSet &command_set, Profile &profile) noexcept
void	RemoveRow (size_t row)

Private Member Functions
CommandMenu *	CreateNewCommandMenu (int row_number, juce::Component *existing_component) const
int	getNumRows () override
void	paintCell (juce::Graphics &, int row_number, int column_id, int width, int height, bool row_is_selected) override
void	paintRowBackground (juce::Graphics &, int row_number, int width, int height, bool row_is_selected) override
juce::Component *	refreshComponentForCell (int row_number, int column_id, bool is_row_selected, juce::Component *existing_component) override
void	sortOrderChanged (int new_sort_column_id, bool is_forwards) override
CommandMenu *	UpdateCommandMenu (int row_number, gsl::not_null< CommandMenu * > command_select) const

Private Attributes
const CommandSet &	command_set_
Profile &	profile_

Constructor & Destructor Documentation

CommandTableModel()

CommandTableModel::CommandTableModel ( const CommandSet &  command_set, Profile &  profile  )

noexcept

    : command_set_ {command_set}, profile_ {profile}
{
}

Member Function Documentation

CreateNewCommandMenu()

CommandMenu * CommandTableModel::CreateNewCommandMenu ( int  row_number, juce::Component *  existing_component  ) const

private

{
   /* create a new command menu, delete old one if it exists */
   delete existing_component; // NOLINT(cppcoreguidelines-owning-memory)
   const auto& msg = profile_.GetMessageForNumber(gsl::narrow_cast<size_t>(row_number));
   auto new_select {std::make_unique<CommandMenu>(msg, command_set_, profile_)};
   new_select->SetSelectedItem(command_set_.CommandTextIndex(profile_.GetCommandForMessage(msg))
                               + 1);
   return new_select.release();
}

getNumRows()

int CommandTableModel::getNumRows ( )

inlineoverrideprivate

{ return gsl::narrow_cast<int>(profile_.Size()); }

paintCell()

void CommandTableModel::paintCell ( juce::Graphics &  g, int  row_number, int  column_id, int  width, int  height, bool  row_is_selected  )

overrideprivate

{
   try {
      g.setColour(juce::Colours::black);
      g.setFont(std::min(16.0F, static_cast<float>(height) * 0.7F));
      if (column_id != 1) { return; }
      if (const auto profile_size = profile_.Size();
          std::cmp_less_equal(profile_size, row_number)) {
         g.drawText("Unknown control", 0, 0, width, height, juce::Justification::centred);
         rsj::Log(fmt::format(FMT_STRING("Unknown control CommandTableModel::paintCell. {} rows in "
                                         "profile, row number to be painted is {}."),
                      profile_size, row_number),
             std::source_location::current());
         return;
      }
      const auto cmd {profile_.GetMessageForNumber(gsl::narrow_cast<size_t>(row_number))};
      const auto messageText {FormatMessageText(cmd)};
      g.drawText(messageText, 0, 0, width, height, juce::Justification::centredLeft);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

paintRowBackground()

void CommandTableModel::paintRowBackground ( juce::Graphics &  g, int  row_number, int  width, int  height, bool  row_is_selected  )

overrideprivate

{
   /* This must draw the background behind one of the rows in the table. The graphics context has
    * its origin at the row's top-left, and your method should fill the area specified by the width
    * and height parameters. Note that the rowNumber value may be greater than the number of rows in
    * your list, so be careful that you don't assume it's less than getNumRows(). */
   try {
      if (row_is_selected) { g.fillAll(juce::Colours::lightblue); }
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

refreshComponentForCell()

juce::Component * CommandTableModel::refreshComponentForCell ( int  row_number, int  column_id, bool  is_row_selected, juce::Component *  existing_component  )

overrideprivate

{
   /* This is used to create or update a custom component to go in a cell. Any cell may contain a
    * custom component, or can just be drawn with the paintCell() method and handle mouse clicks
    * with cellClicked(). This method will be called whenever a custom component might need to be
    * updated - e.g. when the table is changed, or TableListBox::updateContent() is called. If you
    * don't need a custom component for the specified cell, then return nullptr. (Bear in mind that
    * even if you're not creating a new component, you may still need to delete
    * existingComponentToUpdate if it's non-null). If you do want a custom component, and the
    * existingComponentToUpdate is null, then this method must create a new component suitable for
    * the cell, and return it. If the existingComponentToUpdate is non - null, it will be a pointer
    * to a component previously created by this method.In this case, the method must either update
    * it to make sure it's correctly representing the given cell(which may be different from the one
    * that the component was created for), or it can delete this component and return a new one.
    * Because Juce recycles these components when scrolling, we need to reset their properties. */
   try {
      if (column_id != 2) { // Not LR command column
         return nullptr;
      }
      const auto command_select {dynamic_cast<CommandMenu*>(existing_component)};
      if (command_select == nullptr) {
         return CreateNewCommandMenu(row_number, existing_component);
      }
      return UpdateCommandMenu(row_number, command_select);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

RemoveRow()

void CommandTableModel::RemoveRow ( size_t  row )

inline

   {
      /* called from CommandTable, forward to Profile */
      profile_.RemoveRow(row);
   }

sortOrderChanged()

void CommandTableModel::sortOrderChanged ( int  new_sort_column_id, bool  is_forwards  )

overrideprivate

{
   try {
      const auto current_sort {std::make_pair(new_sort_column_id, is_forwards)};
      profile_.Resort(current_sort);
   }
   catch (const std::exception& e) {
      rsj::ExceptionResponse(e, std::source_location::current());
      throw;
   }
}

UpdateCommandMenu()

CommandMenu * CommandTableModel::UpdateCommandMenu ( int  row_number, gsl::not_null< CommandMenu * >  command_select  ) const

private

{
   /* Updates the existing command menu */
   const auto& msg = profile_.GetMessageForNumber(gsl::narrow_cast<size_t>(row_number));
   command_select->SetMsg(msg);
   command_select->SetSelectedItem(command_set_.CommandTextIndex(profile_.GetCommandForMessage(msg))
                                   + 1);
   return command_select;
}

Member Data Documentation

command_set_

const CommandSet& CommandTableModel::command_set_

private

profile_

Profile& CommandTableModel::profile_

private

---

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

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