notifier.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi.
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
#ifndef _NICMIDI_NOTIFIER_H
#define _NICMIDI_NOTIFIER_H
 
 
#include <iostream>
#include "processor.h"
 
 
 
class MIDISequencer;
 
 
class MIDISequencerGUIEvent {
    public:
                    MIDISequencerGUIEvent() : bits(0)                    {}
                    MIDISequencerGUIEvent(unsigned long bits_) : bits(bits_) {}
                    MIDISequencerGUIEvent(int group, int subgroup, int item) {
                        bits = ((group&0xff)<<24) | ((subgroup&0xfff)<<12) | (item&0xfff); }
                        // leave unchanged! overloading trouble, too many ctors
        // copy constructor and operator= provided by the compiler
 
                    operator unsigned long () const             { return bits; }
        int         GetGroup() const                        { return (int)((bits>>24)&0xff); }
        int         GetSubGroup() const                     { return (int)((bits>>12)&0xfff); }
        int         GetItem() const                         { return (int)((bits>>0)&0xfff); }
        void        SetEvent( int group, int subgroup = 0, int item = 0 ) {
                        bits = ((group&0xff)<<24) | ((subgroup&0xfff)<<12) | (item&0xfff); }
 
        enum {
            GROUP_ALL = 0,              
            GROUP_CONDUCTOR,            
            GROUP_TRANSPORT,            
            GROUP_TRACK,                
            GROUP_RECORDER,             
            GROUP_USER                  
        };
 
        enum {
            GROUP_CONDUCTOR_TEMPO = 0,  
            GROUP_CONDUCTOR_TIMESIG,    
            GROUP_CONDUCTOR_KEYSIG,     
            GROUP_CONDUCTOR_MARKER,     
            GROUP_CONDUCTOR_USER        
        };
 
        enum {
            GROUP_TRANSPORT_START = 0,  
            GROUP_TRANSPORT_STOP,       
            GROUP_TRANSPORT_MEASURE,    
            GROUP_TRANSPORT_BEAT,       
            GROUP_TRANSPORT_COUNTIN,    
            GROUP_TRANSPORT_USER        
        };      // TODO: add a GROUP_TRANSPORT_ENDOFSONG for midi type 3 files?
 
        enum {
            GROUP_TRACK_NAME = 0,       
            GROUP_TRACK_PROGRAM,        
            GROUP_TRACK_NOTE,           
            GROUP_TRACK_VOLUME,         
            GROUP_TRACK_PAN,            
            GROUP_TRACK_CHR,            
            GROUP_TRACK_REV,            
            GROUP_TRACK_USER            
        };
 
        enum {
            GROUP_RECORDER_RESET,       
            GROUP_RECORDER_START,       
            GROUP_RECORDER_STOP,        
            GROUP_RECORDER_USER         
        };
 
        enum {
            GROUP_USER_USER = 0         
        };
 
        static const char group_names[][10];
        static const char conductor_items_names[][10];
        static const char transport_items_names[][10];
        static const char track_items_names[][10];
        static const char recording_items_names[][10];
        static const char user_items_names[][10];
 
    protected:
        unsigned long bits;         // Storage for group, subgroup and item
};
 
 
class MIDISequencerGUINotifier {
    public:
                        MIDISequencerGUINotifier(const MIDISequencer* seq = 0) :
                            sequencer(seq), en(true)                {}
        // destructor needed for virtual methods
        virtual         ~MIDISequencerGUINotifier()                 {}
        virtual void    SetSequencer(const MIDISequencer* seq)      { sequencer = seq; }
        virtual void    Notify(const MIDISequencerGUIEvent &ev) = 0;
        virtual bool    GetEnable() const                           { return en;};
        virtual void    SetEnable(bool f)                           { en = f; }
    protected:
        const MIDISequencer*  sequencer;            
        bool en;                                    
};
 
 
class MIDISequencerGUINotifierText : public MIDISequencerGUINotifier {
    public:
                        MIDISequencerGUINotifierText(const MIDISequencer* seq = 0, std::ostream& os = std::cout) :
                                MIDISequencerGUINotifier(seq), start_from(0), ost(os)   {}
 
        unsigned char           GetStartFrom() const             { return start_from; }
        bool            SetStartFrom(unsigned char c);
 
        virtual void    Notify(const MIDISequencerGUIEvent &ev);
 
    protected:
        unsigned char   start_from;
        std::ostream&   ost;
};
 
 
#ifdef _WIN32
#include "windows.h"
#include "mmsystem.h"
 
 
class MIDISequencerGUINotifierWin32 : public MIDISequencerGUINotifier {
    public:
                            MIDISequencerGUINotifierWin32 (HWND w, DWORD msg, WPARAM param_value = 0);
 
                            MIDISequencerGUINotifierWin32 (HWND w);
            virtual         ~MIDISequencerGUINotifierWin32() {}
 
            DWORD           GetMsgId() const            { return window_msg; }
 
            virtual void    Notify (const MIDISequencerGUIEvent &ev);
 
    protected:
            // Returns a safe Windows message id, so we can create the notifier without worrying about this
            static UINT     GetSafeSystemMsgId()        { static UINT base = WM_APP; return base++; }
 
            HWND            dest_window;
            DWORD           window_msg;
            WPARAM          wparam_value;
};
 
#endif // _WIN32
 
#endif // _JDKMIDI_NOTIFIER_H