include/pattern.h

   1 /*
   2  * pattern.h - declaration of class pattern, which contains all informations
   3  *             about a pattern
   4  *
   5  * Copyright (c) 2004-2011 Tobias Doerffel <tobydox/at/users.sourceforge.net>
   6  *
   7  * This file is part of Linux MultiMedia Studio - http://lmms.sourceforge.net
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this program (see COPYING); if not, write to the
  21  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301 USA.
  23  *
  24  */
  25
  26 #ifndef _PATTERN_H
  27 #define _PATTERN_H
  28
  29 #include <QtCore/QVector>
  30 #include <QtGui/QWidget>
  31 #include <QtGui/QDialog>
  32 #include <QtCore/QThread>
  33 #include <QtGui/QPixmap>
  34
  35
  36 #include "note.h"
  37 #include "track.h"
  38
  39
  40 class QAction;
  41 class QProgressBar;
  42 class QPushButton;
  43
  44 class InstrumentTrack;
  45 class patternFreezeThread;
  46 class sampleBuffer;
  47
  48
  49
  50 class EXPORT pattern : public trackContentObject
  51 {
  52         Q_OBJECT
  53 public:
  54         enum PatternTypes
  55         {
  56                 BeatPattern,
  57                 MelodyPattern
  58         } ;
  59
  60         pattern( InstrumentTrack * _instrument_track );
  61         pattern( const pattern & _pat_to_copy );
  62         virtual ~pattern();
  63
  64         void init();
  65
  66
  67         virtual midiTime length() const;
  68         midiTime beatPatternLength() const;
  69
  70         // note management
  71         note * addNote( const note & _new_note, const bool _quant_pos = true );
  72
  73         void removeNote( const note * _note_to_del );
  74
  75         note * rearrangeNote( const note * _note_to_proc,
  76                                                 const bool _quant_pos = true );
  77         void rearrangeAllNotes();
  78         void clearNotes();
  79
  80         inline const NoteVector & notes() const
  81         {
  82                 return m_notes;
  83         }
  84
  85         void setStep( int _step, bool _enabled );
  86
  87         // pattern-type stuff
  88         inline PatternTypes type() const
  89         {
  90                 return m_patternType;
  91         }
  92         void setType( PatternTypes _new_pattern_type );
  93         void checkType();
  94
  95
  96         // functions which are part of freezing-feature
  97         inline bool isFreezing() const
  98         {
  99                 return m_freezing;
 100         }
 101
 102         inline bool isFrozen() const
 103         {
 104                 return m_frozenPattern != NULL;
 105         }
 106
 107         sampleBuffer *frozenPattern()
 108         {
 109                 return m_frozenPattern;
 110         }
 111
 112         // settings-management
 113         virtual void saveSettings( QDomDocument & _doc, QDomElement & _parent );
 114         virtual void loadSettings( const QDomElement & _this );
 115         inline virtual QString nodeName() const
 116         {
 117                 return "pattern";
 118         }
 119
 120         inline InstrumentTrack * instrumentTrack() const
 121         {
 122                 return m_instrumentTrack;
 123         }
 124
 125         bool empty();
 126
 127
 128         void addSteps( int _n );
 129         void removeSteps( int _n );
 130
 131         virtual trackContentObjectView * createView( trackView * _tv );
 132
 133
 134         using Model::dataChanged;
 135
 136
 137 protected:
 138         void ensureBeatNotes();
 139         void updateBBTrack();
 140
 141
 142 protected slots:
 143         void clear();
 144         void freeze();
 145         void unfreeze();
 146         void abortFreeze();
 147         void changeTimeSignature();
 148
 149
 150 private:
 151         InstrumentTrack * m_instrumentTrack;
 152
 153         PatternTypes m_patternType;
 154
 155         // data-stuff
 156         NoteVector m_notes;
 157         int m_steps;
 158
 159         // pattern freezing
 160         sampleBuffer * m_frozenPattern;
 161         bool m_freezing;
 162         volatile bool m_freezeAborted;
 163
 164
 165         friend class patternView;
 166         friend class patternFreezeThread;
 167
 168 } ;
 169
 170
 171
 172 class patternView : public trackContentObjectView
 173 {
 174         Q_OBJECT
 175 public:
 176         patternView( pattern * _pattern, trackView * _parent );
 177         virtual ~patternView();
 178
 179
 180 public slots:
 181         virtual void update();
 182
 183
 184 protected slots:
 185         void openInPianoRoll();
 186
 187         void resetName();
 188         void changeName();
 189
 190         void addSteps( QAction * _item );
 191         void removeSteps( QAction * _item );
 192
 193
 194 protected:
 195         virtual void constructContextMenu( QMenu * );
 196         virtual void mouseDoubleClickEvent( QMouseEvent * _me );
 197         virtual void mousePressEvent( QMouseEvent * _me );
 198         virtual void paintEvent( QPaintEvent * _pe );
 199         virtual void resizeEvent( QResizeEvent * _re )
 200         {
 201                 m_needsUpdate = true;
 202                 trackContentObjectView::resizeEvent( _re );
 203         }
 204         virtual void wheelEvent( QWheelEvent * _we );
 205
 206
 207 private:
 208         static QPixmap * s_stepBtnOn;
 209         static QPixmap * s_stepBtnOverlay;
 210         static QPixmap * s_stepBtnOff;
 211         static QPixmap * s_stepBtnOffLight;
 212         static QPixmap * s_frozen;
 213
 214         pattern * m_pat;
 215         QPixmap m_paintPixmap;
 216         bool m_needsUpdate;
 217
 218 } ;
 219
 220
 221
 222
 223 // TODO: move to own header-files
 224 //
 225
 226
 227 class patternFreezeStatusDialog : public QDialog
 228 {
 229         Q_OBJECT
 230 public:
 231         patternFreezeStatusDialog( QThread * _thread );
 232         virtual ~patternFreezeStatusDialog();
 233
 234         void setProgress( int _p );
 235
 236
 237 protected:
 238         void closeEvent( QCloseEvent * _ce );
 239
 240
 241 protected slots:
 242         void cancelBtnClicked();
 243         void updateProgress();
 244
 245
 246 private:
 247         QProgressBar * m_progressBar;
 248         QPushButton * m_cancelBtn;
 249
 250         QThread * m_freezeThread;
 251
 252         int m_progress;
 253
 254
 255 signals:
 256         void aborted();
 257
 258 } ;
 259
 260
 261
 262
 263
 264 class patternFreezeThread : public QThread
 265 {
 266 public:
 267         patternFreezeThread( pattern * _pattern );
 268         virtual ~patternFreezeThread();
 269
 270
 271 protected:
 272         virtual void run();
 273
 274
 275 private:
 276         pattern * m_pattern;
 277         patternFreezeStatusDialog * m_statusDlg;
 278
 279 } ;
 280
 281
 282 #endif