2021-03-20 Fred Gleason <fredg@paravelsystems.com>

* Fixed a bug in 'RDMarkerView' that transposed the handle direction
	for the 'Fade Up' and 'Fade Down' markers.

Signed-off-by: Fred Gleason <fredg@paravelsystems.com>

ChangeLog

@@ -21288,3 +21288,6 @@
 	* Fixed bugs with detecting unsaved changes in 'RDMarkerView'.
 2021-03-19 Fred Gleason <fredg@paravelsystems.com>
 	* Added 'RDMarkerPlayer'.
+2021-03-20 Fred Gleason <fredg@paravelsystems.com>
+	* Fixed a bug in 'RDMarkerView' that transposed the handle direction
+	for the 'Fade Up' and 'Fade Down' markers.

lib/rdmarkerdialog.cpp

@@ -81,6 +81,9 @@ RDMarkerDialog::RDMarkerDialog(const QString &caption,int card,int port,
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_player,SLOT(setPointerValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_player,SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   //
   // Marker Readouts
@@ -89,32 +92,52 @@ RDMarkerDialog::RDMarkerDialog(const QString &caption,int card,int port,
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_cut_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_cut_readout,SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
   d_cut_readout->setEnabled(true);
 
   d_talk_readout=new RDMarkerReadout(RDMarkerHandle::TalkStart,this);
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_talk_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_talk_readout,SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   d_segue_readout=new RDMarkerReadout(RDMarkerHandle::SegueStart,this);
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_segue_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_segue_readout,SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   d_hook_readout=new RDMarkerReadout(RDMarkerHandle::HookStart,this);
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_hook_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_hook_readout,SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   d_fadeup_readout=new RDMarkerReadout(RDMarkerHandle::FadeUp,this);
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_fadeup_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_fadeup_readout,
+	  SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   d_fadedown_readout=new RDMarkerReadout(RDMarkerHandle::FadeDown,this);
   connect(d_marker_view,
 	  SIGNAL(pointerValueChanged(RDMarkerHandle::PointerRole,int)),
 	  d_fadedown_readout,SLOT(setValue(RDMarkerHandle::PointerRole,int)));
+  connect(d_marker_view,
+	  SIGNAL(selectedMarkerChanged(RDMarkerHandle::PointerRole)),
+	  d_fadedown_readout,
+	  SLOT(setSelectedMarker(RDMarkerHandle::PointerRole)));
 
   /**************************************************************************
    * Navigation Section
@@ -169,12 +192,19 @@ int RDMarkerDialog::exec(unsigned cartnum,int cutnum)
   for(int i=0;i<RDMarkerHandle::LastRole;i++) {
     RDMarkerHandle::PointerRole role=(RDMarkerHandle::PointerRole)i;
     d_cut_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_cut_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_talk_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_talk_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_segue_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_segue_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_hook_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_hook_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_fadeup_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_fadeup_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_fadedown_readout->setValue(role,d_marker_view->pointerValue(role));
+    d_fadedown_readout->setSelectedMarker(RDMarkerHandle::LastRole);
     d_player->setPointerValue(role,d_marker_view->pointerValue(role));
+    d_player->setSelectedMarker(RDMarkerHandle::LastRole);
   }
   return QDialog::exec();
 }

lib/rdmarkerplayer.cpp

@@ -173,17 +173,65 @@ void RDMarkerPlayer::setPointerValue(RDMarkerHandle::PointerRole role,int ptr)
 }
 
 
+void RDMarkerPlayer::setSelectedMarker(RDMarkerHandle::PointerRole role)
+{
+  if(d_selected_marker!=role) {
+    d_region_edit_label->
+      setStyleSheet("background-color: "+
+		    RDMarkerHandle::pointerRoleColor(role).name());
+    d_play_cursor_button->
+      setAccentColor(RDMarkerHandle::pointerRoleColor(role));
+    d_selected_marker=role;
+  }
+}
+
+
 void RDMarkerPlayer::playCursorData()
 {
+  d_active_play_button=d_play_cursor_button;
+
+  int start=0;
+  int len=0;
+  if(d_cae_handle>=0) {
+    if(d_is_playing) {
+      rda->cae()->stopPlay(d_cae_handle);
+    }
+  }
+  switch(RDMarkerHandle::pointerType(d_selected_marker)) {
+  case RDMarkerHandle::Start:
+    start=d_pointers[d_selected_marker];
+    len=d_pointers[d_selected_marker+1]-d_pointers[d_selected_marker];
+    break;
+
+  case RDMarkerHandle::End:
+    start=d_pointers[d_selected_marker]-2000;
+    len=2000;
+    if(start<0) {
+      start=0;
+      len=d_pointers[d_selected_marker];
+    }
+    break;
+  }
+  rda->cae()->positionPlay(d_cae_handle,start);
+  rda->cae()->play(d_cae_handle,len,100000,false);
+  rda->cae()->setPlayPortActive(d_cards.first(),d_port,d_cae_stream);
+  // FIXME: Implement variable gain here!
+  rda->cae()->setOutputVolume(d_cards.first(),d_cae_stream,d_port,0);
+  //    rda->cae()->
+  //      setOutputVolume(d_cards.first(),d_cae_stream,d_port,0+edit_gain_control->value());
+  d_meter_timer->start(RD_METER_UPDATE_INTERVAL);
 }
 
 
 void RDMarkerPlayer::playStartData()
 {
+  d_active_play_button=d_play_start_button;
+
   if(d_cae_handle>=0) {
     if(d_is_playing) {
       rda->cae()->stopPlay(d_cae_handle);
     }
+  }
   rda->cae()->positionPlay(d_cae_handle,d_pointers[RDMarkerHandle::CutStart]);
   rda->cae()->play(d_cae_handle,
 		   d_pointers[RDMarkerHandle::CutEnd]-
@@ -195,7 +243,6 @@ void RDMarkerPlayer::playStartData()
   //      setOutputVolume(d_cards.first(),d_cae_stream,d_port,0+edit_gain_control->value());
   d_meter_timer->start(RD_METER_UPDATE_INTERVAL);
 }
-}
 
 
 void RDMarkerPlayer::pauseData()
@@ -232,7 +279,7 @@ void RDMarkerPlayer::caePlayedData(int handle)
 {
   if(handle==d_cae_handle) {
     if(!d_is_playing) {
-      d_play_start_button->setState(RDTransportButton::On);
+      d_active_play_button->setState(RDTransportButton::On);
       d_pause_button->setState(RDTransportButton::Off);
       d_stop_button->setState(RDTransportButton::Off);
       d_is_playing=true;
@@ -250,6 +297,7 @@ void RDMarkerPlayer::caePausedData(int handle)
 	d_meter->setLeftPeakBar(-10000);
 	d_meter->setRightPeakBar(-10000);
       }
+      d_play_cursor_button->setState(RDTransportButton::Off);
       d_play_start_button->setState(RDTransportButton::Off);
       d_pause_button->setState(RDTransportButton::Off);
       d_stop_button->setState(RDTransportButton::On);

lib/rdmarkerplayer.h

@@ -46,6 +46,7 @@ class RDMarkerPlayer : public RDWidget
  public slots:
   void setPlayPosition(int msec);
   void setPointerValue(RDMarkerHandle::PointerRole role,int ptr);
+  void setSelectedMarker(RDMarkerHandle::PointerRole role);
 
  signals:
   void cursorPositionChanged(unsigned msec);
@@ -74,6 +75,7 @@ class RDMarkerPlayer : public RDWidget
   QLineEdit *d_size_edit;
   RDTransportButton *d_play_cursor_button;
   RDTransportButton *d_play_start_button;
+  RDTransportButton *d_active_play_button;
   RDTransportButton *d_pause_button;
   RDTransportButton *d_stop_button;
   RDTransportButton *d_loop_button;
@@ -84,6 +86,7 @@ class RDMarkerPlayer : public RDWidget
   int d_cae_stream;
   int d_cae_handle;
   bool d_is_playing;
+  RDMarkerHandle::PointerRole d_selected_marker;
 
   int d_pointers[RDMarkerHandle::LastRole];
 };

lib/rdmarkerreadout.cpp

@@ -28,6 +28,7 @@ RDMarkerReadout::RDMarkerReadout(RDMarkerHandle::PointerRole role,
   : RDWidget(parent)
 {
   d_roles.push_back(role);
+  d_selected_marker=RDMarkerHandle::LastRole;
 
   d_label=new QLabel(RDMarkerHandle::pointerRoleText(role),this);
   d_label->setAlignment(Qt::AlignCenter);
@@ -83,7 +84,8 @@ RDMarkerReadout::~RDMarkerReadout()
 
 QSize RDMarkerReadout::sizeHint() const
 {
-  return QSize(60,20+20*d_edits.size());
+  return QSize(labelFontMetrics()->width("00:00:00")+10,20+20*d_edits.size());
+  //  return QSize(60,20+20*d_edits.size());
 }
 
 
@@ -109,6 +111,42 @@ void RDMarkerReadout::setValue(RDMarkerHandle::PointerRole role,int value)
 }
 
 
+void RDMarkerReadout::setSelectedMarker(RDMarkerHandle::PointerRole role)
+{
+  if(d_selected_marker!=role) {
+    for(int i=0;i<d_edits.size();i++) {
+      d_edits.at(i)->setFont(defaultFont());
+    }
+    if(d_roles.contains(role)) {
+      switch(role) {
+      case RDMarkerHandle::CutStart:
+      case RDMarkerHandle::TalkStart:
+      case RDMarkerHandle::SegueStart:
+      case RDMarkerHandle::HookStart:
+	d_edits.at(0)->setFont(labelFont());
+	break;
+
+      case RDMarkerHandle::CutEnd:
+      case RDMarkerHandle::TalkEnd:
+      case RDMarkerHandle::SegueEnd:
+      case RDMarkerHandle::HookEnd:
+	d_edits.at(1)->setFont(labelFont());
+	break;
+
+      case RDMarkerHandle::FadeUp:
+      case RDMarkerHandle::FadeDown:
+	d_edits.at(0)->setFont(labelFont());
+	break;
+
+      case RDMarkerHandle::LastRole:
+	break;
+      }
+    }
+    d_selected_marker=role;
+  }
+}
+
+
 void RDMarkerReadout::setEnabled(bool state)
 {
   if(state) {

lib/rdmarkerreadout.h

@@ -38,6 +38,7 @@ class RDMarkerReadout : public RDWidget
 
  public slots:
   void setValue(RDMarkerHandle::PointerRole role,int value);
+  void setSelectedMarker(RDMarkerHandle::PointerRole role);
   void setEnabled(bool state);
   void setDisabled(bool state);
 
@@ -48,6 +49,7 @@ class RDMarkerReadout : public RDWidget
   QLabel *d_label;
   QList <QLabel *> d_edits;
   QList<RDMarkerHandle::PointerRole> d_roles;
+  RDMarkerHandle::PointerRole d_selected_marker;
 };
 
 

lib/rdmarkerview.cpp

@@ -22,7 +22,6 @@
 #include <QGraphicsSceneMouseEvent>
 #include <QMouseEvent>
 #include <QPen>
-#include <QPolygonF>
 
 #include "rdescape_string.h"
 #include "rdmarkerview.h"
@@ -38,18 +37,18 @@ RDMarkerHandle::RDMarkerHandle(RDMarkerHandle::PointerRole role,
   d_marker_view=mkrview;
   d_x_diff=0;
 
-  QPolygonF triangle;
-
   switch(type) {
   case RDMarkerHandle::Start:
-    triangle << QPointF(0.0,0.0) << QPointF(-16,8) << QPointF(-16,-8);
+    d_triangle << QPointF(0.0,0.0) << QPointF(-16,8) << QPointF(-16,-8);
+    d_big_triangle << QPointF(0.0,0.0) << QPointF(-32,16) << QPointF(-32,-16);
     break;
 
   case RDMarkerHandle::End:
-    triangle << QPointF(0.0,0.0) << QPointF(16,8) << QPointF(16,-8);
+    d_triangle << QPointF(0.0,0.0) << QPointF(16,8) << QPointF(16,-8);
+    d_big_triangle << QPointF(0.0,0.0) << QPointF(32,16) << QPointF(32,-16);
     break;
   }
-  setPolygon(triangle);
+  setPolygon(d_triangle);
   setPen(QPen(RDMarkerHandle::pointerRoleColor(role)));
   setBrush(RDMarkerHandle::pointerRoleColor(role));
   d_name=RDMarkerHandle::pointerRoleTypeText(role);
@@ -84,6 +83,26 @@ void RDMarkerHandle::setMaximum(int pos,int ptr)
 }
 
 
+bool RDMarkerHandle::isSelected() const
+{
+  return d_is_selected;
+}
+
+
+void RDMarkerHandle::setSelected(bool state)
+{
+  if(d_is_selected!=state) {
+    if(state) {
+      setPolygon(d_big_triangle);
+    }
+    else {
+      setPolygon(d_triangle);
+    }
+    d_is_selected=state;
+  }
+}
+
+
 void RDMarkerHandle::mousePressEvent(QGraphicsSceneMouseEvent *e)
 {
   RDMarkerView *view=static_cast<RDMarkerView *>(d_marker_view);
@@ -100,6 +119,7 @@ void RDMarkerHandle::mousePressEvent(QGraphicsSceneMouseEvent *e)
 	}
       }
     }
+    view->processLeftClick(d_role);
   }
 
   if(e->button()==Qt::RightButton) {
@@ -151,6 +171,16 @@ void RDMarkerHandle::mouseMoveEvent(QGraphicsSceneMouseEvent *e)
 }
 
 
+void RDMarkerHandle::wheelEvent(QGraphicsSceneWheelEvent *e)
+{
+  /*
+  if((e->buttons()&Qt::MiddleButton)!=0) {
+    printf("wheelEvent(%d)\n",e->delta());
+  }
+  */
+}
+
+
 void RDMarkerHandle::mouseReleaseEvent(QGraphicsSceneMouseEvent *e)
 {
   //  RDMarkerView *view=static_cast<RDMarkerView *>(d_marker_view);
@@ -289,6 +319,35 @@ QColor RDMarkerHandle::pointerRoleColor(RDMarkerHandle::PointerRole role)
 }
 
 
+RDMarkerHandle::PointerType RDMarkerHandle::pointerType(RDMarkerHandle::PointerRole role)
+{
+  RDMarkerHandle::PointerType ret=RDMarkerHandle::Start;
+
+  switch(role) {
+  case RDMarkerHandle::CutStart:
+  case RDMarkerHandle::TalkStart:
+  case RDMarkerHandle::SegueStart:
+  case RDMarkerHandle::HookStart:
+  case RDMarkerHandle::CutEnd:
+  case RDMarkerHandle::FadeDown:
+    ret=RDMarkerHandle::Start;
+    break;
+
+  case RDMarkerHandle::TalkEnd:
+  case RDMarkerHandle::SegueEnd:
+  case RDMarkerHandle::HookEnd:
+  case RDMarkerHandle::FadeUp:
+    ret=RDMarkerHandle::End;
+    break;
+
+  case RDMarkerHandle::LastRole:
+    break;
+  }
+
+  return ret;
+}
+
+
 RDMarkerView::RDMarkerView(int width,int height,QWidget *parent)
   : QWidget(parent)
 {
@@ -382,12 +441,34 @@ int RDMarkerView::pointerValue(RDMarkerHandle::PointerRole role)
 }
 
 
+RDMarkerHandle::PointerRole RDMarkerView::selectedMarker() const
+{
+  return d_selected_marker;
+}
+
+
 bool RDMarkerView::hasUnsavedChanges() const
 {
   return d_has_unsaved_changes;
 }
 
 
+void RDMarkerView::processLeftClick(RDMarkerHandle::PointerRole role)
+{
+  if(role!=d_selected_marker) {
+    for(int i=0;i<RDMarkerHandle::LastRole;i++) {
+      for(int j=0;j<2;j++) {
+	if(d_handles[i][j]!=NULL) {
+	  d_handles[i][j]->setSelected(role==(RDMarkerHandle::PointerRole)i);
+	}
+      }
+    }
+  }
+  d_selected_marker=role;
+  emit selectedMarkerChanged(role);
+}
+
+
 void RDMarkerView::processRightClick(RDMarkerHandle::PointerRole role,
 				     const QPointF &pos)
 {
@@ -521,6 +602,7 @@ void RDMarkerView::clear()
   d_audio_length=0;
   d_has_unsaved_changes=false;
   d_marker_menu_used=false;
+  d_selected_marker=RDMarkerHandle::LastRole;
 }
 
 
@@ -611,8 +693,9 @@ void RDMarkerView::addFadeupData()
 {
   d_pointers[RDMarkerHandle::FadeUp]=Msec(d_mouse_pos);
 
-  DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::FadeUp,80);
+  DrawMarker(RDMarkerHandle::End,RDMarkerHandle::FadeUp,80);
-  InterlockMarkerPair(RDMarkerHandle::FadeUp);
+  InterlockFadeMarkerPair();
+  //  InterlockMarkerPair(RDMarkerHandle::FadeUp);
 
   d_has_unsaved_changes=true;
 
@@ -625,8 +708,9 @@ void RDMarkerView::addFadedownData()
 {
   d_pointers[RDMarkerHandle::FadeDown]=Msec(d_mouse_pos);
 
-  DrawMarker(RDMarkerHandle::End,RDMarkerHandle::FadeDown,80);
+  DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::FadeDown,80);
-  InterlockMarkerPair(RDMarkerHandle::FadeUp);
+  InterlockFadeMarkerPair();
+  //  InterlockMarkerPair(RDMarkerHandle::FadeDown);
 
   d_has_unsaved_changes=true;
 
@@ -651,6 +735,7 @@ void RDMarkerView::updateInterlocks()
   //
   // Check for "swiped" markers and remove them
   //
+  /*
   for(int i=2;i<(RDMarkerHandle::LastRole);i++) {
     RDMarkerHandle::PointerRole role=(RDMarkerHandle::PointerRole)i;
     if((d_pointers[i]>=0)&&
@@ -679,7 +764,7 @@ void RDMarkerView::updateInterlocks()
       }
     }
   }
-
+  */
   //
   // Update the limit stops
   //
@@ -698,12 +783,58 @@ void RDMarkerView::updateInterlocks()
   InterlockMarkerPair(RDMarkerHandle::TalkStart);
   InterlockMarkerPair(RDMarkerHandle::SegueStart);
   InterlockMarkerPair(RDMarkerHandle::HookStart);
-  InterlockMarkerPair(RDMarkerHandle::FadeUp);
+  InterlockFadeMarkerPair();
 
   //  printf("d_right_margin: %d\n",d_right_margin);
 }
 
 
+void RDMarkerView::InterlockFadeMarkerPair()
+{
+  //
+  // FadeUp
+  //
+  for(int i=0;i<2;i++) {
+    if(d_handles[RDMarkerHandle::FadeUp][i]!=NULL) {
+      d_handles[RDMarkerHandle::FadeUp][i]->
+	setMinimum(d_handles[RDMarkerHandle::CutStart][i]->pos().x()-LEFT_MARGIN,
+		   d_pointers[RDMarkerHandle::CutStart]);
+      if(d_handles[RDMarkerHandle::FadeDown][i]!=NULL) {
+	d_handles[RDMarkerHandle::FadeUp][i]->
+	  setMaximum(d_handles[RDMarkerHandle::FadeDown][i]->pos().x()-LEFT_MARGIN,
+		   d_pointers[RDMarkerHandle::FadeDown]);
+      }
+      else {
+	d_handles[RDMarkerHandle::FadeUp][i]->
+	  setMaximum(d_handles[RDMarkerHandle::CutEnd][i]->pos().x()-LEFT_MARGIN,
+		     d_pointers[RDMarkerHandle::CutEnd]);	  
+      }
+    }
+  }
+
+  //
+  // FadeDown
+  //
+  for(int i=0;i<2;i++) {
+    if(d_handles[RDMarkerHandle::FadeDown][i]!=NULL) {
+      d_handles[RDMarkerHandle::FadeDown][i]->
+	setMaximum(d_handles[RDMarkerHandle::CutEnd][i]->pos().x()-LEFT_MARGIN,
+		   d_pointers[RDMarkerHandle::CutEnd]);
+      if(d_handles[RDMarkerHandle::FadeUp][i]!=NULL) {
+	d_handles[RDMarkerHandle::FadeDown][i]->
+	  setMinimum(d_handles[RDMarkerHandle::FadeUp][i]->pos().x()-LEFT_MARGIN,
+		   d_pointers[RDMarkerHandle::FadeUp]);
+      }
+      else {
+	d_handles[RDMarkerHandle::FadeUp][i]->
+	  setMinimum(d_handles[RDMarkerHandle::CutStart][i]->pos().x()-LEFT_MARGIN,
+		     d_pointers[RDMarkerHandle::CutStart]);	  
+      }
+    }
+  }
+}
+
+
 void RDMarkerView::InterlockMarkerPair(RDMarkerHandle::PointerRole start_marker)
 {
   for(int i=0;i<2;i++) {
@@ -858,8 +989,8 @@ void RDMarkerView::WriteWave()
   //
   // Markers
   //
-  DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::FadeUp,100);
+  DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::FadeDown,100);
-  DrawMarker(RDMarkerHandle::End,RDMarkerHandle::FadeDown,100);
+  DrawMarker(RDMarkerHandle::End,RDMarkerHandle::FadeUp,100);
   DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::HookStart,80);
   DrawMarker(RDMarkerHandle::End,RDMarkerHandle::HookEnd,80);
   DrawMarker(RDMarkerHandle::Start,RDMarkerHandle::TalkStart,60);

lib/rdmarkerview.h

@@ -27,6 +27,7 @@
 #include <QGraphicsView>
 #include <QList>
 #include <QMenu>
+#include <QPolygonF>
 
 #include <rdcut.h>
 #include <rdwavefactory.h>
@@ -39,7 +40,7 @@ class RDMarkerHandle : public QGraphicsPolygonItem
 		    TalkStart=2,TalkEnd=3,
 		    SegueStart=4,SegueEnd=5,
 		    HookStart=6,HookEnd=7,
-		    FadeUp=8,FadeDown=9,
+		    FadeDown=8,FadeUp=9,
 		    LastRole=10};
   RDMarkerHandle(RDMarkerHandle::PointerRole role,PointerType type,
 		 void *mkrview,QGraphicsItem *parent=nullptr);
@@ -47,18 +48,23 @@ class RDMarkerHandle : public QGraphicsPolygonItem
   PointerRole role() const;
   void setMinimum(int pos,int ptr);
   void setMaximum(int pos,int ptr);
+  bool isSelected() const;
+  void setSelected(bool state);
   static QString pointerRoleText(PointerRole role);
   static QString pointerRoleTypeText(PointerRole role);
   static QColor pointerRoleColor(PointerRole role);
+  static PointerType pointerType(PointerRole role);
 
  protected:
   void mousePressEvent(QGraphicsSceneMouseEvent *e);
   void mouseMoveEvent(QGraphicsSceneMouseEvent *e);
+  void wheelEvent(QGraphicsSceneWheelEvent *e);
   void mouseReleaseEvent(QGraphicsSceneMouseEvent *e);
 
  private:
   QString d_name;
   PointerRole d_role;
+  bool d_is_selected;
   QList<QGraphicsItem *> d_peers;
   void *d_marker_view;
   int d_minimum_pos;
@@ -66,6 +72,8 @@ class RDMarkerHandle : public QGraphicsPolygonItem
   int d_maximum_pos;
   int d_maximum_ptr;
   int d_x_diff;
+  QPolygonF d_triangle;
+  QPolygonF d_big_triangle;
 };
 
 
@@ -81,8 +89,10 @@ class RDMarkerView : public QWidget
   unsigned sampleRate() const;
   int shrinkFactor() const;
   int pointerValue(RDMarkerHandle::PointerRole role);
+  RDMarkerHandle::PointerRole selectedMarker() const;
   bool hasUnsavedChanges() const;
 
+  void processLeftClick(RDMarkerHandle::PointerRole role);
   void processRightClick(RDMarkerHandle::PointerRole role,
 			 const QPointF &pos);
   void updatePosition(RDMarkerHandle::PointerRole role,int ptr);
@@ -90,6 +100,7 @@ class RDMarkerView : public QWidget
  signals:
   void positionClicked(int msec);
   void pointerValueChanged(RDMarkerHandle::PointerRole role,int msec);
+  void selectedMarkerChanged(RDMarkerHandle::PointerRole role);
 
  public slots:
   void setAudioGain(int lvl);
@@ -118,6 +129,8 @@ class RDMarkerView : public QWidget
   int Frame(int msec) const;
   int Msec(int frame) const;
   void InterlockMarkerPair(RDMarkerHandle::PointerRole start_marker);
+  void InterlockFadeMarkerPair();
+  //  void InterlockFadeUp();
   bool LoadCutData();
   void WriteWave();
   void DrawMarker(RDMarkerHandle::PointerType type,
@@ -154,6 +167,7 @@ class RDMarkerView : public QWidget
   QList<RDMarkerHandle::PointerRole> d_deleting_roles;
   QAction *d_delete_marker_action;
   bool d_marker_menu_used;
+  RDMarkerHandle::PointerRole d_selected_marker;
 };