Welcome to the Lounge

ZurdoDev wrote:

But in seriousness, there are times when globals make sense.

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

0x01AA wrote:

No

0x01AA wrote:

but also injection is a kind of global behavior in the broadest sense

Greg Utas wrote:

Global constants, yes.
Global variables, no.

Nelek wrote:

Global variables being defined by you...still might be ok.

All vars matter

var matter = "All";

var a='matter', b='matter', c='matter';

David O'Neil wrote:

But if I found a place where a Singleton absolutely made sense, I'd use a Singleton

M.D.V.

If something has a solution... Why do we have to worry about?. If it has no solution... For what reason do we have to worry about?
Help me to understand what I'm saying, and I'll explain it better to you
Rating helpful answers is nice, but saying thanks can be even nicer.

#pragma once

//some includes...

//...some forward declarations

class Globals {
   //General declarations
      private:
         uchar lastNoteVelC;
         MUSIC_TIME lastNoteLenC;
         MUSIC_TIME snapValueC;
      public:
         Globals();
         ~Globals();

         void saveAppDefaults();

         enum NoteDurations { wholeNote=3072, halfNote=1536, quarterNote=768, eigthNote=384,
                     sixteenthNote=192, thirtySecondNote=96, sixtyFourthNote=48, tick=1 }
                     noteButtonDurationC;
         int noteButtonDuration() { return noteButtonDurationC; }
         uchar lastNoteVel() { return lastNoteVelC; }
         void  lastNoteVel(uchar vel) { lastNoteVelC = vel; }
         MUSIC_TIME lastNoteLen() { return lastNoteLenC; }
         void lastNoteLen(MUSIC_TIME newLen) { lastNoteLenC = newLen; }
         MUSIC_TIME snapValue() { return snapValueC; }
         void snapValue(MUSIC_TIME val) { snapValueC = val; }

   //For dealing with the ControllerNames class
      private:                                      
         std::unique_ptr<app::ControllerNames> controllersC;
      public:
         app::ControllerNames & controllerNames() { return *controllersC.get(); }

   //For dealing with the NoteValMap
      private:
         std::unique_ptr<app::NoteValMap> noteValMapC;
      public:
         app::NoteValMap & noteValMap() { return *noteValMapC.get(); }

   //For dealing with the key signatures
      private:
         std::unique_ptr<midi::KeySignatures> keySignaturesC;
      public:
         midi::KeySignatures & keySignatures() { return *keySignaturesC.get(); }

   //For dealing with the synching of multiple ports
      private:
         bool useSyncLogicC;
      public:
         void useSyncLogic(bool state) { useSyncLogicC = state; }
         inline bool useSyncLogic() { return useSyncLogicC; }

   //For dealing with the playing of any events prior to the cursor position which
   //affect the music at that point when play is pressed
      private:
         bool playPriorEventsC;
      public:
         bool playPriorEvents() { return playPriorEventsC; }
         void playPriorEvents(bool state) { playPriorEventsC = state; }

   //For dealing with the screen ticks per pixel
      private:
         double ticksPerPixelC;
         int    keyHeightC;
      public:
         inline double ticksPerPixel()           { return ticksPerPixelC; }
         inline void   ticksPerPixel(double val) { ticksPerPixelC = val; }
         int   keyHeight()              { return keyHeightC; }
         void  keyHeight(int height)    { keyHeightC = height; }

   //For dealing with wether the user wants to display ticks or time
      public:
         enum DisplayVal { DisplayTicks, DisplayTimes };
      private:
         DisplayVal displayValC;
      public:
         DisplayVal displayVal() { return displayValC; }
         void       displayVal(DisplayVal val) { displayValC = val; }

   //For dealing with the sleep time when midi ports stop playing
      private:
         int stopSleepTimeC;
      public:
         int stopSleepTime() { return stopSleepTimeC; }  

   //For showing the help file at startup
      private:
         bool showHelpOnStartupC;
      public:
         bool showHelpOnStartup() { return showHelpOnStartupC; }
         void showHelpOnStartup(bool state) { showHelpOnStartupC = state; }

   //For dealing with the stop method
      public:
         enum StopMethod { PlayNotesOff, PlayOmniModeOff, PlayOmniModeOn, PlayMonoModeOn,
                     PlayPolyModeOn, PlayNothing };
      private:                                   
         StopMethod stopMethodC;
      public:
         StopMethod stopMethod() { return stopMethodC; }
         void stopMethod(StopMethod newMethod) { stopMethodC = newMethod; }

   //For dealing with the last piano view bottom note:
      private:
         int pianoViewBottomNoteC;
      public:
         int pianoViewBottomNote() { return pianoViewBottomNoteC; }
         void pianoViewBottomNote(int x) { pianoViewBottomNoteC = x; }

   //For dealing with the UIManager:
      private:
         std::unique_ptr<ui::UIManager> uiManagerC;
      public:
         ui::UIManager & uiMan() { return *uiManagerC.get(); }

   //For dealing with the medit::Strings:
      private:
         std::unique_ptr<medit::Strings> stringsC;
      public:
         medit::Strings & strings() { return *stringsC.get(); }

   //For dealing with the initialization file path:
      public:
         wString appWorkDir();

   //For user interface definitions:
      private:
         int buttonHeightC = 25;

      public:
         int buttonHeight() { return buttonHeightC; }

   //A global date versioner:
      private:
         std::unique_ptr<utils::DateVersioner> dateVersionerC;
      public:
         utils::DateVersioner * dateVersioner() { return dateVersionerC.get(); }

   //A global for triggering setpoints:
      public:
         bool breakPointTrigger;

   //For the minimum # of ticks between curve events:
      private:
         int minTicksBetweenCurveEventsC;
      public:
         int minTicksBetweenCurveEvents() { return minTicksBetweenCurveEventsC; }

   };

void Repeat::createRepeatedMsgs() {
   if (!createdMsgsC.empty()) throw dwl::Exception(_T("Delete created msgs prior to "
               "creation"));
   app::MsgPlayMap & holder = trackC.playMap();
   holder.setPtrPos(s_cast<MUSIC_TIME>(0));
   midi::BaseMsg * msg;
   midi::BaseMsg * msgToCopy;
   while ((msg = holder.msgAtPtr()) && msg != nullptr && msg->tick() < endTickC) {
      if (msg->tick() < tickC) goto breakout;
      for (size_t i=1, count=numRepeatsC; i<=count; ++i) {
         midi::BaseMsg::Type type = msg->type();
         if (type == midi::BaseMsg::Type::NoteOn) {
            midi::NoteOn * noteOn = s_cast<midi::NoteOn *>(msg);
            midi::Note * note = s_cast<midi::Note*>(noteOn->parent());
            if (note) msgToCopy = note;
            else msgToCopy = noteOn;
            }
         else if (type == midi::BaseMsg::Type::NoteOff) goto breakout;
         else if (type == midi::BaseMsg::Type::KeyAftertouch) goto breakout;
         else msgToCopy = msg;

         //Don't make copies of copies!
         if (msgToCopy->copyOf()) goto breakout;

         std::unique_ptr<midi::BaseMsg> newMsg = msgToCopy->copyToTick(msgToCopy->tick() +
                     durationC * i);
         if (newMsg->type() == midi::BaseMsg::Type::Note) {
            s_cast<midi::Note*>(newMsg.get())->noteOn().copyOf((midi::BaseMsg*)1);
            s_cast<midi::Note*>(newMsg.get())->noteOff().copyOf((midi::BaseMsg*)1);
            }
         createdMsgsC.push_back(newMsg.get());
         newMsg.release(); //It is in the vector
         }
breakout:
      holder.incMsgPtr();
      }

   //Make the created messages visible OUTSIDE of the loop, to keep the iterator valid:
   for (auto msg: createdMsgsC) {
      msg->addToVisible();
      }
   }

#realJSOP wrote:

app configuration settings

#realJSOP wrote:

I also have a static Globals object