CCoptions Class Reference

#include <CCoptions.h>

Inheritance diagram for CCoptions:

Public Member Functions
	CCoptions ()
	CCoptions (CCoptions &&other) noexcept=delete
	~CCoptions ()
void	BindToControl (int channel, int control_number)
void	buttonClicked (juce::Button *buttonThatWasClicked) override
CCoptions &	operator= (CCoptions &&other) noexcept=delete
void	paint (juce::Graphics &g) override
void	resized () override

Static Public Member Functions
static void	LinkToControlsModel (_In_ ControlsModel *model) noexcept

Private Member Functions
void	textEditorFocusLost (juce::TextEditor &t) override

Private Attributes
std::unique_ptr< juce::ToggleButton >	absbutton
std::unique_ptr< juce::TextButton >	applyAll
std::unique_ptr< juce::ToggleButton >	binbutton
int	bound_channel_ {0}
int	bound_number_ {0}
std::unique_ptr< juce::Label >	controlID
std::unique_ptr< juce::GroupComponent >	groupComponent
std::unique_ptr< juce::Label >	maxvallabel
std::unique_ptr< juce::TextEditor >	maxvaltext
std::unique_ptr< juce::Label >	minvallabel
std::unique_ptr< juce::TextEditor >	minvaltext
juce::TextEditor::LengthAndCharacterRestriction	numrestrict_ {5, "0123456789"}
std::unique_ptr< juce::ToggleButton >	signbutton
std::unique_ptr< juce::ToggleButton >	twosbutton

Static Private Attributes
static ControlsModel *	controls_model_ {nullptr}

Detailed Description

[Comments] An auto-generated component, created by the Projucer.

Describe your class and how it works here! [/Comments]

Constructor & Destructor Documentation

CCoptions() [1/2]

CCoptions::CCoptions

(

)

{
   //[Constructor_pre] You can add your own custom stuff here..
   auto fo {juce::FontOptions(15.00f, Font::plain)};
   //[/Constructor_pre]
 
   groupComponent.reset(new GroupComponent("CCmethod", TRANS("CC Message Type")));
   addAndMakeVisible(groupComponent.get());
 
   groupComponent->setBounds(16, 60, 240, 157);
 
   twosbutton.reset(new ToggleButton("twoscomp"));
   addAndMakeVisible(twosbutton.get());
   twosbutton->setTooltip(TRANS("Control value is 1 or greater when turned one way, and 127 or "
                                "smaller when turned the other."));
   twosbutton->setExplicitFocusOrder(2);
   twosbutton->setButtonText(TRANS("Two\'s complement"));
   twosbutton->setConnectedEdges(Button::ConnectedOnTop | Button::ConnectedOnBottom);
   twosbutton->setRadioGroupId(1);
   twosbutton->addListener(this);
 
   twosbutton->setBounds(40, 117, 150, 24);
 
   absbutton.reset(new ToggleButton("Absolute"));
   addAndMakeVisible(absbutton.get());
   absbutton->setTooltip(TRANS("Control value increases when turned one way, decreases when turned "
                               "the other."));
   absbutton->setExplicitFocusOrder(1);
   absbutton->setConnectedEdges(Button::ConnectedOnBottom);
   absbutton->setRadioGroupId(1);
   absbutton->addListener(this);
   absbutton->setToggleState(true, dontSendNotification);
 
   absbutton->setBounds(40, 85, 150, 24);
 
   binbutton.reset(new ToggleButton("Binaryoffset"));
   addAndMakeVisible(binbutton.get());
   binbutton->setTooltip(TRANS("Control value is near 63 when turned one way, and near 65 when "
                               "turned the other."));
   binbutton->setExplicitFocusOrder(3);
   binbutton->setButtonText(TRANS("Binary offset"));
   binbutton->setConnectedEdges(Button::ConnectedOnTop | Button::ConnectedOnBottom);
   binbutton->setRadioGroupId(1);
   binbutton->addListener(this);
 
   binbutton->setBounds(40, 149, 150, 24);
 
   signbutton.reset(new ToggleButton("Signmagnitude"));
   addAndMakeVisible(signbutton.get());
   signbutton->setTooltip(TRANS("Control value is near 1 when turned one way, and near 65 when "
                                "turned the other."));
   signbutton->setExplicitFocusOrder(4);
   signbutton->setButtonText(TRANS("Sign and magnitude"));
   signbutton->setConnectedEdges(Button::ConnectedOnTop);
   signbutton->setRadioGroupId(1);
   signbutton->addListener(this);
 
   signbutton->setBounds(40, 181, 150, 24);
 
   maxvaltext.reset(new TextEditor("maxvaltext"));
   addAndMakeVisible(maxvaltext.get());
   maxvaltext->setExplicitFocusOrder(6);
   maxvaltext->setMultiLine(false);
   maxvaltext->setReturnKeyStartsNewLine(false);
   maxvaltext->setReadOnly(false);
   maxvaltext->setScrollbarsShown(true);
   maxvaltext->setCaretVisible(true);
   maxvaltext->setPopupMenuEnabled(true);
   maxvaltext->setText(TRANS("127"));
 
   maxvaltext->setBounds(200, 268, 56, 24);
 
   minvaltext.reset(new TextEditor("minvaltext"));
   addAndMakeVisible(minvaltext.get());
   minvaltext->setExplicitFocusOrder(5);
   minvaltext->setMultiLine(false);
   minvaltext->setReturnKeyStartsNewLine(false);
   minvaltext->setReadOnly(false);
   minvaltext->setScrollbarsShown(true);
   minvaltext->setCaretVisible(true);
   minvaltext->setPopupMenuEnabled(true);
   minvaltext->setText(TRANS("0"));
 
   minvaltext->setBounds(200, 228, 56, 24);
 
   minvallabel.reset(new Label("new label", TRANS("Minimum value")));
   addAndMakeVisible(minvallabel.get());
   minvallabel->setFont(Font(fo).withTypefaceStyle("Regular"));
   minvallabel->setJustificationType(Justification::centredLeft);
   minvallabel->setEditable(false, false, false);
   minvallabel->setColour(TextEditor::textColourId, Colours::black);
   minvallabel->setColour(TextEditor::backgroundColourId, Colour(0x00000000));
 
   minvallabel->setBounds(16, 228, 150, 24);
 
   maxvallabel.reset(new Label("maxlabel", TRANS("Maximum value")));
   addAndMakeVisible(maxvallabel.get());
   maxvallabel->setFont(Font(fo).withTypefaceStyle("Regular"));
   maxvallabel->setJustificationType(Justification::centredLeft);
   maxvallabel->setEditable(false, false, false);
   maxvallabel->setColour(TextEditor::textColourId, Colours::black);
   maxvallabel->setColour(TextEditor::backgroundColourId, Colour(0x00000000));
 
   maxvallabel->setBounds(16, 268, 150, 24);
 
   applyAll.reset(new TextButton("new button"));
   addAndMakeVisible(applyAll.get());
   applyAll->setTooltip(TRANS("Apply these settings to all similar controls."));
   applyAll->setExplicitFocusOrder(7);
   applyAll->setButtonText(TRANS("Apply to all"));
   applyAll->addListener(this);
 
   controlID.reset(new Label("channel 0 number 0", TRANS("Channel 0 Number 0")));
   addAndMakeVisible(controlID.get());
   controlID->setFont(Font(fo).withTypefaceStyle("Regular"));
   controlID->setJustificationType(Justification::centred);
   controlID->setEditable(false, false, false);
   controlID->setColour(TextEditor::textColourId, Colours::black);
   controlID->setColour(TextEditor::backgroundColourId, Colour(0x00000000));
 
   //[UserPreSize]
   //[/UserPreSize]
 
   setSize(280, 350);
 
   //[Constructor] You can add your own custom stuff here..
   maxvaltext->setInputFilter(&numrestrict_, false);
   minvaltext->setInputFilter(&numrestrict_, false);
   maxvaltext->addListener(this);
   minvaltext->addListener(this);
   //[/Constructor]
}

~CCoptions()

CCoptions::~CCoptions

(

)

{
   //[Destructor_pre]. You can add your own custom destruction code here..
   //[/Destructor_pre]
 
   groupComponent = nullptr;
   twosbutton = nullptr;
   absbutton = nullptr;
   binbutton = nullptr;
   signbutton = nullptr;
   maxvaltext = nullptr;
   minvaltext = nullptr;
   minvallabel = nullptr;
   maxvallabel = nullptr;
   applyAll = nullptr;
   controlID = nullptr;
 
   //[Destructor]. You can add your own custom destruction code here..
   //[/Destructor]
}

CCoptions() [2/2]

CCoptions::CCoptions ( CCoptions &&  other )

deletenoexcept

Member Function Documentation

BindToControl()

void CCoptions::BindToControl	(	int	channel,
		int	control_number
	)

{
   bound_channel_ = channel; // 0-based but displays as 1-based
   bound_number_ = control_number;
   controlID->setText("channel " + juce::String(channel + 1) + " number "
                          + juce::String(control_number),
       juce::dontSendNotification);
   minvaltext->setText(juce::String(controls_model_->GetCcMin(bound_channel_, bound_number_)),
       juce::dontSendNotification);
   maxvaltext->setText(juce::String(controls_model_->GetCcMax(bound_channel_, bound_number_)),
       juce::dontSendNotification);
   switch (controls_model_->GetCcMethod(bound_channel_, bound_number_)) {
   case rsj::CCmethod::kAbsolute:
      absbutton->setToggleState(true, juce::sendNotification);
      break;
   case rsj::CCmethod::kBinaryOffset:
      binbutton->setToggleState(true, juce::sendNotification);
      break;
   case rsj::CCmethod::kSignMagnitude:
      signbutton->setToggleState(true, juce::sendNotification);
      break;
   case rsj::CCmethod::kTwosComplement:
      twosbutton->setToggleState(true, juce::sendNotification);
      break;
   }
}

buttonClicked()

void CCoptions::buttonClicked ( juce::Button *  buttonThatWasClicked )

override

{
   //[UserbuttonClicked_Pre]
   //[/UserbuttonClicked_Pre]
 
   if (buttonThatWasClicked == twosbutton.get()) {
      //[UserButtonCode_twosbutton] -- add your button handler code here..
      minvaltext->setVisible(false);
      minvallabel->setVisible(false);
      maxvallabel->setText(TRANS("Resolution"), juce::dontSendNotification);
      minvaltext->setText("0", juce::dontSendNotification);
      controls_model_->SetCcMethod(bound_channel_, bound_number_, rsj::CCmethod::kTwosComplement);
      //[/UserButtonCode_twosbutton]
   }
   else if (buttonThatWasClicked == absbutton.get()) {
      //[UserButtonCode_absbutton] -- add your button handler code here..
      minvaltext->setVisible(true);
      minvallabel->setVisible(true);
      maxvallabel->setText(TRANS("Maximum value"), juce::dontSendNotification);
      controls_model_->SetCcMethod(bound_channel_, bound_number_, rsj::CCmethod::kAbsolute);
      //[/UserButtonCode_absbutton]
   }
   else if (buttonThatWasClicked == binbutton.get()) {
      //[UserButtonCode_binbutton] -- add your button handler code here..
      minvaltext->setVisible(false);
      minvallabel->setVisible(false);
      maxvallabel->setText(TRANS("Resolution"), juce::dontSendNotification);
      minvaltext->setText("0", juce::dontSendNotification);
      controls_model_->SetCcMethod(bound_channel_, bound_number_, rsj::CCmethod::kBinaryOffset);
 
      //[/UserButtonCode_binbutton]
   }
   else if (buttonThatWasClicked == signbutton.get()) {
      //[UserButtonCode_signbutton] -- add your button handler code here..
      minvaltext->setVisible(false);
      minvallabel->setVisible(false);
      maxvallabel->setText(TRANS("Resolution"), juce::dontSendNotification);
      minvaltext->setText("0", juce::dontSendNotification);
      controls_model_->SetCcMethod(bound_channel_, bound_number_, rsj::CCmethod::kSignMagnitude);
      //[/UserButtonCode_signbutton]
   }
   else if (buttonThatWasClicked == applyAll.get()) {
      //[UserButtonCode_applyAll] -- add your button handler code here..
      rsj::CCmethod ccm {};
      if (twosbutton->getToggleState()) { ccm = rsj::CCmethod::kTwosComplement; }
      else if (absbutton->getToggleState()) {
         ccm = rsj::CCmethod::kAbsolute;
      }
      else if (binbutton->getToggleState()) {
         ccm = rsj::CCmethod::kBinaryOffset;
      }
      else if (signbutton->getToggleState()) {
         ccm = rsj::CCmethod::kSignMagnitude;
      }
      else {
         throw std::logic_error("CCoptions::buttonClicked reached unreachable code");
      }
      controls_model_->SetCcAll(bound_channel_, bound_number_, minvaltext->getText().getIntValue(),
          maxvaltext->getText().getIntValue(), ccm);
      //[/UserButtonCode_applyAll]
   }
   else { /* no action needed */
   }
 
   //[UserbuttonClicked_Post]
   //[/UserbuttonClicked_Post]
}

LinkToControlsModel()

static void CCoptions::LinkToControlsModel ( _In_ ControlsModel *  model )

inlinestaticnoexcept

{ controls_model_ = model; }

operator=()

CCoptions & CCoptions::operator= ( CCoptions &&  other )

deletenoexcept

paint()

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

override

{
   //[UserPrePaint] Add your own custom painting code here..
   //[/UserPrePaint]
 
   g.fillAll(Colours::white);
 
   //[UserPaint] Add your own custom painting code here..
   //[/UserPaint]
}

resized()

void CCoptions::resized ( )

override

{
   //[UserPreResize] Add your own custom resize code here..
   //[/UserPreResize]
 
   applyAll->setBounds((getWidth() / 2) - (150 / 2), (getHeight() / 2) + 141, 150, 24);
   controlID->setBounds((getWidth() / 2) - (248 / 2), 16, 248, 24);
   //[UserResized] Add your own custom resize handling here..
   //[/UserResized]
}

textEditorFocusLost()

void CCoptions::textEditorFocusLost ( juce::TextEditor &  t )

overrideprivate

{
   const auto val = t.getText().getIntValue();
   const auto& nam = t.getName();
   if (nam == "minvaltext") { controls_model_->SetCcMin(bound_channel_, bound_number_, val); }
   else if (nam == "maxvaltext") {
      controls_model_->SetCcMax(bound_channel_, bound_number_, val);
   }
   else { /* no action needed */
   }
}

Member Data Documentation

absbutton

std::unique_ptr<juce::ToggleButton> CCoptions::absbutton

private

applyAll

std::unique_ptr<juce::TextButton> CCoptions::applyAll

private

binbutton

std::unique_ptr<juce::ToggleButton> CCoptions::binbutton

private

bound_channel_

int CCoptions::bound_channel_ {0}

private

{0}; // note: 0-based in program, add one to compensate for display

bound_number_

int CCoptions::bound_number_ {0}

private

{0};

controlID

std::unique_ptr<juce::Label> CCoptions::controlID

private

controls_model_

ControlsModel* CCoptions::controls_model_ {nullptr}

inlinestaticprivate

{nullptr};

groupComponent

std::unique_ptr<juce::GroupComponent> CCoptions::groupComponent

private

maxvallabel

std::unique_ptr<juce::Label> CCoptions::maxvallabel

private

maxvaltext

std::unique_ptr<juce::TextEditor> CCoptions::maxvaltext

private

minvallabel

std::unique_ptr<juce::Label> CCoptions::minvallabel

private

minvaltext

std::unique_ptr<juce::TextEditor> CCoptions::minvaltext

private

numrestrict_

juce::TextEditor::LengthAndCharacterRestriction CCoptions::numrestrict_ {5, "0123456789"}

private

{5, "0123456789"};

signbutton

std::unique_ptr<juce::ToggleButton> CCoptions::signbutton

private

twosbutton

std::unique_ptr<juce::ToggleButton> CCoptions::twosbutton

private

---

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

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