HydrogenApp.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2024 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see https://www.gnu.org/licenses
 *
 */
 
#ifndef HYDROGEN_APP_H
#define HYDROGEN_APP_H
 
#include <core/config.h>
#include <core/Object.h>
#include <core/Globals.h>
#include <core/Preferences/Preferences.h>
 
#include "EventListener.h"
 
#include <iostream>
#include <cstdint>
#include <vector>
#include <memory>
 
#include <QtGui>
#include <QtWidgets>
#include <QStringList>
 
constexpr uint16_t QUEUE_TIMER_PERIOD = 50;
 
 
namespace H2Core
{
        class Song;
}
 
class SongEditorPanel;
class MainForm;
class PlayerControl;
class PatternEditorPanel;
class InstrumentEditorPanel;
class SongEditor;
class Mixer;
class AudioEngineInfoForm;
class FilesystemInfoForm;
class SimpleHTMLBrowser;
class LadspaFXProperties;
class LadspaFXInfo;
class LadspaFXGroup;
class InstrumentRack;
class PlaylistDialog;
class SampleEditor;
class Director;
class InfoBar;
class CommonStrings;
 
class HydrogenApp :  public QObject, public EventListener,  public H2Core::Object<HydrogenApp>
{
                H2_OBJECT(HydrogenApp)
        Q_OBJECT
        public:
                HydrogenApp( MainForm* pMainForm );
 
                static HydrogenApp* get_instance();
 
                virtual ~HydrogenApp();
 
                static bool openSong( QString sFilename );
                static bool openSong( std::shared_ptr<H2Core::Song> pSong );
        static bool recoverEmptySong();
 
                void showPreferencesDialog();
                void updateMixerCheckbox();
                void showMixer(bool bShow);
                void showInstrumentPanel(bool);
                void showAudioEngineInfoForm();
                void showFilesystemInfoForm();
                void showPlaylistDialog();
                void showDirector();
                void showSampleEditor( QString name, int mSelectedComponemt, int mSelectedLayer );
 
                bool hideKeyboardCursor();
                void setHideKeyboardCursor( bool bHidden );
 
                Mixer*                          getMixer();
                MainForm*                       getMainForm();
                SongEditorPanel*                getSongEditorPanel();
                AudioEngineInfoForm*            getAudioEngineInfoForm();
                PlaylistDialog*                 getPlayListDialog();
                Director*                       getDirector();
                SampleEditor*                   getSampleEditor();
                PatternEditorPanel*             getPatternEditorPanel();
                PlayerControl*                  getPlayerControl();
                InstrumentRack*                 getInstrumentRack();
        std::shared_ptr<CommonStrings>                  getCommonStrings();
                InfoBar *                       addInfoBar();
 
                QUndoStack*                     m_pUndoStack;
 
        void showStatusBarMessage( const QString& sMessage, const QString& sCaller = "" );
                void updateWindowTitle();
 
#ifdef H2CORE_HAVE_LADSPA
                LadspaFXProperties* getLadspaFXProperties(uint nFX) {   return m_pLadspaFXProperties[nFX];      }
#endif
                void addEventListener( EventListener* pListener );
                void removeEventListener( EventListener* pListener );
                void closeFXProperties();
 
                void cleanupTemporaryFiles();
 
                enum SetPropertyFlag {
                        SetX = 1 << 0,
                        SetY = 1 << 1,
                        SetWidth = 1 << 2,
                        SetHeight = 1 << 3,
                        SetVisible = 1 << 4,
                        SetAll = SetX + SetY + SetWidth + SetHeight + SetVisible,
                        SetDefault = SetAll
                };
 
                void setWindowProperties( QWidget *pWindow, H2Core::WindowProperties &prop, unsigned flags = SetAll );
                H2Core::WindowProperties getWindowProperties( QWidget *pWindow );
 
        static bool checkDrumkitLicense( std::shared_ptr<H2Core::Drumkit> pDrumkit );
 
signals:
        void preferencesChanged( H2Core::Preferences::Changes changes );
 
        public slots:
                void onEventQueueTimer();
                void currentTabChanged(int);
 
        void changePreferences( H2Core::Preferences::Changes changes );
        void onPreferencesChanged( H2Core::Preferences::Changes changes );
 
private slots:
        void propagatePreferences();
 
        private:
                static HydrogenApp *            m_pInstance;    
 
#ifdef H2CORE_HAVE_LADSPA
                LadspaFXProperties *            m_pLadspaFXProperties[MAX_FX];
#endif
 
                MainForm *                                      m_pMainForm;
                Mixer *                                         m_pMixer;
                PatternEditorPanel*                     m_pPatternEditorPanel;
                AudioEngineInfoForm *           m_pAudioEngineInfoForm;
                FilesystemInfoForm *            m_pFilesystemInfoForm;
                SongEditorPanel *                       m_pSongEditorPanel;
                InstrumentRack*                         m_pInstrumentRack;
                PlayerControl *                         m_pPlayerControl;
                PlaylistDialog *                        m_pPlaylistDialog;
                SampleEditor *                          m_pSampleEditor;
                Director *                                      m_pDirector;
                QTimer *                                        m_pEventQueueTimer;
                std::vector<EventListener*>     m_EventListeners;
                QTabWidget *                            m_pTab;
                QSplitter *                                     m_pSplitter;
                QVBoxLayout *                           m_pMainVBox;
        std::shared_ptr<CommonStrings>                          m_pCommonStrings;
 
                bool                                            m_bHideKeyboardCursor;
                QTimer *                                        m_pPreferencesUpdateTimer;
                int                                                 m_nPreferencesUpdateTimeout;
        H2Core::Preferences::Changes m_bufferedChanges;  
 
                // implement EngineListener interface
                void engineError(uint nErrorCode);
 
                void setupSinglePanedInterface();
                virtual void songModifiedEvent() override;
        virtual void XRunEvent() override;
 
                virtual void updatePreferencesEvent( int nValue ) override;
                virtual void updateSongEvent( int nValue ) override;
        virtual void drumkitLoadedEvent() override;
        
};
 
 
inline HydrogenApp* HydrogenApp::get_instance() {
        return m_pInstance;
}
 
inline Mixer* HydrogenApp::getMixer()
{
        return m_pMixer;        
}
 
inline MainForm* HydrogenApp::getMainForm()
{       
        return m_pMainForm;     
}
 
inline SongEditorPanel* HydrogenApp::getSongEditorPanel()
{
        return m_pSongEditorPanel;
}
 
inline AudioEngineInfoForm* HydrogenApp::getAudioEngineInfoForm()
{
        return m_pAudioEngineInfoForm;
}
 
inline PlaylistDialog* HydrogenApp::getPlayListDialog()
{
        return m_pPlaylistDialog;
}
 
inline Director* HydrogenApp::getDirector()
{
        return m_pDirector;
}
 
inline SampleEditor* HydrogenApp::getSampleEditor()
{
        return m_pSampleEditor; 
}
 
inline PatternEditorPanel* HydrogenApp::getPatternEditorPanel()
{
        return m_pPatternEditorPanel;
}
 
inline PlayerControl* HydrogenApp::getPlayerControl()
{
        return m_pPlayerControl;
}
 
inline InstrumentRack* HydrogenApp::getInstrumentRack()
{
        return m_pInstrumentRack;
}
 
inline std::shared_ptr<CommonStrings> HydrogenApp::getCommonStrings()
{
        return m_pCommonStrings;
}
 
inline bool HydrogenApp::hideKeyboardCursor()
{
        return m_bHideKeyboardCursor;
}
 
inline void HydrogenApp::setHideKeyboardCursor( bool bHidden )
{
        if ( bHidden && ! m_bHideKeyboardCursor ) {
                H2Core::Preferences *pPref = H2Core::Preferences::get_instance();
                if ( pPref->hideKeyboardCursor() ) {
                        m_bHideKeyboardCursor = true;
                }
        } else {
                m_bHideKeyboardCursor = bHidden;
        }
}
 
 
#endif