StepPadView.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 pongasoft
 *
 * Licensed under the Apache License, Version 2.0 or the MIT license,
 * at your option. You may not use this file except in compliance with
 * one of these licenses. You may obtain copies of the licenses at:
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 * https://opensource.org/licenses/MIT
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @author Yan Pujante
 */
#pragma once
 
#include <vstgui4/vstgui/lib/controls/ccontrol.h>
#include <vstgui4/vstgui/lib/cdrawcontext.h>
#include <pongasoft/VST/GUI/Params/GUIVstParameter.h>
#include "CustomControlView.h"
 
namespace pongasoft::VST::GUI::Views {
 
using namespace VSTGUI;

class StepPadView : public CustomDiscreteControlView
{
public:
  enum class EPositiveDirection
  {
    kUp,
    kDown,
    kRight,
    kLeft,
  };
 
public:
  explicit StepPadView(const CRect &iSize) : CustomDiscreteControlView(iSize)
  {
  }
 
  // draw => does the actual drawing job
  void draw(CDrawContext *iContext) override;
 
  // called to display the "held" pad state
  virtual void drawHeldPad(CDrawContext *iContext);
 
  // called to display the "released" pad state
  virtual void drawReleasedPad(CDrawContext *iContext);
 
  // input events (mouse/keyboard)
  CMouseEventResult onMouseDown(CPoint &where, const CButtonState &buttons) override;
  CMouseEventResult onMouseMoved(CPoint &where, const CButtonState &buttons) override;
  CMouseEventResult onMouseUp(CPoint &where, const CButtonState &buttons) override;
  CMouseEventResult onMouseCancel() override;
 
  // true if held
  bool isHeld() const { return fHeld; }

  inline CColor const &getHeldColor() const { return fHeldColor; }
  void setHeldColor(CColor const &iColor) { fHeldColor = iColor; }

  CColor const &getDisabledColor() const { return fDisabledColor; }
  void setDisabledColor(CColor const &iColor) { fDisabledColor = iColor; }

  BitmapPtr getImage() const { return fImage; }

  void setImage(BitmapPtr iImage) { fImage = iImage; }

  bool getImageHasDisabledState() const { return fImageHasDisabledState; }
  void setImageHasDisabledState(bool iValue) { fImageHasDisabledState = iValue; }

  int32 getStepIncrement() const { return fStepIncrement; }
  void setStepIncrement(int32 iStepIncrement) { fStepIncrement = iStepIncrement; }

  int32 getShiftStepIncrement() const { return fShiftStepIncrement; }

  void setShiftStepIncrement(int32 iStepIncrement) { fShiftStepIncrement = iStepIncrement; }

  double getDragFactor() const { return fDragFactor; }
  void setDragFactor(double iDragFactor) { fDragFactor = iDragFactor; }

  double getShiftDragFactor() const { return fShiftDragFactor; }
  void setShiftDragFactor(double iShiftDragFactor) { fShiftDragFactor = iShiftDragFactor; }

  inline bool getWrap() const { return fWrap; }
  void setWrap(bool iFlag) { fWrap = iFlag; }

  bool getInverse() const { return fInverse; }
  void setInverse(bool iInverse) { fInverse = iInverse; }

  EPositiveDirection getDirection() const { return fDirection; }
  void setDirection(EPositiveDirection iDirection) { fDirection = iDirection; }
 
protected:
  // registerParameters
  void registerParameters() override;

  virtual CMouseEventResult setNextValue(CPoint &iWhere, const CButtonState &iButtons);
 
  // sizeToFit
  bool sizeToFit() override;
 
protected:
  bool fHeld{false};
 
  int32 fStepIncrement{1};
  int32 fShiftStepIncrement{1};
  double fDragFactor{100.0};
  double fShiftDragFactor{100.0};
  bool fWrap{false};
 
  CColor fHeldColor{kRedCColor};
  CColor fDisabledColor{kBlackCColor};
  BitmapSPtr fImage{nullptr};
  bool fInverse{false};
  EPositiveDirection fDirection{EPositiveDirection::kUp};
 
  // whether the image has disabled state (3 frames) or not (2 frames)
  bool fImageHasDisabledState{false};
 
  // the editor for handling parameter change
  GUIOptionalParam<int32>::Editor fEditor{};
  CPoint fMousePosition{};
 
public:
  class Creator : public CustomViewCreator<StepPadView, CustomDiscreteControlView>
  {
    public:
    explicit Creator(char const *iViewName = nullptr, char const *iDisplayName = nullptr) :
      CustomViewCreator(iViewName, iDisplayName)
    {
      registerIntegerAttribute<int32>("step-increment", &StepPadView::getStepIncrement, &StepPadView::setStepIncrement);
      registerIntegerAttribute<int32>("shift-step-increment", &StepPadView::getShiftStepIncrement, &StepPadView::setShiftStepIncrement);
      registerDoubleAttribute("drag-factor", &StepPadView::getDragFactor, &StepPadView::setDragFactor);
      registerDoubleAttribute("shift-drag-factor", &StepPadView::getShiftDragFactor, &StepPadView::setShiftDragFactor);
      registerBooleanAttribute("wrap", &StepPadView::getWrap, &StepPadView::setWrap);
      registerColorAttribute("held-color", &StepPadView::getHeldColor, &StepPadView::setHeldColor);
      registerColorAttribute("disabled-color", &StepPadView::getDisabledColor, &StepPadView::setDisabledColor);
      registerBitmapAttribute("pad-image", &StepPadView::getImage, &StepPadView::setImage);
      registerBooleanAttribute("pad-image-has-disabled-state", &StepPadView::getImageHasDisabledState, &StepPadView::setImageHasDisabledState);
      registerBooleanAttribute("inverse", &StepPadView::getInverse, &StepPadView::setInverse);
      registerListAttribute<EPositiveDirection>("positive-direction",
                                                &StepPadView::getDirection, &StepPadView::setDirection,
                                                {
                                                  {"up",   EPositiveDirection::kUp},
                                                  {"down", EPositiveDirection::kDown},
                                                  {"right",   EPositiveDirection::kRight},
                                                  {"left",   EPositiveDirection::kLeft}
                                                }
      );
    }
  };
};
 
}