Add seq view horizontal wheel event

src/ui/component/sequencer/SeqTimeRuler.h

@@ -36,7 +36,7 @@ class SeqTimeRuler final
  void mouseUp(const juce::MouseEvent& event) override;
  void mouseMove(const juce::MouseEvent& event) override;
  void mouseWheelMove(const juce::MouseEvent& event,
- const juce::MouseWheelDetails& wheel);
+ const juce::MouseWheelDetails& wheel) override;
 
  /** Place, IsBar, barId */
  using LineItem = std::tuple<double, bool, int>;

src/ui/component/sequencer/SeqTrackComponent.cpp

@@ -9,6 +9,8 @@
 
 SeqTrackComponent::SeqTrackComponent(
  const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelHFunc,
+ const WheelAltFunc& wheelAltHFunc,
  const DragStartFunc& dragStartFunc,
  const DragProcessFunc& dragProcessFunc,
  const DragEndFunc& dragEndFunc) {
@@ -108,7 +110,8 @@ SeqTrackComponent::SeqTrackComponent(
 
  /** Content */
  this->content = std::make_unique<SeqTrackContentViewer>(
- scrollFunc, dragStartFunc, dragProcessFunc, dragEndFunc);
+ scrollFunc, wheelHFunc, wheelAltHFunc,
+ dragStartFunc, dragProcessFunc, dragEndFunc);
  this->addAndMakeVisible(this->content.get());
 }
 

src/ui/component/sequencer/SeqTrackComponent.h

@@ -15,10 +15,14 @@ class SeqTrackComponent final
  public juce::SettableTooltipClient {
 public:
  using ScrollFunc = std::function<void(double)>;
+ using WheelFunc = std::function<void(float, bool)>;
+ using WheelAltFunc = std::function<void(double, double, float, bool)>;
  using DragStartFunc = std::function<void(void)>;
  using DragProcessFunc = std::function<void(int, int, bool, bool)>;
  using DragEndFunc = std::function<void(void)>;
  SeqTrackComponent(const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelHFunc,
+ const WheelAltFunc& wheelAltHFunc,
  const DragStartFunc& dragStartFunc,
  const DragProcessFunc& dragProcessFunc,
  const DragEndFunc& dragEndFunc);

src/ui/component/sequencer/SeqTrackContentViewer.cpp

@@ -33,10 +33,12 @@ void DataImageUpdateTimer::timerCallback() {
 
 SeqTrackContentViewer::SeqTrackContentViewer(
  const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelFunc,
+ const WheelAltFunc& wheelAltFunc,
  const DragStartFunc& dragStartFunc,
  const DragProcessFunc& dragProcessFunc,
  const DragEndFunc& dragEndFunc)
- : scrollFunc(scrollFunc),
+ : scrollFunc(scrollFunc), wheelFunc(wheelFunc), wheelAltFunc(wheelAltFunc),
  dragStartFunc(dragStartFunc), dragProcessFunc(dragProcessFunc),
  dragEndFunc(dragEndFunc) {
  /** Look And Feel */
@@ -639,6 +641,7 @@ void SeqTrackContentViewer::mouseUp(const juce::MouseEvent& event) {
  if (event.mods.isLeftButtonDown()) {
  /** Move View */
  if (this->viewMoving) {
+ this->viewMoving = false;
  this->dragEndFunc();
  }
 
@@ -716,6 +719,19 @@ void SeqTrackContentViewer::mouseExit(const juce::MouseEvent& event) {
  this->repaint();
 }
 
+void SeqTrackContentViewer::mouseWheelMove(const juce::MouseEvent& event,
+ const juce::MouseWheelDetails& wheel) {
+ if (event.mods.isAltDown()) {
+ double thumbPer = event.position.getX() / (double)this->getWidth();
+ double centerNum = this->secStart + (this->secEnd - this->secStart) * thumbPer;
+
+ this->wheelAltFunc(centerNum, thumbPer, wheel.deltaY, wheel.isReversed);
+ }
+ else {
+ this->wheelFunc(wheel.deltaY, wheel.isReversed);
+ }
+}
+
 void SeqTrackContentViewer::updateBlockInternal(int blockIndex) {
  if (auto temp = this->blockTemp[blockIndex]) {
  std::tie(temp->startTime, temp->endTime, temp->offset)

src/ui/component/sequencer/SeqTrackContentViewer.h

@@ -5,10 +5,14 @@
 class SeqTrackContentViewer final : public juce::Component {
 public:
  using ScrollFunc = std::function<void(double)>;
+ using WheelFunc = std::function<void(float, bool)>;
+ using WheelAltFunc = std::function<void(double, double, float, bool)>;
  using DragStartFunc = std::function<void(void)>;
  using DragProcessFunc = std::function<void(int, int, bool, bool)>;
  using DragEndFunc = std::function<void(void)>;
  SeqTrackContentViewer(const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelFunc,
+ const WheelAltFunc& wheelAltFunc,
  const DragStartFunc& dragStartFunc,
  const DragProcessFunc& dragProcessFunc,
  const DragEndFunc& dragEndFunc);
@@ -29,9 +33,13 @@ class SeqTrackContentViewer final : public juce::Component {
  void mouseDown(const juce::MouseEvent& event) override;
  void mouseUp(const juce::MouseEvent& event) override;
  void mouseExit(const juce::MouseEvent& event) override;
+ void mouseWheelMove(const juce::MouseEvent& event,
+ const juce::MouseWheelDetails& wheel) override;
 
 private:
  const ScrollFunc scrollFunc;
+ const WheelFunc wheelFunc;
+ const WheelAltFunc wheelAltFunc;
  const DragStartFunc dragStartFunc;
  const DragProcessFunc dragProcessFunc;
  const DragEndFunc dragEndFunc;

src/ui/component/sequencer/SeqView.cpp

@@ -9,6 +9,16 @@
 
 #define SEQ_TAIL_SEC 10;
 
+SeqView::TrackList::TrackList(
+ const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelHFunc,
+ const WheelAltFunc& wheelAltHFunc,
+ const DragStartFunc& dragStartFunc,
+ const DragProcessFunc& dragProcessFunc,
+ const DragEndFunc& dragEndFunc)
+ : scrollFunc(scrollFunc), wheelHFunc(wheelHFunc), wheelAltHFunc(wheelAltHFunc),
+ dragStartFunc(dragStartFunc), dragProcessFunc(dragProcessFunc), dragEndFunc(dragEndFunc) {}
+
 int SeqView::TrackList::size() const {
  return this->list.size();
 }
@@ -80,6 +90,18 @@ void SeqView::TrackList::updateData(int index) {
 }
 
 void SeqView::TrackList::updateHPos(double pos, double itemSize) {
+ /** Size */
+ auto screenSize = utils::getScreenSize(this);
+ int headWidth = screenSize.getWidth() * 0.1;
+
+ /** Temp */
+ this->pos = pos;
+ this->itemSize = itemSize;
+
+ this->secStart = pos / itemSize;
+ this->secEnd = this->secStart + ((this->getWidth() - headWidth) / itemSize);
+
+ /** Tracks */
  for (auto i : this->list) {
  i->updateHPos(pos, itemSize);
  }
@@ -94,12 +116,117 @@ void SeqView::TrackList::updateVPos(double pos, double itemSize) {
  }
 }
 
+void SeqView::TrackList::mouseDown(const juce::MouseEvent& event) {
+ /** Size */
+ auto screenSize = utils::getScreenSize(this);
+ int headWidth = screenSize.getWidth() * 0.1;
+
+ /** Get Tool Type */
+ auto tool = Tools::getInstance()->getType();
+
+ /** Not Head */
+ if (event.position.x > headWidth) {
+ if (event.mods.isLeftButtonDown()) {
+ /** Check Tool Type */
+ switch (tool) {
+ case Tools::Type::Hand:
+ /** Move View Area */
+ this->viewMoving = true;
+ this->dragStartFunc();
+ break;
+ }
+ }
+ }
+}
+
 void SeqView::TrackList::mouseUp(const juce::MouseEvent& event) {
- if (event.mods.isRightButtonDown()) {
- this->add();
+ if (event.mods.isLeftButtonDown()) {
+ /** Move View */
+ if (this->viewMoving) {
+ this->viewMoving = false;
+ this->dragEndFunc();
+ }
+ }
+ else if (event.mods.isRightButtonDown()) {
+ if (!event.mouseWasDraggedSinceMouseDown()) {
+ this->add();
+ }
  }
 }
 
+void SeqView::TrackList::mouseMove(const juce::MouseEvent& event) {
+ /** Size */
+ auto screenSize = utils::getScreenSize(this);
+ int headWidth = screenSize.getWidth() * 0.1;
+
+ float posX = event.position.getX();
+
+ /** Not Head */
+ if (posX > headWidth) {
+ /** Move */
+ if (Tools::getInstance()->getType() == Tools::Type::Hand) {
+ this->setMouseCursor(juce::MouseCursor::DraggingHandCursor);
+ return;
+ }
+ }
+
+ this->setMouseCursor(juce::MouseCursor::NormalCursor);
+}
+
+void SeqView::TrackList::mouseDrag(const juce::MouseEvent& event) {
+ /** Size */
+ auto screenSize = utils::getScreenSize(this);
+ int headWidth = screenSize.getWidth() * 0.1;
+
+ /** Not Head */
+ if (event.mouseDownPosition.getX() > headWidth) {
+ /** Auto Scroll */
+ float xPos = event.position.getX();
+ if (!this->viewMoving) {
+ double delta = 0;
+ if (xPos > this->getWidth()) {
+ delta = xPos - this->getWidth();
+ }
+ else if (xPos < headWidth) {
+ delta = xPos - headWidth;
+ }
+
+ if (delta != 0) {
+ this->scrollFunc(delta / 4);
+ }
+ }
+
+ if (event.mods.isLeftButtonDown()) {
+ /** Move View */
+ if (this->viewMoving) {
+ int distanceX = event.getDistanceFromDragStartX();
+ int distanceY = event.getDistanceFromDragStartY();
+ this->dragProcessFunc(distanceX, distanceY, true, true);
+ }
+ }
+ }
+}
+
+void SeqView::TrackList::mouseWheelMove(const juce::MouseEvent& event,
+ const juce::MouseWheelDetails& wheel) {
+ /** Size */
+ auto screenSize = utils::getScreenSize(this);
+ int headWidth = screenSize.getWidth() * 0.1;
+
+ if (event.position.getX() > headWidth) {
+ if (event.mods.isAltDown()) {
+ double thumbPer = (event.position.getX() - headWidth) / (double)(this->getWidth() - headWidth);
+ double centerNum = this->secStart + (this->secEnd - this->secStart) * thumbPer;
+
+ this->wheelAltHFunc(centerNum, thumbPer, wheel.deltaY, wheel.isReversed);
+ }
+ else {
+ this->wheelHFunc(wheel.deltaY, wheel.isReversed);
+ }
+ }
+
+}
+
 void SeqView::TrackList::add() {
  CoreActions::insertSeqGUI();
 }
@@ -116,10 +243,6 @@ SeqView::SeqView()
  this->adsorbIcon->replaceColour(juce::Colours::black,
  this->getLookAndFeel().findColour(juce::TextButton::ColourIds::textColourOffId));
 
- /** Track List */
- this->trackList = std::make_unique<TrackList>();
- this->addAndMakeVisible(this->trackList.get());
-
  /** Scroller */
  this->hScroller = std::make_unique<Scroller>(false,
  [this] { return (double)(this->getViewWidth()); },
@@ -142,6 +265,45 @@ SeqView::SeqView()
  this->paintTrackPreview(g, itemIndex, width, height, vertical); });
  this->addAndMakeVisible(this->vScroller.get());
 
+ /** Track List */
+ this->trackList = std::make_unique<TrackList>(
+ [comp = ScrollerBase::SafePointer(this->hScroller.get())]
+ (double delta) {
+ if (comp) {
+ comp->scroll(delta);
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this->hScroller.get())]
+ (float deltaY, bool reversed) {
+ if (comp) {
+ comp->mouseWheelOutside(deltaY, reversed);
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this->hScroller.get())]
+ (double centerNum, double thumbPer, float deltaY, bool reversed) {
+ if (comp) {
+ comp->mouseWheelOutsideWithAlt(centerNum, thumbPer, deltaY, reversed);
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this)] {
+ if (comp) {
+ comp->processAreaDragStart();
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this)]
+ (int distanceX, int distanceY, bool moveX, bool moveY) {
+ if (comp) {
+ comp->processAreaDragTo(
+ distanceX, distanceY, moveX, moveY);
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this)] {
+ if (comp) {
+ comp->processAreaDragEnd();
+ }
+ });
+ this->addAndMakeVisible(this->trackList.get());
+
  /** Button */
  this->adsorbButton = std::make_unique<juce::DrawableButton>(
  TRANS("Adsorb"), juce::DrawableButton::ButtonStyle::ImageOnButtonBackground);
@@ -479,6 +641,18 @@ void SeqView::update(int index) {
  comp->scroll(delta);
  }
  },
+ [comp = ScrollerBase::SafePointer(this->hScroller.get())]
+ (float deltaY, bool reversed) {
+ if (comp) {
+ comp->mouseWheelOutside(deltaY, reversed);
+ }
+ },
+ [comp = ScrollerBase::SafePointer(this->hScroller.get())]
+ (double centerNum, double thumbPer, float deltaY, bool reversed) {
+ if (comp) {
+ comp->mouseWheelOutsideWithAlt(centerNum, thumbPer, deltaY, reversed);
+ }
+ },
  [comp = ScrollerBase::SafePointer(this)] {
  if (comp) {
  comp->processAreaDragStart();

src/ui/component/sequencer/SeqView.h

@@ -37,7 +37,18 @@ class SeqView final
 
  class TrackList : public juce::Component {
  public:
- TrackList() = default;
+ using ScrollFunc = std::function<void(double)>;
+ using WheelFunc = std::function<void(float, bool)>;
+ using WheelAltFunc = std::function<void(double, double, float, bool)>;
+ using DragStartFunc = std::function<void(void)>;
+ using DragProcessFunc = std::function<void(int, int, bool, bool)>;
+ using DragEndFunc = std::function<void(void)>;
+ TrackList(const ScrollFunc& scrollFunc,
+ const WheelFunc& wheelHFunc,
+ const WheelAltFunc& wheelAltHFunc,
+ const DragStartFunc& dragStartFunc,
+ const DragProcessFunc& dragProcessFunc,
+ const DragEndFunc& dragEndFunc);
 
  int size() const;
  void remove(int index);
@@ -55,11 +66,28 @@ class SeqView final
  void updateHPos(double pos, double itemSize);
  void updateVPos(double pos, double itemSize);
 
+ void mouseDown(const juce::MouseEvent& event) override;
  void mouseUp(const juce::MouseEvent& event) override;
+ void mouseMove(const juce::MouseEvent& event) override;
+ void mouseDrag(const juce::MouseEvent& event) override;
+ void mouseWheelMove(const juce::MouseEvent& event,
+ const juce::MouseWheelDetails& wheel) override;
 
  private:
  juce::OwnedArray<SeqTrackComponent> list;
 
+ const ScrollFunc scrollFunc;
+ const WheelFunc wheelHFunc;
+ const WheelAltFunc wheelAltHFunc;
+ const DragStartFunc dragStartFunc;
+ const DragProcessFunc dragProcessFunc;
+ const DragEndFunc dragEndFunc;
+
+ double pos = 0, itemSize = 0;
+ double secStart = 0, secEnd = 0;
+
+ bool viewMoving = false;
+
  void add();
 
  JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(TrackList)