//-----------------------------------------------------------------------------
CMouseEventResult CSegmentButton::onMouseDown (CPoint& where, const CButtonState& buttons)
{
if (buttons.isLeftButton ())
{
float newValue = 0;
float valueOffset = 1.f / (segments.size () - 1);
uint32_t currentIndex = getSegmentIndex (getValueNormalized ());
for (Segments::const_iterator it = segments.begin (), end = segments.end (); it != end; ++it, newValue += valueOffset)
{
if ((*it).rect.pointInside (where))
{
uint32_t newIndex = getSegmentIndex (newValue);
if (newIndex != currentIndex)
{
beginEdit ();
setSelectedSegment (newIndex);
valueChanged ();
endEdit ();
invalid ();
}
break;
}
}
}
return kMouseDownEventHandledButDontNeedMovedOrUpEvents;
}
//------------------------------------------------------------------------
bool CSlider::onWheel (const CPoint& where, const float &distance, const CButtonState &buttons)
{
if (!getMouseEnabled ())
return false;
float _distance = distance;
if (styleIsInverseStyle (style))
_distance *= -1.f;
float normValue = getValueNormalized ();
if (buttons & kZoomModifier)
normValue += 0.1f * _distance * wheelInc;
else
normValue += _distance * wheelInc;
setValueNormalized (normValue);
if (isDirty ())
{
invalid ();
// begin of edit parameter
beginEdit ();
valueChanged ();
// end of edit parameter
endEdit ();
}
return true;
}
//------------------------------------------------------------------------
void CMovieBitmap::draw (CDrawContext *pContext)
{
CPoint where (offset.h, offset.v);
where.v += heightOfOneImage * (int32_t)(getValueNormalized () * (getNumSubPixmaps () - 1) + 0.5);
if (getDrawBackground ())
{
getDrawBackground ()->draw (pContext, getViewSize (), where);
}
setDirty (false);
}
//-----------------------------------------------------------------------------
int32_t CSegmentButton::onKeyDown (VstKeyCode& keyCode)
{
int32_t result = -1;
if (keyCode.modifier == 0 && keyCode.character == 0)
{
uint32_t newIndex = getSegmentIndex (getValueNormalized ());
uint32_t oldIndex = newIndex;
switch (keyCode.virt)
{
case VKEY_LEFT:
{
if (style == kHorizontal && newIndex > 0)
newIndex--;
result = 1;
break;
}
case VKEY_RIGHT:
{
if (style == kHorizontal && newIndex < segments.size () - 1)
newIndex++;
result = 1;
break;
}
case VKEY_UP:
{
if (style == kVertical && newIndex > 0)
newIndex--;
result = 1;
break;
}
case VKEY_DOWN:
{
if (style == kVertical && newIndex < segments.size () - 1)
newIndex++;
result = 1;
break;
}
}
if (newIndex != oldIndex)
{
beginEdit ();
setSelectedSegment (newIndex);
valueChanged ();
endEdit ();
invalid ();
}
}
return result;
}
//------------------------------------------------------------------------
float CSlider::calculateDelta (const CPoint& where, CRect* handleRect) const
{
CCoord result;
if (style & kHorizontal)
result = getViewSize ().left + offsetHandle.x;
else
result = getViewSize ().top + offsetHandle.y;
if (getMode () != kFreeClickMode)
{
float normValue = getValueNormalized ();
if (style & kRight || style & kBottom)
normValue = 1.f - normValue;
CCoord actualPos;
CRect rect;
actualPos = result + (int32_t)(normValue * rangeHandle);
if (style & kHorizontal)
{
if (handleRect)
{
handleRect->left = actualPos;
handleRect->top = getViewSize ().top + offsetHandle.y;
handleRect->right = handleRect->left + widthOfSlider;
handleRect->bottom = handleRect->top + heightOfSlider;
}
result += where.x - actualPos;
}
else
{
if (handleRect)
{
handleRect->left = getViewSize ().left + offsetHandle.x;
handleRect->top = actualPos;
handleRect->right = handleRect->left + widthOfSlider;
handleRect->bottom = handleRect->top + heightOfSlider;
}
result += where.y - actualPos;
}
}
else
{
if (style & kHorizontal)
result += widthOfSlider / 2 - 1;
else
result += heightOfSlider / 2 - 1;
}
return (float)result;
}
//------------------------------------------------------------------------
int32_t CSlider::onKeyDown (VstKeyCode& keyCode)
{
switch (keyCode.virt)
{
case VKEY_UP :
case VKEY_RIGHT :
case VKEY_DOWN :
case VKEY_LEFT :
{
float distance = 1.f;
bool isInverse = styleIsInverseStyle (style);
if ((keyCode.virt == VKEY_DOWN && !isInverse)
|| (keyCode.virt == VKEY_UP && isInverse)
|| (keyCode.virt == VKEY_LEFT && !isInverse)
|| (keyCode.virt == VKEY_RIGHT && isInverse))
{
distance = -distance;
}
float normValue = getValueNormalized ();
if (mapVstKeyModifier (keyCode.modifier) & kZoomModifier)
normValue += 0.1f * distance * wheelInc;
else
normValue += distance * wheelInc;
setValueNormalized (normValue);
if (isDirty ())
{
invalid ();
// begin of edit parameter
beginEdit ();
valueChanged ();
// end of edit parameter
endEdit ();
}
return 1;
}
}
return -1;
}
//-----------------------------------------------------------------------------
uint32_t CSegmentButton::getSelectedSegment () const
{
return getSegmentIndex (getValueNormalized ());
}
//------------------------------------------------------------------------
void CSlider::draw (CDrawContext *pContext)
{
CDrawContext* drawContext = pContext;
// draw background
if (getDrawBackground ())
{
CRect rect (0, 0, widthControl, heightControl);
rect.offset (getViewSize ().left, getViewSize ().top);
getDrawBackground ()->draw (drawContext, rect, offset);
}
if (drawStyle != 0)
{
CRect r (getViewSize ());
pContext->setDrawMode (kAliasing);
pContext->setLineStyle (kLineSolid);
pContext->setLineWidth (1.);
if (drawStyle & kDrawFrame || drawStyle & kDrawBack)
{
pContext->setFrameColor (frameColor);
pContext->setFillColor (backColor);
CDrawStyle d = kDrawFilled;
if (drawStyle & kDrawFrame && drawStyle & kDrawBack)
d = kDrawFilledAndStroked;
else if (drawStyle & kDrawFrame)
d = kDrawStroked;
pContext->drawRect (r, d);
}
pContext->setDrawMode (kAliasing);
if (drawStyle & kDrawValue)
{
if (drawStyle & kDrawFrame)
r.inset (1., 1.);
float drawValue = getValueNormalized ();
if (drawStyle & kDrawValueFromCenter)
{
if (drawStyle & kDrawInverted)
drawValue = 1.f - drawValue;
if (getStyle () & kHorizontal)
{
CCoord width = r.getWidth ();
r.right = r.left + r.getWidth () * drawValue;
r.left += width / 2.;
r.normalize ();
}
else
{
CCoord height = r.getHeight ();
r.bottom = r.top + r.getHeight () * drawValue;
r.top += height / 2.;
r.normalize ();
}
}
else
{
if (getStyle () & kHorizontal)
{
if (drawStyle & kDrawInverted)
r.left = r.right - r.getWidth () * drawValue;
else
r.right = r.left + r.getWidth () * drawValue;
}
else
{
if (drawStyle & kDrawInverted)
r.bottom = r.top + r.getHeight () * drawValue;
else
r.top = r.bottom - r.getHeight () * drawValue;
}
}
r.normalize ();
if (r.getWidth () >= 0.5 && r.getHeight () >= 0.5)
{
pContext->setFillColor (valueColor);
pContext->drawRect (r, kDrawFilled);
}
}
}
if (pHandle)
{
float normValue = getValueNormalized ();
if (style & kRight || style & kBottom)
normValue = 1.f - normValue;
// calc new coords of slider
CRect rectNew;
if (style & kHorizontal)
{
rectNew.top = offsetHandle.y;
rectNew.bottom = rectNew.top + heightOfSlider;
rectNew.left = offsetHandle.x + floor (normValue * rangeHandle);
rectNew.left = (rectNew.left < minTmp) ? minTmp : rectNew.left;
rectNew.right = rectNew.left + widthOfSlider;
rectNew.right = (rectNew.right > maxTmp) ? maxTmp : rectNew.right;
}
else
{
rectNew.left = offsetHandle.x;
rectNew.right = rectNew.left + widthOfSlider;
rectNew.top = offsetHandle.y + floor (normValue * rangeHandle);
rectNew.top = (rectNew.top < minTmp) ? minTmp : rectNew.top;
rectNew.bottom = rectNew.top + heightOfSlider;
rectNew.bottom = (rectNew.bottom > maxTmp) ? maxTmp : rectNew.bottom;
}
rectNew.offset (getViewSize ().left, getViewSize ().top);
// draw slider at new position
pHandle->draw (drawContext, rectNew);
}
setDirty (false);
}
//------------------------------------------------------------------------
void CCheckBox::draw (CDrawContext* context)
{
float norm = getValueNormalized ();
CRect checkBoxSize (getViewSize ());
if (getDrawBackground ())
{
CPoint off;
checkBoxSize.setWidth (getDrawBackground ()->getWidth ());
checkBoxSize.setHeight (getDrawBackground ()->getHeight () / 6);
if (norm == 0.5)
off.y = checkBoxSize.getHeight ();
else if (norm > 0.5)
off.y = checkBoxSize.getHeight () * 2;
else
off.y = 0;
if (hilight)
off.y += getDrawBackground ()->getHeight () / 2;
getDrawBackground ()->draw (context, checkBoxSize, off);
}
else
{
checkBoxSize.setHeight (getFontCapHeight (font) + 2);
checkBoxSize.setWidth (checkBoxSize.getHeight ());
checkBoxSize.offset (1, ceil ((getViewSize ().getHeight () - checkBoxSize.getHeight ()) / 2));
checkBoxSize.makeIntegral ();
context->setLineWidth (1);
context->setLineStyle (kLineSolid);
context->setDrawMode (kAliasing);
context->setFrameColor (boxFrameColor);
context->setFillColor (boxFillColor);
context->drawRect (checkBoxSize, kDrawFilledAndStroked);
if (hilight)
{
CColor hilightColor = boxFrameColor;
hilightColor.alpha /= 2;
context->setFrameColor (hilightColor);
CRect r (checkBoxSize);
r.inset (1, 1);
context->drawRect (r, kDrawStroked);
}
context->setDrawMode (kAntiAliasing);
context->setFrameColor (checkMarkColor);
context->setLineWidth (2);
const CCoord cbInset = 2;
if (style & kDrawCrossBox)
{
if (norm == 0.5f)
{
context->moveTo (CPoint (checkBoxSize.left + cbInset, checkBoxSize.top + checkBoxSize.getHeight () / 2));
context->lineTo (CPoint (checkBoxSize.right - cbInset, checkBoxSize.top + checkBoxSize.getHeight () / 2));
}
else if (norm > 0.5f)
{
context->moveTo (CPoint (checkBoxSize.left + cbInset, checkBoxSize.top + cbInset));
context->lineTo (CPoint (checkBoxSize.right - cbInset, checkBoxSize.bottom - cbInset));
context->moveTo (CPoint (checkBoxSize.left + cbInset, checkBoxSize.bottom - cbInset));
context->lineTo (CPoint (checkBoxSize.right - cbInset, checkBoxSize.top + cbInset));
}
}
else
{
context->moveTo (CPoint (checkBoxSize.left + cbInset, checkBoxSize.top + checkBoxSize.getHeight () / 2));
if (norm == 0.5f)
{
context->lineTo (CPoint (checkBoxSize.right - cbInset, checkBoxSize.top + checkBoxSize.getHeight () / 2));
}
else if (norm > 0.5f)
{
context->lineTo (CPoint (checkBoxSize.left + checkBoxSize.getWidth () / 2, checkBoxSize.bottom - cbInset));
context->lineTo (CPoint (checkBoxSize.right + 1, checkBoxSize.top - 1));
}
}
}
if (title)
{
CPoint p (checkBoxSize.getBottomRight ());
p.offset (kCheckBoxTitleMargin, -1);
context->setFont (font);
context->setFontColor (fontColor);
context->drawString (title, p, true);
}
setDirty (false);
}
