comparison view/Pane.cpp @ 374:64e84e5efb76 spectrogram-cache-rejig

* Merge from trunk

 #include "base/RealTime.h"
 #include "base/Profiler.h"
 #include "ViewManager.h"
 #include "base/CommandHistory.h"
 #include "base/TextAbbrev.h"
+#include "base/Preferences.h"
 #include "layer/WaveformLayer.h"
 
 //!!! ugh
 #include "data/model/WaveFileModel.h"
 

 #include "widgets/RangeInputDialog.h"
 #include "widgets/NotifyingPushButton.h"
 
 #include "widgets/KeyReference.h" //!!! should probably split KeyReference into a data class in base and another that shows the widget
 
+//#define DEBUG_PANE
+
 using std::cerr;
 using std::endl;
 
 QCursor *Pane::m_measureCursor1 = 0;
 QCursor *Pane::m_measureCursor2 = 0;

     m_clickedInRange(false),
     m_shiftPressed(false),
     m_ctrlPressed(false),
     m_navigating(false),
     m_resizing(false),
+    m_editing(false),
+    m_releasing(false),
     m_centreLineVisible(true),
     m_scaleWidth(0),
     m_headsUpDisplay(0),
     m_vpan(0),
     m_hthumb(0),

     if (e) r = e->rect();
 
     View::paintEvent(e);
 
     paint.begin(this);
+    setPaintFont(paint);
 
     if (e) paint.setClipRect(r);
 
     ViewManager::ToolMode toolMode = m_manager->getToolMode();
 

         emit contextHelpChanged("");
         emit rightButtonMenuRequested(mapToGlobal(e->pos()));
         return;
     }
 
+//    std::cerr << "mousePressEvent" << std::endl;
+
     m_clickPos = e->pos();
     m_mousePos = m_clickPos;
     m_clickedInRange = true;
     m_editingSelection = Selection();
     m_editingSelectionEdge = 0;

 
     ViewManager::ToolMode mode = ViewManager::NavigateMode;
     if (m_manager) mode = m_manager->getToolMode();
 
     m_navigating = false;
+    m_resizing = false;
+    m_editing = false;
+    m_releasing = false;
 
     if (mode == ViewManager::NavigateMode ||
         (e->buttons() & Qt::MidButton) ||
         (mode == ViewManager::MeasureMode &&
          (e->buttons() & Qt::LeftButton) && m_shiftPressed)) {

 	    }
 	    
 	    if (snapFrame < 0) snapFrame = 0;
 	    m_selectionStartFrame = snapFrame;
 	    if (m_manager) {
-		m_manager->setInProgressSelection(Selection(snapFrame,
-							    snapFrame + resolution),
-						  !m_ctrlPressed);
+		m_manager->setInProgressSelection
+                    (Selection(alignToReference(snapFrame),
+                               alignToReference(snapFrame + resolution)),
+                     !m_ctrlPressed);
 	    }
 
 	    m_resizing = false;
 	}
 

 	Layer *layer = getSelectedLayer();
 	if (layer && layer->isLayerEditable()) {
 	    layer->drawStart(this, e);
 	}
 
+    } else if (mode == ViewManager::EraseMode) {
+
+	Layer *layer = getSelectedLayer();
+	if (layer && layer->isLayerEditable()) {
+	    layer->eraseStart(this, e);
+	}
+
     } else if (mode == ViewManager::EditMode) {
 
-	if (!editSelectionStart(e)) {
-	    Layer *layer = getSelectedLayer();
-	    if (layer && layer->isLayerEditable()) {
-		layer->editStart(this, e);
-	    }
-	}
+        // Do nothing here -- we'll do it in mouseMoveEvent when the
+        // drag threshold has been passed
 
     } else if (mode == ViewManager::MeasureMode) {
 
         Layer *layer = getTopLayer();
         if (layer) layer->measureStart(this, e);

 {
     if (e->buttons() & Qt::RightButton) {
         return;
     }
 
+//    std::cerr << "mouseReleaseEvent" << std::endl;
+
     ViewManager::ToolMode mode = ViewManager::NavigateMode;
     if (m_manager) mode = m_manager->getToolMode();
+
+    m_releasing = true;
 
     if (m_clickedInRange) {
 	mouseMoveEvent(e);
     }
 

             zoomToRegion(x0, y0, x1, y1);
 	}
 
     } else if (mode == ViewManager::SelectMode) {
 
-        if (!hasTopLayerTimeXAxis()) return;
+        if (!hasTopLayerTimeXAxis()) {
+            m_releasing = false;
+            return;
+        }
 
 	if (m_manager && m_manager->haveInProgressSelection()) {
 
 	    bool exclusive;
 	    Selection selection = m_manager->getInProgressSelection(exclusive);

 	if (layer && layer->isLayerEditable()) {
 	    layer->drawEnd(this, e);
 	    update();
 	}
 
+    } else if (mode == ViewManager::EraseMode) {
+
+	Layer *layer = getSelectedLayer();
+	if (layer && layer->isLayerEditable()) {
+	    layer->eraseEnd(this, e);
+	    update();
+	}
+
     } else if (mode == ViewManager::EditMode) {
 
-	if (!editSelectionEnd(e)) {
-	    Layer *layer = getSelectedLayer();
-	    if (layer && layer->isLayerEditable()) {
-		layer->editEnd(this, e);
-		update();
-	    }
-	}
+        if (m_editing) {
+            if (!editSelectionEnd(e)) {
+                Layer *layer = getSelectedLayer();
+                if (layer && layer->isLayerEditable()) {
+                    layer->editEnd(this, e);
+                    update();
+                }
+            }
+        }
 
     } else if (mode == ViewManager::MeasureMode) {
 
         Layer *layer = getTopLayer();
         if (layer) layer->measureEnd(this, e);
         if (m_measureCursor1) setCursor(*m_measureCursor1);
         update();
     }
 
     m_clickedInRange = false;
+    m_releasing = false;
 
     emit paneInteractedWith();
 }
 
 void

 {
     if (e->buttons() & Qt::RightButton) {
         return;
     }
 
+//    std::cerr << "mouseMoveEvent" << std::endl;
+
     updateContextHelp(&e->pos());
+
+    if (m_navigating && m_clickedInRange && !m_releasing) {
+
+        // if no buttons pressed, and not called from
+        // mouseReleaseEvent, we want to reset clicked-ness (to avoid
+        // annoying continual drags when we moved the mouse outside
+        // the window after pressing button first time).
+
+        if (!(e->buttons() & Qt::LeftButton) &&
+            !(e->buttons() & Qt::MidButton)) {
+            m_clickedInRange = false;
+            return;
+        }
+    }
 
     ViewManager::ToolMode mode = ViewManager::NavigateMode;
     if (m_manager) mode = m_manager->getToolMode();
 
     QPoint prevPoint = m_identifyPoint;

 	Layer *layer = getSelectedLayer();
 	if (layer && layer->isLayerEditable()) {
 	    layer->drawDrag(this, e);
 	}
 
+    } else if (mode == ViewManager::EraseMode) {
+
+	Layer *layer = getSelectedLayer();
+	if (layer && layer->isLayerEditable()) {
+	    layer->eraseDrag(this, e);
+	}
+
     } else if (mode == ViewManager::EditMode) {
 
-	if (!editSelectionDrag(e)) {
-	    Layer *layer = getSelectedLayer();
-	    if (layer && layer->isLayerEditable()) {
-		layer->editDrag(this, e);
-	    }
-	}
+        if (m_editing) {
+            if (!editSelectionDrag(e)) {
+                Layer *layer = getSelectedLayer();
+                if (layer && layer->isLayerEditable()) {
+                    layer->editDrag(this, e);
+                }
+            }
+        }
+
+        if (!m_editing) {
+
+            DragMode newDragMode = updateDragMode
+                (m_dragMode,
+                 m_clickPos,
+                 e->pos(),
+                 true,  // can move horiz
+                 true,  // can move vert
+                 true,  // resist horiz
+                 true); // resist vert
+
+            if (newDragMode != UnresolvedDrag) {
+
+                m_editing = true;
+
+                QMouseEvent clickEvent(QEvent::MouseButtonPress,
+                                       m_clickPos,
+                                       Qt::NoButton,
+                                       e->buttons(),
+                                       e->modifiers());
+
+                if (!editSelectionStart(&clickEvent)) {
+                    Layer *layer = getSelectedLayer();
+                    if (layer && layer->isLayerEditable()) {
+                        layer->editStart(this, &clickEvent);
+                    }
+                }
+            }
+        }
 
     } else if (mode == ViewManager::MeasureMode) {
 
         if (m_measureCursor2) setCursor(*m_measureCursor2);
 

     // other direction as well, we may switch into free mode.
     // 
     // If the top layer is incapable of being dragged
     // vertically, the logic is short circuited.
 
-    int xdiff = e->x() - m_clickPos.x();
-    int ydiff = e->y() - m_clickPos.y();
-    int smallThreshold = 10, bigThreshold = 50;
-
-    bool canMoveVertical = canTopLayerMoveVertical();
-    bool canMoveHorizontal = true;
-
-    if (!canMoveHorizontal) {
-        m_dragMode = HorizontalDrag;
-    }
-
-    if (m_dragMode == UnresolvedDrag) {
-
-        if (abs(ydiff) > smallThreshold &&
-            abs(ydiff) > abs(xdiff) * 2) {
-            m_dragMode = VerticalDrag;
-        } else if (abs(xdiff) > smallThreshold &&
-                   abs(xdiff) > abs(ydiff) * 2) {
-            m_dragMode = HorizontalDrag;
-        } else if (abs(xdiff) > smallThreshold &&
-                   abs(ydiff) > smallThreshold) {
-            m_dragMode = FreeDrag;
-        } else {
-            // When playing, we don't want to disturb the play
-            // position too easily; when not playing, we don't
-            // want to move up/down too easily
-            if (m_manager && m_manager->isPlaying()) {
-                canMoveHorizontal = false;
-            } else {
-                canMoveVertical = false;
-            }
-        }
-    }
-
-    if (m_dragMode == VerticalDrag) {
-        if (abs(xdiff) > bigThreshold) m_dragMode = FreeDrag;
-        else canMoveHorizontal = false;
-    }
-
-    if (m_dragMode == HorizontalDrag && canMoveVertical) {
-        if (abs(ydiff) > bigThreshold) m_dragMode = FreeDrag;
-        else canMoveVertical = false;
-    }
-
-    if (canMoveHorizontal) {
+    m_dragMode = updateDragMode
+        (m_dragMode,
+         m_clickPos,
+         e->pos(),
+         true, // can move horiz
+         canTopLayerMoveVertical(), // can move vert
+         canTopLayerMoveVertical() || (m_manager && m_manager->isPlaying()), // resist horiz
+         !(m_manager && m_manager->isPlaying())); // resist vert
+
+    if (m_dragMode == HorizontalDrag ||
+        m_dragMode == FreeDrag) {
 
         long frameOff = getFrameForX(e->x()) - getFrameForX(m_clickPos.x());
 
         size_t newCentreFrame = m_dragCentreFrame;
 	    

         } else if (newCentreFrame >= size_t(frameOff)) {
             newCentreFrame -= frameOff;
         } else {
             newCentreFrame = 0;
         }
-	    
+
+#ifdef DEBUG_PANE	    
+        std::cerr << "Pane::dragTopLayer: newCentreFrame = " << newCentreFrame <<
+            ", models end frame = " << getModelsEndFrame() << std::endl;
+#endif
+
         if (newCentreFrame >= getModelsEndFrame()) {
             newCentreFrame = getModelsEndFrame();
             if (newCentreFrame > 0) --newCentreFrame;
         }
                 
         if (getXForFrame(m_centreFrame) != getXForFrame(newCentreFrame)) {
             setCentreFrame(newCentreFrame);
         }
     }
 
-    if (canMoveVertical) {
+    if (m_dragMode == VerticalDrag ||
+        m_dragMode == FreeDrag) {
 
         float vmin = 0.f, vmax = 0.f;
         float dmin = 0.f, dmax = 0.f;
 
         if (getTopLayerDisplayExtents(vmin, vmax, dmin, dmax)) {
 
 //            std::cerr << "ydiff = " << ydiff << std::endl;
 
+            int ydiff = e->y() - m_clickPos.y();
             float perpix = (dmax - dmin) / height();
             float valdiff = ydiff * perpix;
 //            std::cerr << "valdiff = " << valdiff << std::endl;
+
+            if (m_dragMode == UnresolvedDrag && ydiff != 0) {
+                m_dragMode = VerticalDrag;
+            }
 
             float newmin = m_dragStartMinValue + valdiff;
             float newmax = m_dragStartMinValue + (dmax - dmin) + valdiff;
             if (newmin < vmin) {
                 newmax += vmin - newmin;

 
             setTopLayerDisplayExtents(newmin, newmax);
             updateVerticalPanner();
         }
     }
+}
+
+Pane::DragMode
+Pane::updateDragMode(DragMode dragMode,
+                     QPoint origin,
+                     QPoint point,
+                     bool canMoveHorizontal,
+                     bool canMoveVertical,
+                     bool resistHorizontal,
+                     bool resistVertical)
+{
+    int xdiff = point.x() - origin.x();
+    int ydiff = point.y() - origin.y();
+
+    int smallThreshold = 10, bigThreshold = 80;
+
+//    std::cerr << "Pane::updateDragMode: xdiff = " << xdiff << ", ydiff = "
+//              << ydiff << ", canMoveVertical = " << canMoveVertical << ", drag mode = " << m_dragMode << std::endl;
+
+    if (dragMode == UnresolvedDrag) {
+
+        if (abs(ydiff) > smallThreshold &&
+            abs(ydiff) > abs(xdiff) * 2 &&
+            canMoveVertical) {
+//            std::cerr << "Pane::updateDragMode: passed vertical threshold" << std::endl;
+            dragMode = VerticalDrag;
+        } else if (abs(xdiff) > smallThreshold &&
+                   abs(xdiff) > abs(ydiff) * 2 &&
+                   canMoveHorizontal) {
+//            std::cerr << "Pane::updateDragMode: passed horizontal threshold" << std::endl;
+            dragMode = HorizontalDrag;
+        } else if (abs(xdiff) > smallThreshold &&
+                   abs(ydiff) > smallThreshold &&
+                   canMoveVertical &&
+                   canMoveHorizontal) {
+//            std::cerr << "Pane::updateDragMode: passed both thresholds" << std::endl;
+            dragMode = FreeDrag;
+        }
+    }
+
+    if (dragMode == VerticalDrag && canMoveHorizontal) {
+        if (abs(xdiff) > bigThreshold) dragMode = FreeDrag;
+    }
+
+    if (dragMode == HorizontalDrag && canMoveVertical) {
+        if (abs(ydiff) > bigThreshold) dragMode = FreeDrag;
+    }
+
+    if (dragMode == UnresolvedDrag) {
+        if (!resistHorizontal && xdiff != 0) {
+            dragMode = HorizontalDrag;
+        }
+        if (!resistVertical && ydiff != 0) {
+            if (dragMode == HorizontalDrag) dragMode = FreeDrag;
+            else dragMode = VerticalDrag;
+        }
+    }
+    
+    return dragMode;
 }
 
 void
 Pane::dragExtendSelection(QMouseEvent *e)
 {

         min = snapFrameLeft;
         max = snapFrameRight;
     }
 
     if (m_manager) {
-        m_manager->setInProgressSelection(Selection(min, max),
+        m_manager->setInProgressSelection(Selection(alignToReference(min),
+                                                    alignToReference(max)),
                                           !m_resizing && !m_ctrlPressed);
     }
 
     edgeScrollMaybe(e->x());
 

 	break;
 	
     case ViewManager::DrawMode:
 	setCursor(Qt::CrossCursor);
 	break;
+	
+    case ViewManager::EraseMode:
+	setCursor(Qt::CrossCursor);
+	break;
 
     case ViewManager::MeasureMode:
         if (m_measureCursor1) setCursor(*m_measureCursor1);
 	break;
 

         
         //!!! could call through to a layer function to find out exact meaning
 	if (editable) {
             help = tr("Click to add a new item in the active layer");
         }
+
+    } else if (mode == ViewManager::EraseMode) {
+        
+        //!!! could call through to a layer function to find out exact meaning
+	if (editable) {
+            help = tr("Click to erase an item from the active layer");
+        }
         
     } else if (mode == ViewManager::EditMode) {
         
         //!!! could call through to layer
 	if (editable) {