Added old abandoned KDE3 version of the RoseGarden MIDI tool

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/rosegarden@1097595 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 1717 insertions, 0 deletions

diff --git a/src/gui/general/EditView.cpp b/src/gui/general/EditView.cpp
new file mode 100644
index 0000000..a36b385
--- /dev/null
+++ b/src/gui/general/EditView.cpp
@@ -0,0 +1,1717 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
+
+/*
+    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.
+*/
+
+
+#include "EditView.h"
+#include <qlayout.h>
+
+#include "base/BaseProperties.h"
+#include <klocale.h>
+#include <kconfig.h>
+#include "misc/Debug.h"
+#include "misc/Strings.h"
+#include "ActiveItem.h"
+#include "base/AnalysisTypes.h"
+#include "base/Composition.h"
+#include "base/CompositionTimeSliceAdapter.h"
+#include "base/Controllable.h"
+#include "base/ControlParameter.h"
+#include "base/Device.h"
+#include "base/Event.h"
+#include "base/Exception.h"
+#include "base/Instrument.h"
+#include "base/MidiDevice.h"
+#include "base/MidiProgram.h"
+#include "base/MidiTypes.h"
+#include "base/NotationTypes.h"
+#include "base/Profiler.h"
+#include "base/Property.h"
+#include "base/PropertyName.h"
+#include "base/RulerScale.h"
+#include "base/Segment.h"
+#include "base/Selection.h"
+#include "base/SoftSynthDevice.h"
+#include "base/Staff.h"
+#include "base/Studio.h"
+#include "base/ViewElement.h"
+#include "commands/edit/InvertCommand.h"
+#include "commands/edit/MoveCommand.h"
+#include "commands/edit/RescaleCommand.h"
+#include "commands/edit/RetrogradeCommand.h"
+#include "commands/edit/RetrogradeInvertCommand.h"
+#include "commands/edit/TransposeCommand.h"
+#include "commands/segment/AddTempoChangeCommand.h"
+#include "commands/segment/AddTimeSignatureAndNormalizeCommand.h"
+#include "commands/segment/AddTimeSignatureCommand.h"
+#include "document/MultiViewCommandHistory.h"
+#include "document/RosegardenGUIDoc.h"
+#include "document/ConfigGroups.h"
+#include "EditViewBase.h"
+#include "gui/dialogs/RescaleDialog.h"
+#include "gui/dialogs/TempoDialog.h"
+#include "gui/dialogs/IntervalDialog.h"
+#include "gui/dialogs/TimeSignatureDialog.h"
+#include "gui/rulers/StandardRuler.h"
+#include "gui/kdeext/KTmpStatusMsg.h"
+#include "gui/kdeext/QCanvasGroupableItem.h"
+#include "gui/rulers/ControllerEventsRuler.h"
+#include "gui/rulers/ControlRuler.h"
+#include "gui/rulers/PropertyControlRuler.h"
+#include "RosegardenCanvasView.h"
+#include <kaction.h>
+#include <kcommand.h>
+#include <kdockwidget.h>
+#include <kglobal.h>
+#include <kiconloader.h>
+#include <kstddirs.h>
+#include <ktabwidget.h>
+#include <kxmlguiclient.h>
+#include <qaccel.h>
+#include <qbutton.h>
+#include <qdialog.h>
+#include <qframe.h>
+#include <qinputdialog.h>
+#include <qlabel.h>
+#include <qobjectlist.h>
+#include <qpopupmenu.h>
+#include <qsize.h>
+#include <qstring.h>
+#include <qtabwidget.h>
+#include <qvbox.h>
+#include <qwidget.h>
+#include <qwmatrix.h>
+
+
+namespace Rosegarden
+{
+
+const unsigned int EditView::CONTROLS_ROW         = 0;
+const unsigned int EditView::RULERS_ROW           = CONTROLS_ROW + 1;
+const unsigned int EditView::TOPBARBUTTONS_ROW    = RULERS_ROW + 1;
+const unsigned int EditView::CANVASVIEW_ROW       = TOPBARBUTTONS_ROW + 1;
+const unsigned int EditView::CONTROLRULER_ROW     = CANVASVIEW_ROW + 1;
+
+// Just some simple features we might want to show - make them bit maskable
+//
+static int FeatureShowVelocity = 0x00001; // show the velocity ruler
+
+EditView::EditView(RosegardenGUIDoc *doc,
+                   std::vector<Segment *> segments,
+                   unsigned int cols,
+                   QWidget *parent, const char *name) :
+        EditViewBase(doc, segments, cols, parent, name),
+        m_currentEventSelection(0),
+        m_activeItem(0),
+        m_canvasView(0),
+        m_rulerBox(new QVBoxLayout),  // top ruler box - added to grid later on
+        m_rulerBoxFiller(0),          // On the left of m_rulerBox
+        m_controlBox(new QVBoxLayout),  // top control ruler box - added to grid later on
+        m_bottomBox(new QVBox(this, "bottomframe")),  // bottom box - added to bottom of canvas view by setCanvasView()
+        m_topStandardRuler(0),
+        m_bottomStandardRuler(0),
+        m_controlRuler(0),
+        m_controlRulers(new KTabWidget(getBottomWidget(), "controlrulers"))
+{
+    m_controlRulers->setHoverCloseButton(true);
+    m_controlRulers->setHoverCloseButtonDelayed(false);
+    connect(m_controlRulers, SIGNAL(closeRequest(QWidget*)),
+            this, SLOT(slotRemoveControlRuler(QWidget*)));
+
+    (dynamic_cast<QBoxLayout*>(m_bottomBox->layout()))->setDirection(QBoxLayout::BottomToTop);
+
+    // m_rulerBoxFiller is a white label used to keep m_rulerBox exactly
+    // above the scrolling part of the view (and never above the
+    // RosegardenCanvasView::m_leftWidget).
+    QGridLayout * gl = new QGridLayout(1, 2); 
+    gl->setColStretch(0, 0);
+    gl->setColStretch(1, 1);
+    gl->addLayout(m_rulerBox, 0, 1);
+    m_rulerBoxFiller = new QLabel(getCentralWidget());
+    gl->addWidget(m_rulerBoxFiller, 0, 0);
+    m_rulerBoxFiller->hide();
+
+    m_grid->addLayout(gl, RULERS_ROW, m_mainCol);
+
+    m_grid->addMultiCellLayout(m_controlBox, CONTROLS_ROW, CONTROLS_ROW, 0, 1);
+    m_controlBox->setAlignment(AlignRight);
+    //     m_grid->addWidget(m_controlRulers, CONTROLRULER_ROW, 2);
+
+    m_controlRulers->hide();
+    m_controlRulers->setTabPosition(QTabWidget::Bottom);
+}
+
+EditView::~EditView()
+{
+    delete m_currentEventSelection;
+    m_currentEventSelection = 0;
+}
+
+void EditView::updateBottomWidgetGeometry()
+{
+    getBottomWidget()->layout()->invalidate();
+    getBottomWidget()->updateGeometry();
+    getCanvasView()->updateBottomWidgetGeometry();
+}
+
+void EditView::paintEvent(QPaintEvent* e)
+{
+    RG_DEBUG << "EditView::paintEvent()\n";
+    EditViewBase::paintEvent(e);
+
+    if (m_needUpdate) {
+        RG_DEBUG << "EditView::paintEvent() - calling updateView\n";
+        updateView();
+        getCanvasView()->slotUpdate();
+
+        // update rulers
+        QLayoutIterator it = m_rulerBox->iterator();
+        QLayoutItem *child;
+        while ( (child = it.current()) != 0 ) {
+            if (child->widget())
+                child->widget()->update();
+            ++it;
+        }
+
+        updateControlRulers();
+
+    } else {
+
+        getCanvasView()->slotUpdate();
+        updateControlRulers();
+
+    }
+
+    m_needUpdate = false;
+}
+
+void EditView::updateControlRulers(bool updateHPos)
+{
+    for (int i = 0; i < m_controlRulers->count(); ++i) {
+        ControlRuler* ruler = dynamic_cast<ControlRuler*>(m_controlRulers->page(i));
+        if (ruler) {
+            if (updateHPos)
+                ruler->slotUpdateElementsHPos();
+            else
+                ruler->slotUpdate();
+        }
+    }
+}
+
+void EditView::setControlRulersZoom(QWMatrix zoomMatrix)
+{
+    m_currentRulerZoomMatrix = zoomMatrix;
+
+    for (int i = 0; i < m_controlRulers->count(); ++i) {
+        ControlRuler* ruler = dynamic_cast<ControlRuler*>(m_controlRulers->page(i));
+        if (ruler)
+            ruler->setWorldMatrix(zoomMatrix);
+    }
+}
+
+void EditView::setControlRulersCurrentSegment()
+{
+    RG_DEBUG << "EditView::setControlRulersCurrentSegment: visible is " << m_controlRulers->isVisible() << endl;
+
+    bool visible = m_controlRulers->isVisible();
+
+    delete m_controlRulers;
+    m_controlRulers = new KTabWidget(getBottomWidget(), "controlrulers");
+
+    bool haveTabs = setupControllerTabs();
+    setupAddControlRulerMenu();
+
+    if (haveTabs)
+        m_controlRulers->show();
+    else
+        m_controlRulers->hide();
+
+    updateBottomWidgetGeometry();
+
+    /*
+        for (int i = 0; i < m_controlRulers->count(); ++i) {
+     
+            PropertyControlRuler *pcr = dynamic_cast<PropertyControlRuler *>
+    	    (m_controlRulers->page(i));
+     
+            if (pcr) pcr->setStaff(getCurrentStaff());
+    	else {
+     
+    	    ControllerEventsRuler *cer = dynamic_cast<ControllerEventsRuler *>
+    		(m_controlRulers->page(i));
+     
+    	    if (cer) cer->setSegment(getCurrentSegment());
+    	}
+        }
+    */
+}
+
+void EditView::setTopStandardRuler(StandardRuler* w, QWidget *leftBox)
+{
+    delete m_topStandardRuler;
+    m_topStandardRuler = w;
+
+    QGridLayout * gl = new QGridLayout(1, 2); 
+    gl->setColStretch(0, 0);
+    gl->setColStretch(1, 1);
+
+    gl->addWidget(w, 0, 1);
+    if (leftBox) {
+        gl->addWidget(leftBox, 0, 0);
+    }
+
+    m_grid->addLayout(gl, TOPBARBUTTONS_ROW, m_mainCol);
+
+    if (m_canvasView) {
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+                m_topStandardRuler, SLOT(slotScrollHoriz(int)));
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(sliderMoved(int)),
+                m_topStandardRuler, SLOT(slotScrollHoriz(int)));
+    }
+}
+
+void EditView::setBottomStandardRuler(StandardRuler* w)
+{
+    delete m_bottomStandardRuler;
+    m_bottomStandardRuler = w;
+
+    //     m_bottomBox->insertWidget(0, w);
+
+    if (m_canvasView) {
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+                m_bottomStandardRuler, SLOT(slotScrollHoriz(int)));
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(sliderMoved(int)),
+                m_bottomStandardRuler, SLOT(slotScrollHoriz(int)));
+    }
+}
+
+void EditView::setRewFFwdToAutoRepeat()
+{
+    QWidget* transportToolbar = factory()->container("Transport Toolbar", this);
+
+    if (transportToolbar) {
+        QObjectList *l = transportToolbar->queryList();
+        QObjectListIt it(*l); // iterate over the buttons
+        QObject *obj;
+
+        while ( (obj = it.current()) != 0 ) {
+            // for each found object...
+            ++it;
+            //             RG_DEBUG << "EditView::setRewFFwdToAutoRepeat() : obj name : " << obj->name() << endl;
+            QString objName = obj->name();
+
+            if (objName.endsWith("playback_pointer_back_bar") || objName.endsWith("playback_pointer_forward_bar")) {
+                QButton* btn = dynamic_cast<QButton*>(obj);
+                if (!btn) {
+                    RG_DEBUG << "Very strange - found widgets in Transport Toolbar which aren't buttons\n";
+
+                    continue;
+                }
+                btn->setAutoRepeat(true);
+            }
+
+
+        }
+        delete l;
+
+    } else {
+        RG_DEBUG << "transportToolbar == 0\n";
+    }
+
+}
+
+void EditView::addRuler(QWidget* w)
+{
+    m_rulerBox->addWidget(w);
+
+    if (m_canvasView) {
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+                w, SLOT(slotScrollHoriz(int)));
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(sliderMoved(int)),
+                w, SLOT(slotScrollHoriz(int)));
+    }
+}
+
+void EditView::addPropertyBox(QWidget *w)
+{
+    m_controlBox->addWidget(w);
+}
+
+void EditView::addControlRuler(ControlRuler* ruler)
+{
+    ruler->setWorldMatrix(m_currentRulerZoomMatrix);
+    m_controlRulers->addTab(ruler, KGlobal::iconLoader()->loadIconSet("fileclose", KIcon::Small),
+                            ruler->getName());
+    m_controlRulers->showPage(ruler);
+
+    if (m_canvasView) {
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(valueChanged(int)),
+                ruler->horizontalScrollBar(), SIGNAL(valueChanged(int)));
+        connect(m_canvasView->horizontalScrollBar(), SIGNAL(sliderMoved(int)),
+                ruler->horizontalScrollBar(), SIGNAL(sliderMoved(int)));
+    }
+
+    connect(ruler, SIGNAL(stateChange(const QString&, bool)),
+            this, SLOT(slotStateChanged(const QString&, bool)));
+
+    stateChanged("have_control_ruler", KXMLGUIClient::StateReverse);
+}
+
+void EditView::readjustViewSize(QSize requestedSize, bool exact)
+{
+    Profiler profiler("EditView::readjustViewSize", true);
+
+    if (exact) {
+        RG_DEBUG << "EditView::readjustViewSize: exact size requested ("
+        << requestedSize.width() << ", " << requestedSize.height()
+        << ")\n";
+
+        setViewSize(requestedSize);
+        getCanvasView()->slotUpdate();
+        return ;
+    }
+
+    int requestedWidth = requestedSize.width(),
+        requestedHeight = requestedSize.height(),
+        windowWidth = width(),
+        windowHeight = height();
+
+    QSize newSize;
+
+    newSize.setWidth(((requestedWidth / windowWidth) + 1) * windowWidth);
+    newSize.setHeight(((requestedHeight / windowHeight) + 1) * windowHeight);
+
+    RG_DEBUG << "EditView::readjustViewSize: requested ("
+    << requestedSize.width() << ", " << requestedSize.height()
+    << "), getting (" << newSize.width() << ", "
+    << newSize.height() << ")" << endl;
+
+    setViewSize(newSize);
+
+    getCanvasView()->slotUpdate();
+}
+
+void EditView::setCanvasView(RosegardenCanvasView *canvasView)
+{
+    delete m_canvasView;
+    m_canvasView = canvasView;
+    m_grid->addWidget(m_canvasView, CANVASVIEW_ROW, m_mainCol);
+    m_canvasView->setBottomFixedWidget(m_bottomBox);
+
+    // TODO : connect canvas view's horiz. scrollbar to top/bottom bars and rulers
+
+    //     m_horizontalScrollBar->setRange(m_canvasView->horizontalScrollBar()->minValue(),
+    //                                     m_canvasView->horizontalScrollBar()->maxValue());
+
+    //     m_horizontalScrollBar->setSteps(m_canvasView->horizontalScrollBar()->lineStep(),
+    //                                     m_canvasView->horizontalScrollBar()->pageStep());
+
+    //     connect(m_horizontalScrollBar, SIGNAL(valueChanged(int)),
+    //             m_canvasView->horizontalScrollBar(), SIGNAL(valueChanged(int)));
+    //     connect(m_horizontalScrollBar, SIGNAL(sliderMoved(int)),
+    //             m_canvasView->horizontalScrollBar(), SIGNAL(sliderMoved(int)));
+
+}
+
+Device *
+EditView::getCurrentDevice()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return 0;
+
+    Studio &studio = getDocument()->getStudio();
+    Instrument *instrument =
+        studio.getInstrumentById
+        (segment->getComposition()->getTrackById(segment->getTrack())->
+         getInstrument());
+    if (!instrument)
+        return 0;
+
+    return instrument->getDevice();
+}
+
+timeT
+EditView::getInsertionTime(Clef &clef,
+                           Rosegarden::Key &key)
+{
+    timeT t = getInsertionTime();
+    Segment *segment = getCurrentSegment();
+
+    if (segment) {
+        clef = segment->getClefAtTime(t);
+        key = segment->getKeyAtTime(t);
+    } else {
+        clef = Clef();
+        key = ::Rosegarden::Key();
+    }
+
+    return t;
+}
+
+void EditView::slotActiveItemPressed(QMouseEvent* e,
+                                     QCanvasItem* item)
+{
+    if (!item)
+        return ;
+
+    // Check if it's a groupable item, if so get its group
+    //
+    QCanvasGroupableItem *gitem = dynamic_cast<QCanvasGroupableItem*>(item);
+    if (gitem)
+        item = gitem->group();
+
+    // Check if it's an active item
+    //
+    ActiveItem *activeItem = dynamic_cast<ActiveItem*>(item);
+
+    if (activeItem) {
+
+        setActiveItem(activeItem);
+        activeItem->handleMousePress(e);
+        updateView();
+
+    }
+}
+
+void
+EditView::slotStepBackward()
+{
+    Staff *staff = getCurrentStaff();
+    if (!staff)
+        return ;
+    ViewElementList *vel = staff->getViewElementList();
+
+    timeT time = getInsertionTime();
+    ViewElementList::iterator i = vel->findTime(time);
+
+    while (i != vel->begin() &&
+            (i == vel->end() || (*i)->getViewAbsoluteTime() >= time))
+        --i;
+
+    if (i != vel->end())
+        slotSetInsertCursorPosition((*i)->getViewAbsoluteTime());
+}
+
+void
+EditView::slotStepForward()
+{
+    Staff *staff = getCurrentStaff();
+    if (!staff)
+        return ;
+    ViewElementList *vel = staff->getViewElementList();
+
+    timeT time = getInsertionTime();
+    ViewElementList::iterator i = vel->findTime(time);
+
+    while (i != vel->end() &&
+            (*i)->getViewAbsoluteTime() <= time)
+        ++i;
+
+    if (i == vel->end()) {
+        slotSetInsertCursorPosition(staff->getSegment().getEndMarkerTime());
+    } else {
+        slotSetInsertCursorPosition((*i)->getViewAbsoluteTime());
+    }
+}
+
+void
+EditView::slotJumpBackward()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return ;
+    timeT time = getInsertionTime();
+    time = segment->getBarStartForTime(time - 1);
+    slotSetInsertCursorPosition(time);
+}
+
+void
+EditView::slotJumpForward()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return ;
+    timeT time = getInsertionTime();
+    time = segment->getBarEndForTime(time);
+    slotSetInsertCursorPosition(time);
+}
+
+void
+EditView::slotJumpToStart()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return ;
+    timeT time = segment->getStartTime();
+    slotSetInsertCursorPosition(time);
+}
+
+void
+EditView::slotJumpToEnd()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return ;
+    timeT time = segment->getEndMarkerTime();
+    slotSetInsertCursorPosition(time);
+}
+
+void EditView::slotExtendSelectionBackward()
+{
+    slotExtendSelectionBackward(false);
+}
+
+void EditView::slotExtendSelectionBackwardBar()
+{
+    slotExtendSelectionBackward(true);
+}
+
+void EditView::slotExtendSelectionBackward(bool bar)
+{
+    // If there is no current selection, or the selection is entirely
+    // to the right of the cursor, move the cursor left and add to the
+    // selection
+
+    timeT oldTime = getInsertionTime();
+    if (bar)
+        slotJumpBackward();
+    else
+        slotStepBackward();
+    timeT newTime = getInsertionTime();
+
+    Staff *staff = getCurrentStaff();
+    if (!staff)
+        return ;
+    Segment *segment = &staff->getSegment();
+    ViewElementList *vel = staff->getViewElementList();
+
+    EventSelection *es = new EventSelection(*segment);
+    if (m_currentEventSelection &&
+            &m_currentEventSelection->getSegment() == segment)
+        es->addFromSelection(m_currentEventSelection);
+
+    if (!m_currentEventSelection ||
+            &m_currentEventSelection->getSegment() != segment ||
+            m_currentEventSelection->getSegmentEvents().size() == 0 ||
+            m_currentEventSelection->getStartTime() >= oldTime) {
+
+        ViewElementList::iterator extendFrom = vel->findTime(oldTime);
+
+        while (extendFrom != vel->begin() &&
+                (*--extendFrom)->getViewAbsoluteTime() >= newTime) {
+            if ((*extendFrom)->event()->isa(Note::EventType)) {
+                es->addEvent((*extendFrom)->event());
+            }
+        }
+
+    } else { // remove an event
+
+        EventSelection::eventcontainer::iterator i =
+            es->getSegmentEvents().end();
+
+        std::vector<Event *> toErase;
+
+        while (i != es->getSegmentEvents().begin() &&
+                (*--i)->getAbsoluteTime() >= newTime) {
+            toErase.push_back(*i);
+        }
+
+        for (unsigned int j = 0; j < toErase.size(); ++j) {
+            es->removeEvent(toErase[j]);
+        }
+    }
+
+    setCurrentSelection(es);
+}
+
+void EditView::slotExtendSelectionForward()
+{
+    slotExtendSelectionForward(false);
+}
+
+void EditView::slotExtendSelectionForwardBar()
+{
+    slotExtendSelectionForward(true);
+}
+
+void EditView::slotExtendSelectionForward(bool bar)
+{
+    // If there is no current selection, or the selection is entirely
+    // to the left of the cursor, move the cursor right and add to the
+    // selection
+
+    timeT oldTime = getInsertionTime();
+    if (bar)
+        slotJumpForward();
+    else
+        slotStepForward();
+    timeT newTime = getInsertionTime();
+
+    Staff *staff = getCurrentStaff();
+    if (!staff)
+        return ;
+    Segment *segment = &staff->getSegment();
+    ViewElementList *vel = staff->getViewElementList();
+
+    EventSelection *es = new EventSelection(*segment);
+    if (m_currentEventSelection &&
+            &m_currentEventSelection->getSegment() == segment)
+        es->addFromSelection(m_currentEventSelection);
+
+    if (!m_currentEventSelection ||
+            &m_currentEventSelection->getSegment() != segment ||
+            m_currentEventSelection->getSegmentEvents().size() == 0 ||
+            m_currentEventSelection->getEndTime() <= oldTime) {
+
+        ViewElementList::iterator extendFrom = vel->findTime(oldTime);
+
+        while (extendFrom != vel->end() &&
+                (*extendFrom)->getViewAbsoluteTime() < newTime) {
+            if ((*extendFrom)->event()->isa(Note::EventType)) {
+                es->addEvent((*extendFrom)->event());
+            }
+            ++extendFrom;
+        }
+
+    } else { // remove an event
+
+        EventSelection::eventcontainer::iterator i =
+            es->getSegmentEvents().begin();
+
+        std::vector<Event *> toErase;
+
+        while (i != es->getSegmentEvents().end() &&
+                (*i)->getAbsoluteTime() < newTime) {
+            toErase.push_back(*i);
+            ++i;
+        }
+
+        for (unsigned int j = 0; j < toErase.size(); ++j) {
+            es->removeEvent(toErase[j]);
+        }
+    }
+
+    setCurrentSelection(es);
+}
+
+void
+EditView::setupActions()
+{
+    createInsertPitchActionMenu();
+
+    //
+    // Tempo and time signature changes
+    //
+    QString pixmapDir = KGlobal::dirs()->findResource("appdata", "pixmaps/");
+    QCanvasPixmap pixmap(pixmapDir + "/toolbar/event-insert-tempo.png");
+    QIconSet icon = QIconSet(pixmap);
+    new KAction(AddTempoChangeCommand::getGlobalName(),
+		icon, 0,
+		this, SLOT(slotAddTempo()),
+		actionCollection(), "add_tempo");
+
+    pixmap.load(pixmapDir + "/toolbar/event-insert-timesig.png");
+    icon = QIconSet(pixmap);
+    new KAction(AddTimeSignatureCommand::getGlobalName(),
+		icon, 0,
+		this, SLOT(slotAddTimeSignature()),
+		actionCollection(), "add_time_signature");
+
+    //
+    // Transforms
+    //
+    new KAction(i18n("&Halve Durations"), Key_H + CTRL, this,
+                SLOT(slotHalveDurations()), actionCollection(),
+                "halve_durations");
+
+    new KAction(i18n("&Double Durations"), Key_H + CTRL + SHIFT, this,
+                SLOT(slotDoubleDurations()), actionCollection(),
+                "double_durations");
+
+    new KAction(RescaleCommand::getGlobalName(), 0, this,
+                SLOT(slotRescale()), actionCollection(),
+                "rescale");
+
+    new KAction(TransposeCommand::getGlobalName(1), 0,
+                Key_Up, this,
+                SLOT(slotTransposeUp()), actionCollection(),
+                "transpose_up");
+
+    new KAction(TransposeCommand::getGlobalName(12), 0,
+                Key_Up + CTRL, this,
+                SLOT(slotTransposeUpOctave()), actionCollection(),
+                "transpose_up_octave");
+
+    new KAction(TransposeCommand::getGlobalName( -1), 0,
+                Key_Down, this,
+                SLOT(slotTransposeDown()), actionCollection(),
+                "transpose_down");
+
+    new KAction(TransposeCommand::getGlobalName( -12), 0,
+                Key_Down + CTRL, this,
+                SLOT(slotTransposeDownOctave()), actionCollection(),
+                "transpose_down_octave");
+
+    new KAction(TransposeCommand::getGlobalName(0), 0, this,
+                SLOT(slotTranspose()), actionCollection(),
+                "general_transpose");
+
+    new KAction(TransposeCommand::getDiatonicGlobalName(0,0), 0, this,
+                SLOT(slotDiatonicTranspose()), actionCollection(),
+                "general_diatonic_transpose");
+
+    new KAction(InvertCommand::getGlobalName(0), 0, this,
+                SLOT(slotInvert()), actionCollection(),
+                "invert");
+
+    new KAction(RetrogradeCommand::getGlobalName(0), 0, this,
+                SLOT(slotRetrograde()), actionCollection(),
+                "retrograde");
+
+    new KAction(RetrogradeInvertCommand::getGlobalName(0), 0, this,
+                SLOT(slotRetrogradeInvert()), actionCollection(),
+                "retrograde_invert");
+
+    new KAction(i18n("Jog &Left"), Key_Left + ALT, this,
+                SLOT(slotJogLeft()), actionCollection(),
+                "jog_left");
+
+    new KAction(i18n("Jog &Right"), Key_Right + ALT, this,
+                SLOT(slotJogRight()), actionCollection(),
+                "jog_right");
+
+    // Control rulers
+    //
+    new KAction(i18n("Show Velocity Property Ruler"), 0, this,
+                SLOT(slotShowVelocityControlRuler()), actionCollection(),
+                "show_velocity_control_ruler");
+
+    /*
+    new KAction(i18n("Show Controllers Events Ruler"), 0, this,
+                SLOT(slotShowControllerEventsRuler()), actionCollection(),
+                "show_controller_events_ruler");
+                */
+
+    // Disabled for now
+    //
+    //     new KAction(i18n("Add Control Ruler..."), 0, this,
+    //                 SLOT(slotShowPropertyControlRuler()), actionCollection(),
+    //                 "add_control_ruler");
+
+    //
+    // Control Ruler context menu
+    //
+    new KAction(i18n("Insert item"), 0, this,
+                SLOT(slotInsertControlRulerItem()), actionCollection(),
+                "insert_control_ruler_item");
+
+    // This was on Key_Delete, but that conflicts with existing Delete commands
+    // on individual edit views
+    new KAction(i18n("Erase selected items"), 0, this,
+                SLOT(slotEraseControlRulerItem()), actionCollection(),
+                "erase_control_ruler_item");
+
+    new KAction(i18n("Clear ruler"), 0, this,
+                SLOT(slotClearControlRulerItem()), actionCollection(),
+                "clear_control_ruler_item");
+
+    new KAction(i18n("Insert line of controllers"), 0, this,
+                SLOT(slotStartControlLineItem()), actionCollection(),
+                "start_control_line_item");
+
+    new KAction(i18n("Flip forward"), Key_BracketRight, this,
+                SLOT(slotFlipForwards()), actionCollection(),
+                "flip_control_events_forward");
+
+    new KAction(i18n("Flip backwards"), Key_BracketLeft, this,
+                SLOT(slotFlipBackwards()), actionCollection(),
+                "flip_control_events_back");
+
+    new KAction(i18n("Draw property line"), 0, this,
+                SLOT(slotDrawPropertyLine()), actionCollection(),
+                "draw_property_line");
+
+    new KAction(i18n("Select all property values"), 0, this,
+                SLOT(slotSelectAllProperties()), actionCollection(),
+                "select_all_properties");
+}
+
+void
+EditView::setupAddControlRulerMenu()
+{
+    RG_DEBUG << "EditView::setupAddControlRulerMenu" << endl;
+
+    QPopupMenu* addControlRulerMenu = dynamic_cast<QPopupMenu*>
+                                      (factory()->container("add_control_ruler", this));
+
+    if (addControlRulerMenu) {
+
+        addControlRulerMenu->clear();
+
+        //!!! problem here with notation view -- current segment can
+        // change after construction, but this function isn't used again
+
+        Controllable *c =
+            dynamic_cast<MidiDevice *>(getCurrentDevice());
+        if (!c) {
+            c = dynamic_cast<SoftSynthDevice *>(getCurrentDevice());
+            if (!c)
+                return ;
+        }
+
+        const ControlList &list = c->getControlParameters();
+
+        int i = 0;
+        QString itemStr;
+
+        for (ControlList::const_iterator it = list.begin();
+                it != list.end(); ++it) {
+            if (it->getType() == Controller::EventType) {
+                QString hexValue;
+                hexValue.sprintf("(0x%x)", it->getControllerValue());
+
+                itemStr = i18n("%1 Controller %2 %3").arg(strtoqstr(it->getName()))
+                          .arg(it->getControllerValue())
+                          .arg(hexValue);
+
+            } else if (it->getType() == PitchBend::EventType)
+                itemStr = i18n("Pitch Bend");
+            else
+                itemStr = i18n("Unsupported Event Type");
+
+            addControlRulerMenu->insertItem(itemStr, i++);
+        }
+
+        connect(addControlRulerMenu, SIGNAL(activated(int)),
+                SLOT(slotAddControlRuler(int)));
+    }
+
+}
+
+bool
+EditView::setupControllerTabs()
+{
+    bool have = false;
+
+    // Setup control rulers the Segment already has some stored against it.
+    //
+    Segment *segment = getCurrentSegment();
+    Segment::EventRulerList list = segment->getEventRulerList();
+
+    RG_DEBUG << "EditView::setupControllerTabs - got " << list.size() << " EventRulers" << endl;
+
+    RG_DEBUG << "Segment view features: " << segment->getViewFeatures() << endl;
+    if (segment->getViewFeatures() & FeatureShowVelocity) {
+        showPropertyControlRuler(BaseProperties::VELOCITY);
+        have = true;
+    }
+
+    if (list.size()) {
+        Controllable *c =
+            dynamic_cast<MidiDevice *>(getCurrentDevice());
+        if (!c) {
+            c = dynamic_cast<SoftSynthDevice *>(getCurrentDevice());
+            if (!c)
+                return have;
+        }
+
+        have = true;
+
+        Segment::EventRulerListIterator it;
+
+        for (it = list.begin(); it != list.end(); ++it) {
+            // Get ControlParameter object from controller value
+            //
+            const ControlParameter *controlParameter =
+                c->getControlParameter((*it)->m_type,
+                                       MidiByte((*it)->m_controllerValue));
+
+            RG_DEBUG << "EditView::setupControllerTabs - "
+            << "Control Parameter type = " << (*it)->m_type << endl;
+
+            if (controlParameter) {
+                ControllerEventsRuler* controlRuler = makeControllerEventRuler(controlParameter);
+                addControlRuler(controlRuler);
+                RG_DEBUG << "EditView::setupControllerTabs - adding Ruler" << endl;
+            }
+        }
+
+        if (!m_controlRulers->isVisible())
+            m_controlRulers->show();
+
+        updateBottomWidgetGeometry();
+    }
+
+    return have;
+}
+
+void
+EditView::slotAddControlRuler(int controller)
+{
+    RG_DEBUG << "EditView::slotAddControlRuler - item = "
+    << controller << endl;
+
+    Controllable *c =
+        dynamic_cast<MidiDevice *>(getCurrentDevice());
+    if (!c) {
+        c = dynamic_cast<SoftSynthDevice *>(getCurrentDevice());
+        if (!c)
+            return ;
+    }
+
+    const ControlList &list = c->getControlParameters();
+    ControlParameter control = list[controller];
+
+    int index = 0;
+
+    ControlRuler* existingRuler = findRuler(control, index);
+
+    if (existingRuler) {
+
+        m_controlRulers->setCurrentPage(index);
+
+    } else {
+
+        // Create control ruler to a specific controller.  This duplicates
+        // the control parameter in the supplied pointer.
+        ControllerEventsRuler* controlRuler = makeControllerEventRuler(&control);
+
+        addControlRuler(controlRuler);
+    }
+
+    if (!m_controlRulers->isVisible()) {
+        m_controlRulers->show();
+    }
+
+    updateBottomWidgetGeometry();
+
+    // Add the controller to the segment so the views can
+    // remember what we've opened against it.
+    //
+    Staff *staff = getCurrentStaff();
+    staff->getSegment().addEventRuler(control.getType(), control.getControllerValue());
+
+    getDocument()->slotDocumentModified();
+}
+
+void EditView::slotRemoveControlRuler(QWidget* w)
+{
+    ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(w);
+
+    if (ruler) {
+        ControlParameter *controller = ruler->getControlParameter();
+
+        // remove the control parameter from the "showing controllers" list on the segment
+        //
+        if (controller) {
+            Staff *staff = getCurrentStaff();
+            bool value = staff->getSegment().
+                         deleteEventRuler(controller->getType(), controller->getControllerValue());
+
+            if (value)
+                RG_DEBUG << "slotRemoveControlRuler : removed controller from segment\n";
+            else
+                RG_DEBUG << "slotRemoveControlRuler : couldn't remove controller from segment - "
+                << int(controller->getControllerValue())
+                << endl;
+
+        }
+    } else { // else it's probably a velocity ruler
+        PropertyControlRuler *propertyRuler = dynamic_cast<PropertyControlRuler*>(w);
+
+        if (propertyRuler) {
+            Segment &seg = getCurrentStaff()->getSegment();
+            seg.setViewFeatures(0); // for the moment we only have one view feature so
+            // we can just blank it out
+
+            RG_DEBUG << "slotRemoveControlRuler : removed velocity ruler" << endl;
+        }
+    }
+
+    delete w;
+
+    if (m_controlRulers->count() == 0) {
+        m_controlRulers->hide();
+        updateBottomWidgetGeometry();
+    }
+
+    getDocument()->slotDocumentModified();
+}
+
+void
+EditView::createInsertPitchActionMenu()
+{
+    QString notePitchNames[] = {
+                                   i18n("I"), i18n("II"), i18n("III"), i18n("IV"),
+                                   i18n("V"), i18n("VI"), i18n("VII"), i18n("VIII")
+                               };
+    QString flat = i18n("%1 flat");
+    QString sharp = i18n("%1 sharp");
+
+    const Key notePitchKeys[3][7] = {
+                                        {
+                                            Key_A, Key_S, Key_D, Key_F, Key_J, Key_K, Key_L,
+                                        },
+                                        {
+                                            Key_Q, Key_W, Key_E, Key_R, Key_U, Key_I, Key_O,
+                                        },
+                                        {
+                                            Key_Z, Key_X, Key_C, Key_V, Key_B, Key_N, Key_M,
+                                        },
+                                    };
+
+    KActionMenu *insertPitchActionMenu =
+        new KActionMenu(i18n("&Insert Note"), this, "insert_note_actionmenu");
+
+    for (int octave = 0; octave <= 2; ++octave) {
+
+        KActionMenu *menu = insertPitchActionMenu;
+        if (octave == 1) {
+            menu = new KActionMenu(i18n("&Upper Octave"), this,
+                                   "insert_note_actionmenu_upper_octave");
+            insertPitchActionMenu->insert(new KActionSeparator(this));
+            insertPitchActionMenu->insert(menu);
+        } else if (octave == 2) {
+            menu = new KActionMenu(i18n("&Lower Octave"), this,
+                                   "insert_note_actionmenu_lower_octave");
+            insertPitchActionMenu->insert(menu);
+        }
+
+        for (unsigned int i = 0; i < 7; ++i) {
+
+            KAction *insertPitchAction = 0;
+
+            QString octaveSuffix;
+            if (octave == 1)
+                octaveSuffix = "_high";
+            else if (octave == 2)
+                octaveSuffix = "_low";
+
+            // do and fa lack a flat
+
+            if (i != 0 && i != 3) {
+
+                insertPitchAction =
+                    new KAction
+                    (flat.arg(notePitchNames[i]),
+                     CTRL + SHIFT + notePitchKeys[octave][i],
+                     this, SLOT(slotInsertNoteFromAction()), actionCollection(),
+                     QString("insert_%1_flat%2").arg(i).arg(octaveSuffix));
+
+                menu->insert(insertPitchAction);
+            }
+
+            insertPitchAction =
+                new KAction
+                (notePitchNames[i],
+                 notePitchKeys[octave][i],
+                 this, SLOT(slotInsertNoteFromAction()), actionCollection(),
+                 QString("insert_%1%2").arg(i).arg(octaveSuffix));
+
+            menu->insert(insertPitchAction);
+
+            // and mi and ti lack a sharp
+
+            if (i != 2 && i != 6) {
+
+                insertPitchAction =
+                    new KAction
+                    (sharp.arg(notePitchNames[i]),
+                     SHIFT + notePitchKeys[octave][i],
+                     this, SLOT(slotInsertNoteFromAction()), actionCollection(),
+                     QString("insert_%1_sharp%2").arg(i).arg(octaveSuffix));
+
+                menu->insert(insertPitchAction);
+            }
+
+            if (i < 6)
+                menu->insert(new KActionSeparator(this));
+        }
+    }
+
+    actionCollection()->insert(insertPitchActionMenu);
+}
+
+int
+EditView::getPitchFromNoteInsertAction(QString name,
+                                       Accidental &accidental,
+                                       const Clef &clef,
+                                       const ::Rosegarden::Key &key)
+{
+    using namespace Accidentals;
+
+    accidental = NoAccidental;
+
+    if (name.left(7) == "insert_") {
+
+        name = name.right(name.length() - 7);
+
+        int modify = 0;
+        int octave = 0;
+
+        if (name.right(5) == "_high") {
+
+            octave = 1;
+            name = name.left(name.length() - 5);
+
+        } else if (name.right(4) == "_low") {
+
+            octave = -1;
+            name = name.left(name.length() - 4);
+        }
+
+        if (name.right(6) == "_sharp") {
+
+            modify = 1;
+            accidental = Sharp;
+            name = name.left(name.length() - 6);
+
+        } else if (name.right(5) == "_flat") {
+
+            modify = -1;
+            accidental = Flat;
+            name = name.left(name.length() - 5);
+        }
+
+        int scalePitch = name.toInt();
+
+        if (scalePitch < 0 || scalePitch > 7) {
+            NOTATION_DEBUG << "EditView::getPitchFromNoteInsertAction: pitch "
+            << scalePitch << " out of range, using 0" << endl;
+            scalePitch = 0;
+        }
+
+        Pitch pitch
+        (scalePitch, 4 + octave + clef.getOctave(), key, accidental);
+        return pitch.getPerformancePitch();
+
+    } else {
+
+        throw Exception("Not an insert action",
+                        __FILE__, __LINE__);
+    }
+}
+
+void EditView::slotAddTempo()
+{
+    timeT insertionTime = getInsertionTime();
+
+    TempoDialog tempoDlg(this, getDocument());
+
+    connect(&tempoDlg,
+            SIGNAL(changeTempo(timeT,
+                               tempoT,
+                               tempoT,
+                               TempoDialog::TempoDialogAction)),
+            this,
+            SIGNAL(changeTempo(timeT,
+                               tempoT,
+                               tempoT,
+                               TempoDialog::TempoDialogAction)));
+
+    tempoDlg.setTempoPosition(insertionTime);
+    tempoDlg.exec();
+}
+
+void EditView::slotAddTimeSignature()
+{
+    Segment *segment = getCurrentSegment();
+    if (!segment)
+        return ;
+    Composition *composition = segment->getComposition();
+    timeT insertionTime = getInsertionTime();
+
+    TimeSignatureDialog *dialog = 0;
+    int timeSigNo = composition->getTimeSignatureNumberAt(insertionTime);
+
+    if (timeSigNo >= 0) {
+
+        dialog = new TimeSignatureDialog
+                 (this, composition, insertionTime,
+                  composition->getTimeSignatureAt(insertionTime));
+
+    } else {
+
+        timeT endTime = composition->getDuration();
+        if (composition->getTimeSignatureCount() > 0) {
+            endTime = composition->getTimeSignatureChange(0).first;
+        }
+
+        CompositionTimeSliceAdapter adapter
+        (composition, insertionTime, endTime);
+        AnalysisHelper helper;
+        TimeSignature timeSig = helper.guessTimeSignature(adapter);
+
+        dialog = new TimeSignatureDialog
+                 (this, composition, insertionTime, timeSig, false,
+                  i18n("Estimated time signature shown"));
+    }
+
+    if (dialog->exec() == QDialog::Accepted) {
+
+        insertionTime = dialog->getTime();
+
+        if (dialog->shouldNormalizeRests()) {
+
+            addCommandToHistory(new AddTimeSignatureAndNormalizeCommand
+                                (composition, insertionTime,
+                                 dialog->getTimeSignature()));
+
+        } else {
+
+            addCommandToHistory(new AddTimeSignatureCommand
+                                (composition, insertionTime,
+                                 dialog->getTimeSignature()));
+        }
+    }
+
+    delete dialog;
+}
+
+void EditView::showPropertyControlRuler(PropertyName propertyName)
+{
+    int index = 0;
+
+    ControlRuler* existingRuler = findRuler(propertyName, index);
+
+    if (existingRuler) {
+
+        m_controlRulers->setCurrentPage(index);
+
+    } else {
+
+        PropertyControlRuler* controlRuler = makePropertyControlRuler(propertyName);
+        addControlRuler(controlRuler);
+    }
+
+    if (!m_controlRulers->isVisible()) {
+        m_controlRulers->show();
+    }
+
+    updateBottomWidgetGeometry();
+}
+
+void EditView::slotShowVelocityControlRuler()
+{
+    showPropertyControlRuler(BaseProperties::VELOCITY);
+    Segment &seg = getCurrentStaff()->getSegment();
+    seg.setViewFeatures(seg.getViewFeatures() | FeatureShowVelocity);
+    getDocument()->slotDocumentModified();
+}
+
+void EditView::slotShowControllerEventsRuler()
+{
+
+    //     int index = 0;
+
+    //     ControlRuler* existingRuler = findRuler(propertyName, index);
+
+    //     if (existingRuler) {
+
+    //         m_controlRulers->setCurrentPage(index);
+
+    //     } else {
+
+    //         ControllerEventsRuler* controlRuler = makeControllerEventRuler();
+    //         addControlRuler(controlRuler);
+    //     }
+
+    //     if (!m_controlRulers->isVisible()) {
+    //         m_controlRulers->show();
+    //     }
+
+    //     updateBottomWidgetGeometry();
+}
+
+void EditView::slotShowPropertyControlRuler()
+{
+    /*
+        KDialogBase propChooserDialog(this, "propertychooserdialog", true, i18n("Select event property"),
+                                      KDialogBase::Ok | KDialogBase::Cancel, KDialogBase::Ok);
+        
+        KListBox* propList = new KListBox(propChooserDialog.makeVBoxMainWidget());
+        new QListBoxRGProperty(propList, BaseProperties::VELOCITY.c_str());
+     
+        int rc = propChooserDialog.exec();
+        if (rc == QDialog::Accepted) {
+            // fix for KDE 3.0
+            //QListBoxRGProperty* item = dynamic_cast<QListBoxRGProperty*>(propList->selectedItem());
+            QListBoxRGProperty* item = dynamic_cast<QListBoxRGProperty*>
+                (propList->item(propList->currentItem()));
+     
+            if (item) {
+                PropertyName property = item->getPropertyName();
+                showPropertyControlRuler(property);
+            }
+        }
+    */
+}
+
+void
+EditView::slotInsertControlRulerItem()
+{
+    ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(getCurrentControlRuler());
+    if (ruler)
+        ruler->insertControllerEvent();
+}
+
+void
+EditView::slotEraseControlRulerItem()
+{
+    ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(getCurrentControlRuler());
+    if (ruler)
+        ruler->eraseControllerEvent();
+}
+
+void
+EditView::slotStartControlLineItem()
+{
+    ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(getCurrentControlRuler());
+    if (ruler)
+        ruler->startControlLine();
+}
+
+void
+EditView::slotDrawPropertyLine()
+{
+    int index = 0;
+    PropertyControlRuler* ruler = dynamic_cast<PropertyControlRuler*>
+                                  (findRuler(BaseProperties::VELOCITY, index));
+
+    if (ruler)
+        ruler->startPropertyLine();
+}
+
+void
+EditView::slotSelectAllProperties()
+{
+    int index = 0;
+    PropertyControlRuler* ruler = dynamic_cast<PropertyControlRuler*>
+                                  (findRuler(BaseProperties::VELOCITY, index));
+
+    if (ruler)
+        ruler->selectAllProperties();
+}
+
+void
+EditView::slotClearControlRulerItem()
+{
+    ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(getCurrentControlRuler());
+    if (ruler)
+        ruler->clearControllerEvents();
+}
+
+void
+EditView::slotHalveDurations()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    KTmpStatusMsg msg(i18n("Halving durations..."), this);
+
+    addCommandToHistory(
+        new RescaleCommand(*m_currentEventSelection,
+                           m_currentEventSelection->getTotalDuration() / 2,
+                           false));
+}
+
+void
+EditView::slotDoubleDurations()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    KTmpStatusMsg msg(i18n("Doubling durations..."), this);
+
+    addCommandToHistory(
+        new RescaleCommand(*m_currentEventSelection,
+                           m_currentEventSelection->getTotalDuration() * 2,
+                           false));
+}
+
+void
+EditView::slotRescale()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    RescaleDialog dialog
+    (this,
+     &getDocument()->getComposition(),
+     m_currentEventSelection->getStartTime(),
+     m_currentEventSelection->getEndTime() -
+     m_currentEventSelection->getStartTime(),
+     true,
+     true);
+
+    if (dialog.exec() == QDialog::Accepted) {
+        KTmpStatusMsg msg(i18n("Rescaling..."), this);
+        addCommandToHistory(new RescaleCommand
+                            (*m_currentEventSelection,
+                             dialog.getNewDuration(),
+                             dialog.shouldCloseGap()));
+    }
+}
+
+void EditView::slotTranspose()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    m_config->setGroup(EditViewConfigGroup);
+
+    int dialogDefault = m_config->readNumEntry("lasttransposition", 0);
+
+    bool ok = false;
+    int semitones = QInputDialog::getInteger
+                    (i18n("Transpose"),
+                     i18n("By number of semitones: "),
+                     dialogDefault, -127, 127, 1, &ok, this);
+    if (!ok || semitones == 0) return;
+
+    m_config->setGroup(EditViewConfigGroup);
+    m_config->writeEntry("lasttransposition", semitones);
+
+    KTmpStatusMsg msg(i18n("Transposing..."), this);
+    addCommandToHistory(new TransposeCommand
+                        (semitones, *m_currentEventSelection));
+}
+
+void EditView::slotDiatonicTranspose()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    m_config->setGroup(EditViewConfigGroup);
+
+    IntervalDialog intervalDialog(this);
+    int ok = intervalDialog.exec();
+	//int dialogDefault = m_config->readNumEntry("lasttransposition", 0);
+    int semitones = intervalDialog.getChromaticDistance();
+    int steps = intervalDialog.getDiatonicDistance();
+
+    if (!ok || (semitones == 0 && steps == 0)) return;
+
+    m_config->setGroup(EditViewConfigGroup);
+
+    KTmpStatusMsg msg(i18n("Transposing..."), this);
+    if (intervalDialog.getChangeKey())
+    {
+		std::cout << "Transposing changing keys is not currently supported on selections" << std::endl;
+    }
+    else
+    {
+	// Transpose within key
+		//std::cout << "Transposing semitones, steps: " << semitones << ", " << steps << std::endl;
+		addCommandToHistory(new TransposeCommand
+                        (semitones, steps, *m_currentEventSelection));
+    }
+}
+
+void EditView::slotTransposeUp()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Transposing up one semitone..."), this);
+
+    addCommandToHistory(new TransposeCommand(1, *m_currentEventSelection));
+}
+
+void EditView::slotTransposeUpOctave()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Transposing up one octave..."), this);
+
+    addCommandToHistory(new TransposeCommand(12, *m_currentEventSelection));
+}
+
+void EditView::slotTransposeDown()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Transposing down one semitone..."), this);
+
+    addCommandToHistory(new TransposeCommand( -1, *m_currentEventSelection));
+}
+
+void EditView::slotTransposeDownOctave()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Transposing down one octave..."), this);
+
+    addCommandToHistory(new TransposeCommand( -12, *m_currentEventSelection));
+}
+
+void EditView::slotInvert()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    int semitones = 0;
+
+    KTmpStatusMsg msg(i18n("Inverting..."), this);
+    addCommandToHistory(new InvertCommand
+                        (semitones, *m_currentEventSelection));
+}
+
+void EditView::slotRetrograde()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    int semitones = 0;
+
+    KTmpStatusMsg msg(i18n("Retrograding..."), this);
+    addCommandToHistory(new RetrogradeCommand
+                        (semitones, *m_currentEventSelection));
+}
+
+void EditView::slotRetrogradeInvert()
+{
+    if (!m_currentEventSelection)
+        return ;
+
+    int semitones = 0;
+
+    KTmpStatusMsg msg(i18n("Retrograde inverting..."), this);
+    addCommandToHistory(new RetrogradeInvertCommand
+                        (semitones, *m_currentEventSelection));
+}
+
+void EditView::slotJogLeft()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Jogging left..."), this);
+
+    RG_DEBUG << "EditView::slotJogLeft" << endl;
+
+    addCommandToHistory(
+        new MoveCommand(*getCurrentSegment(),
+                        -Note(Note::Demisemiquaver).getDuration(),
+                        false,  // don't use notation timings
+                        *m_currentEventSelection));
+}
+
+void EditView::slotJogRight()
+{
+    if (!m_currentEventSelection)
+        return ;
+    KTmpStatusMsg msg(i18n("Jogging right..."), this);
+
+    RG_DEBUG << "EditView::slotJogRight" << endl;
+
+    addCommandToHistory(
+        new MoveCommand(*getCurrentSegment(),
+                        Note(Note::Demisemiquaver).getDuration(),
+                        false,  // don't use notation timings
+                        *m_currentEventSelection));
+}
+
+void
+EditView::slotFlipForwards()
+{
+    RG_DEBUG << "EditView::slotFlipForwards" << endl;
+    ControlRuler* ruler = getCurrentControlRuler();
+    if (ruler) ruler->flipForwards();
+}
+
+void
+EditView::slotFlipBackwards()
+{
+    RG_DEBUG << "EditView::slotFlipBackwards" << endl;
+    ControlRuler* ruler = getCurrentControlRuler();
+    if (ruler) ruler->flipBackwards();
+}
+
+ControlRuler* EditView::getCurrentControlRuler()
+{
+    return dynamic_cast<ControlRuler*>(m_controlRulers->currentPage());
+}
+
+ControlRuler* EditView::findRuler(PropertyName propertyName, int &index)
+{
+    for(index = 0; index < m_controlRulers->count(); ++index) {
+        PropertyControlRuler* ruler = dynamic_cast<PropertyControlRuler*>(m_controlRulers->page(index));
+        if (ruler && ruler->getPropertyName() == propertyName) return ruler;
+    }
+
+    return 0;
+}
+
+ControlRuler* EditView::findRuler(const ControlParameter& controller, int &index)
+{
+    for(index = 0; index < m_controlRulers->count(); ++index) {
+        ControllerEventsRuler* ruler = dynamic_cast<ControllerEventsRuler*>(m_controlRulers->page(index));
+        if (ruler && *(ruler->getControlParameter()) == controller) return ruler;
+    }
+
+    return 0;
+}
+
+PropertyControlRuler* EditView::makePropertyControlRuler(PropertyName propertyName)
+{
+    QCanvas* controlRulerCanvas = new QCanvas(this);
+    QSize viewSize = getViewSize();
+    controlRulerCanvas->resize(viewSize.width(), ControlRuler::DefaultRulerHeight); // TODO - keep it in sync with main canvas size
+
+//     QCanvas* controlRulerCanvas = ControlRulerCanvasRepository::getCanvas(getCurrentSegment(), propertyName,
+//                                                                           getViewSize());
+
+    PropertyControlRuler* controlRuler = new PropertyControlRuler
+    (propertyName, getCurrentStaff(), getHLayout(), this,
+     controlRulerCanvas, m_controlRulers);
+
+    controlRuler->setMainHorizontalScrollBar(m_canvasView->horizontalScrollBar());
+
+    return controlRuler;
+}
+
+ControllerEventsRuler* EditView::makeControllerEventRuler(const ControlParameter *controller)
+{
+    QCanvas* controlRulerCanvas = new QCanvas(this);
+    QSize viewSize = getViewSize();
+    controlRulerCanvas->resize(viewSize.width(), ControlRuler::DefaultRulerHeight); // TODO - keep it in sync with main canvas size
+//     QCanvas* controlRulerCanvas = ControlRulerCanvasRepository::getCanvas(getCurrentSegment(), controller,
+//                                                                           getViewSize());
+    
+
+    ControllerEventsRuler* controlRuler = new ControllerEventsRuler
+    (getCurrentSegment(), getHLayout(), this,
+     controlRulerCanvas, m_controlRulers, controller);
+
+    controlRuler->setMainHorizontalScrollBar(m_canvasView->horizontalScrollBar());
+
+    return controlRuler;
+}
+
+RosegardenCanvasView* EditView::getCanvasView()
+{
+    return m_canvasView;
+}
+
+}
+#include "EditView.moc"