Welcome to the Lounge

#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

David O'Neil wrote:

Globals are a tool.

David O'Neil wrote:

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

David O'Neil wrote:

If it works for you, though, it works. And that's all that really matters.

raddevus wrote:

Because the original dev didn't understand anything he created every variable as a global.

David O'Neil wrote:

Unless it was created by the owner of the company, then you'd best polish your resume!

Super Lloyd wrote:

Stop using Python and rediscover inner peace?

def printGlobal():
   print(str(extra))

extra = 35
printGlobal() # prints 35
extra = "Python are stupid."

class Arsinine:
   def __init__(self):
      printGlobal() # and you though this would print '35'  ;) 

a = Arsinine() # prints Python are stupid.

Cp-Coder wrote:

get a Kindle

Cp-Coder wrote:

What is wrong with people stupid enough

Cp-Coder wrote:

get a Kindle or something!