path: root/src/gui/editors/matrix/MatrixView.h

/*
    Rosegarden
    A MIDI and audio sequencer and musical notation editor.

    This program is Copyright 2000-2008
        Guillaume Laurent   <[email protected]>,
        Chris Cannam        <[email protected]>,
        Richard Bown        <[email protected]>

    The moral rights of Guillaume Laurent, Chris Cannam, and Richard
    Bown to claim authorship of this work have been asserted.

    Other copyrights also apply to some parts of this work.  Please
    see the AUTHORS file and individual file headers for details.

    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.  See the file
    COPYING included with this distribution for more information.
*/

#ifndef _RG_MATRIXVIEW_H_
#define _RG_MATRIXVIEW_H_

#include "base/MidiProgram.h"
#include "base/PropertyName.h"
#include "base/SnapGrid.h"
#include "gui/general/EditView.h"
#include "gui/widgets/ZoomSlider.h"
#include "MatrixHLayout.h"
#include "MatrixVLayout.h"
#include "MatrixCanvasView.h"
#include <kdockwidget.h>
#include <tqpoint.h>
#include <tqsize.h>
#include <vector>
#include "base/Event.h"
#include "document/ConfigGroups.h"


class TQWidget;
class TQPaintEvent;
class TQObject;
class TQMouseEvent;
class TQLabel;
class TQCursor;
class TQCanvas;
class KComboBox;


namespace Rosegarden
{

class Staff;
class Segment;
class RulerScale;
class RosegardenGUIDoc;
class QDeferScrollView;
class PropertyViewRuler;
class PropertyBox;
class PitchRuler;
class MidiKeyMapping;
class MatrixStaff;
class MatrixElement;
class InstrumentParameterBox;
class Instrument;
class EventSelection;
class Event;
class ChordNameRuler;
class LevelInfo;


/**
 * Matrix ("Piano Roll") View
 *
 * Note: we currently display only one staff
 */
class MatrixView : public EditView
{
    Q_OBJECT
  

    friend class MatrixSelector;

public:
    MatrixView(RosegardenGUIDoc *doc,
               std::vector<Segment *> segments,
               TQWidget *parent, bool drumMode);

    virtual ~MatrixView();

    virtual bool applyLayout(int staffNo = -1,
                             timeT startTime = 0,
                             timeT endTime = 0);

    virtual void refreshSegment(Segment *segment,
                                timeT startTime = 0,
                                timeT endTime = 0);

    TQCanvas* canvas() { return getCanvasView()->canvas(); }

    void setCanvasCursor(const TQCursor &cursor) {
        getCanvasView()->viewport()->setCursor(cursor);
    }

    MatrixStaff* getStaff(int i)
    {
        if (i >= 0 && unsigned(i) < m_staffs.size()) return m_staffs[i];
        else return 0;
    }

    MatrixStaff *getStaff(const Segment &segment);

    virtual void updateView();

    bool isDrumMode() { return m_drumMode; }

    /**
     * Discover whether chord-mode insertions are enabled (as opposed
     * to the default melody-mode)
     */
    bool isInChordMode();

    /**
     * Set the current event selection.
     *
     * If preview is true, sound the selection as well.
     *
     * If redrawNow is true, recolour the elements on the canvas;
     * otherwise just line up a refresh for the next paint event.
     *
     * (If the selection has changed as part of a modification to a
     * segment, redrawNow should be unnecessary and undesirable, as a
     * paint event will occur in the next event loop following the
     * command invocation anyway.)
     */
    virtual void setCurrentSelection(EventSelection* s,
                                     bool preview = false,
                                     bool redrawNow = false);

    /**
     * Set the current event selection to a single event
     */
    void setSingleSelectedEvent(int staffNo,
                                Event *event,
                                bool preview = false,
                                bool redrawNow = false);

    /**
     * Set the current event selection to a single event
     */
    void setSingleSelectedEvent(Segment &segment,
                                Event *event,
                                bool preview = false,
                                bool redrawNow = false);


    /**
     * Play a Note Event using the keyPressed() signal
     */
    void playNote(Event *event);

    /**
     * Play a preview (same as above but a simpler interface)
     */
    void playNote(const Segment &segment, int pitch, int velocity = -1);

    /**
     * Get the SnapGrid
     */
    const SnapGrid &getSnapGrid() const { return *m_snapGrid; }

    /**
     * Add a ruler that allows control of a single property -
     * return the number of the added ruler
     * 
     */
    unsigned int addPropertyViewRuler(const PropertyName &property);

    /**
     * Remove a control ruler - return true if it's a valid ruler number
     */
    bool removePropertyViewRuler(unsigned int number);

    /**
     * Adjust an X coord by world matrix
     */
    double getXbyWorldMatrix(double value)
    { return m_canvasView->worldMatrix().m11() * value; }
        
    double getXbyInverseWorldMatrix(double value)
    { return m_canvasView->inverseWorldMatrix().m11() * value; }

    TQPoint inverseMapPoint(const TQPoint& p) { return m_canvasView->inverseMapPoint(p); }

    /*
     * Repaint the control rulers
     *
     */
    void repaintRulers();

    /*
     * Readjust the canvas size
     *
     */
    void readjustCanvasSize();

    /*
     * Scrolls the view such that the given time is centered
     */
    void scrollToTime(timeT t);

    /**
     * Get the local keyMapping (when in drum mode)
     */
    MidiKeyMapping *getKeyMapping() { return m_localMapping; }

    /**
     * Get the velocity currently set in the velocity menu.
     */
    int getCurrentVelocity() const;

signals:
    /**
     * Emitted when the selection has been cut or copied
     *
     * @see MatrixSelector#hideSelection
     */
    void usedSelection();

    void play();
    void stop();
    void fastForwardPlayback();
    void rewindPlayback();
    void fastForwardPlaybackToEnd();
    void rewindPlaybackToBeginning();
    void jumpPlaybackTo(timeT);
    void panic();

    void stepByStepTargetRequested(TQObject *);

    void editTriggerSegment(int);
    
    void editTimeSignature(timeT);

public slots:

    /**
     * put the indicationed text/object into the clipboard and remove * it
     * from the document
     */
    virtual void slotEditCut();

    /**
     * put the indicationed text/object into the clipboard
     */
    virtual void slotEditCopy();

    /**
     * paste the clipboard into the document
     */
    virtual void slotEditPaste();

    /**
     * Delete the current selection
     */
    void slotEditDelete();

    virtual void slotStepBackward(); // override from EditView
    virtual void slotStepForward(); // override from EditView

    void slotPreviewSelection();
    void slotClearLoop();
    void slotClearSelection();

    /**
     * Filter selection by event type
     */
    void slotFilterSelection(); // dummy - not actually functional yet

    /// edition tools
    void slotPaintSelected();
    void slotEraseSelected();
    void slotSelectSelected();
    void slotMoveSelected();
    void slotResizeSelected();

    void slotToggleStepByStep();

    /// status stuff
    void slotUpdateInsertModeStatus();

    /// transforms
    void slotTransformsQuantize();
    void slotTransformsRepeatQuantize();
    void slotTransformsLegato();
    void slotVelocityUp();
    void slotVelocityDown();

    /// settings
    void slotToggleChordsRuler();
    void slotToggleTempoRuler();

    /// cursor moves
    void slotJumpCursorToPlayback();
    void slotJumpPlaybackToCursor();
    void slotToggleTracking();

    /// Canvas actions slots

    /**
     * Called when a mouse press occurred on a matrix element
     * or somewhere on the staff
     */
    void slotMousePressed(timeT time, int pitch,
                          TQMouseEvent*, MatrixElement*);

    void slotMouseMoved(timeT time, int pitch, TQMouseEvent*);
    void slotMouseReleased(timeT time, int pitch, TQMouseEvent*);

    /**
     * Called when the mouse cursor moves over a different height on
     * the staff
     *
     * @see MatrixCanvasView#hoveredOverNoteChanged()
     */
    void slotHoveredOverNoteChanged(int evPitch, bool haveEvent,
                                    timeT evTime);

    /**
     * Called when the mouse cursor moves over a different key on
     * the piano keyboard
     *
     * @see PianoKeyboard#hoveredOverKeyChanged()
     */
    void slotHoveredOverKeyChanged(unsigned int);

    /**
     * Called when the mouse cursor moves over a note which is at a
     * different time on the staff
     *
     * @see MatrixCanvasView#hoveredOverNoteChange()
     */
    void slotHoveredOverAbsoluteTimeChanged(unsigned int);

    /**
     * Set the time pointer position during playback
     */
    void slotSetPointerPosition(timeT time);

    /**
     * Set the time pointer position during playback
     */
    void slotSetPointerPosition(timeT time,
                                bool scroll);

    /**
     * Set the insertion pointer position (from the bottom LoopRuler)
     */
    void slotSetInsertCursorPosition(timeT position, bool scroll);

    virtual void slotSetInsertCursorPosition(timeT position) {
        slotSetInsertCursorPosition(position, true);
    }

    /**
     * Catch the keyboard being pressed
     */
    void slotKeyPressed(unsigned int y, bool repeating);

    /**
     * Catch the keyboard being released
     */
    void slotKeyReleased(unsigned int y, bool repeating);

    /**
     * Catch the keyboard being pressed with selection modifier
     */
    void slotKeySelected(unsigned int y, bool repeating);

    /**
     * Handle scrolling between view and PianoKeyboard
     */
    void slotVerticalScrollPianoKeyboard(int y);

    /**
     * Close
     */
    void closeWindow();

    /**
     * A new selection has been acquired by a tool
     */
    void slotNewSelection();

    /**
     * Set the snaptime of the grid from an item in the snap combo
     */
    void slotSetSnapFromIndex(int);

    /**
     * Set the snaptime of the grid based on the name of the invoking action
     */
    void slotSetSnapFromAction();

    /**
     * Set the snaptime of the grid
     */
    void slotSetSnap(timeT);

    /**
     * Quantize a selection to a given level
     */
    void slotQuantizeSelection(int);

    /**
     * Collapse equal pitch notes
     */
    void slotTransformsCollapseNotes();

    /**
     * Pop-up the velocity modification dialog
     */
    void slotSetVelocities();

    /**
     * Set selected event velocities to whatever's in the velocity widget
     */
    void slotSetVelocitiesToCurrent();

    /**
     * Pop-up the select trigger segment dialog
     */
    void slotTriggerSegment();

    /**
     * Clear triggers from selection
     */
    void slotRemoveTriggers();

    /**
     * Change horizontal zoom
     */
    void slotChangeHorizontalZoom(int);

    void slotZoomIn();
    void slotZoomOut();

    /**
     * Select all
     */
    void slotSelectAll();

    /**
     * Keyboard insert
     */
    void slotInsertNoteFromAction();

    /// Note-on received asynchronously -- consider step-by-step editing
    void slotInsertableNoteOnReceived(int pitch, int velocity);

    /// Note-off received asynchronously -- consider step-by-step editing
    void slotInsertableNoteOffReceived(int pitch, int velocity);

    /// Note-on or note-off received asynchronously -- as above
    void slotInsertableNoteEventReceived(int pitch, int velocity, bool noteOn);

    /// The given TQObject has originated a step-by-step-editing request
    void slotStepByStepTargetRequested(TQObject *);

    void slotInstrumentLevelsChanged(InstrumentId,
                                     const LevelInfo &);

    /// Set the velocity menu to the given value
    void slotSetCurrentVelocity(int);
    void slotSetCurrentVelocityFromSelection();

protected slots:
    void slotCanvasBottomWidgetHeightChanged(int newHeight);

    /**
     * A new percussion key mapping has to be displayed
     */
    void slotPercussionSetChanged(Instrument *);

    /**
     * Re-dock the parameters box to its initial position
     */
    void slotDockParametersBack();

    /**
     * The parameters box was closed
     */
    void slotParametersClosed();

    /**
     * The parameters box was docked back
     */
    void slotParametersDockedBack(KDockWidget*, KDockWidget::DockPosition);

    /**
     * The instrument for this track may have changed
     */
    void slotCheckTrackAssignments();

    void slotToolHelpChanged(const TQString &);
    void slotMouseEnteredCanvasView();
    void slotMouseLeftCanvasView();
    
protected:
    virtual RulerScale* getHLayout();

    virtual Segment *getCurrentSegment();
    virtual Staff *getCurrentStaff();
    virtual timeT getInsertionTime();

    /**
     * save general Options like all bar positions and status as well
     * as the geometry and the recent file list to the configuration
     * file
     */
    virtual void slotSaveOptions();

    /**
     * read general Options again and initialize all variables like the recent file list
     */
    virtual void readOptions();

    /**
     * create menus and toolbars
     */
    virtual void setupActions();

    /**
     * setup status bar
     */
    virtual void initStatusBar();

    /**
     * update the current quantize level from selection or entire segment
     */
    virtual void updateQuantizeCombo();

    /**
     * Return the size of the MatrixCanvasView
     */
    virtual TQSize getViewSize();

    /**
     * Set the size of the MatrixCanvasView
     */
    virtual void setViewSize(TQSize);

    virtual MatrixCanvasView *getCanvasView();

    /**
     * Init matrix actions toolbar
     */
    void initActionsToolbar();

    /**
     * Zoom toolbar
     */
    void initZoomToolbar();

    /**
     * Test whether we've had too many preview notes recently
     */
    bool canPreviewAnotherNote();

    virtual void paintEvent(TQPaintEvent* e);

    virtual void updateViewCaption();

    int computePostLayoutWidth();

    /**
     * Get min and max pitches of notes on matrix.
     * Return false if no notes.
     */
    bool getMinMaxPitches(int& minPitch, int& maxPitch);

    /**
     * If necessary, extend local keymapping to contain
     * all notes currently on staff
     */
    void extendKeyMapping();

    //--------------- Data members ---------------------------------

    std::vector<MatrixStaff*> m_staffs;

    MatrixHLayout             m_hlayout;
    MatrixVLayout             m_vlayout;
    SnapGrid     *m_snapGrid;

    timeT         m_lastEndMarkerTime;

    // Status bar elements
    TQLabel* m_hoveredOverAbsoluteTime;
    TQLabel* m_hoveredOverNoteName;
    TQLabel *m_selectionCounter;
    TQLabel *m_insertModeLabel;
    bool m_haveHoveredOverNote;

    /**
     * used in slotHoveredOverKeyChanged to track moves over the piano
     * keyboard
     */
    int m_previousEvPitch;

    KDockWidget         *m_dockLeft;
    MatrixCanvasView    *m_canvasView;
    QDeferScrollView    *m_pianoView;
    PitchRuler          *m_pitchRuler;

    MidiKeyMapping *m_localMapping;

    // The last note we sent in case we're swooshing up and
    // down the keyboard and don't want repeat notes sending
    //
    MidiByte m_lastNote;

    // The first note we sent in similar case (only used for
    // doing effective sweep selections
    //
    MidiByte m_firstNote;

    PropertyName m_selectedProperty;

    // The parameter box
    //
    InstrumentParameterBox *m_parameterBox;

    // Toolbar flora
    //
    KComboBox          *m_velocityCombo;
    KComboBox          *m_quantizeCombo;
    KComboBox          *m_snapGridCombo;
    ZoomSlider<double> *m_hZoomSlider;
    ZoomSlider<double> *m_vZoomSlider;
    TQLabel             *m_zoomLabel;
 
    // Hold our matrix quantization values and snap values
    //
    std::vector<timeT> m_quantizations;
    std::vector<timeT> m_snapValues;

    std::vector<std::pair<PropertyViewRuler*, PropertyBox*> >  m_propertyViewRulers;

    ChordNameRuler *m_chordNameRuler;
    TQWidget        *m_tempoRuler;

    // ruler used to scale tempo and chord name ruler
    ZoomableMatrixHLayoutRulerScale* m_referenceRuler;

    std::vector<std::pair<int, int> > m_pendingInsertableNotes;

    bool m_playTracking;
    bool m_dockVisible;
    bool m_drumMode;

    bool m_mouseInCanvasView;
    TQString m_toolContextHelp;
};

// Commented this out - was a MatrixView inner class, but we get a warning
// that Q_OBJECT can't be used in an inner class - gl
//

// class NoteSender : public TQObject
// {
//     Q_OBJECT
//     
        
// public:
//     NoteSender(int i, int p) : m_insid(i), m_pitch(p) { }
//     virtual ~NoteSender();
        
// public slots:
// void sendNote();
    
// private:
//     int m_insid, m_pitch;
// };


}

#endif