diff options
Diffstat (limited to 'vendor/vstsdk2.4/vstgui.sf/vstgui/vstcontrols.cpp')
| -rw-r--r-- | vendor/vstsdk2.4/vstgui.sf/vstgui/vstcontrols.cpp | 5516 |
1 files changed, 5516 insertions, 0 deletions
diff --git a/vendor/vstsdk2.4/vstgui.sf/vstgui/vstcontrols.cpp b/vendor/vstsdk2.4/vstgui.sf/vstgui/vstcontrols.cpp new file mode 100644 index 0000000..ba164d9 --- /dev/null +++ b/vendor/vstsdk2.4/vstgui.sf/vstgui/vstcontrols.cpp @@ -0,0 +1,5516 @@ +//----------------------------------------------------------------------------- +// VST Plug-Ins SDK +// VSTGUI: Graphical User Interface Framework for VST plugins : +// Standard Control Objects +// +// Version 3.0 $Date: 2006/02/09 10:18:20 $ +// +// Added new objects : Michael Schmidt 08.97 +// Added new objects : Yvan Grabit 01.98 +// Added BeOS version : Georges-Edouard Berenger 05.99 +// Added MacOSX version : Arne Scheffler 02.03 +// +//----------------------------------------------------------------------------- +// VSTGUI LICENSE +// © 2004, Steinberg Media Technologies, All Rights Reserved +//----------------------------------------------------------------------------- +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of the Steinberg Media Technologies nor the names of its +// contributors may be used to endorse or promote products derived from this +// software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED +// OF THE POSSIBILITY OF SUCH DAMAGE. +//----------------------------------------------------------------------------- + +#include <stdio.h> +#include <stdlib.h> +#include <math.h> +#include <string.h> + +#ifndef __vstcontrols__ +#include "vstcontrols.h" +#endif + +#include "vstkeycode.h" + +#if (__MACH__ && __MWERKS__) + #ifndef cosf + #define cosf (float)cos + #endif + + #ifndef sinf + #define sinf (float)sin + #endif +#endif + +BEGIN_NAMESPACE_VSTGUI + +// some external variables (vstgui.cpp) +extern long gStandardFontSize []; +extern const char *gStandardFontName []; + +//------------------------------------------------------------------------ +// CControl +//------------------------------------------------------------------------ +/*! @class CControl +This object manages the tag identification and the value of a control object. + +Note: +Since version 2.1, when an object uses the transparency for its background and draws on it (tranparency area) +or the transparency area changes during different draws (CMovieBitmap ,...), the background will be false (not updated), +you have to rewrite the draw function in order to redraw the background and then call the draw of the object. +*/ +CControl::CControl (const CRect &size, CControlListener *listener, long tag, + CBitmap *pBackground) +: CView (size), + listener (listener), tag (tag), oldValue (1), defaultValue (0.5f), + value (0), vmin (0), vmax (1.f), wheelInc (0.1f), lastTicks (-1) +{ + #if WINDOWS + delta = GetDoubleClickTime (); + #elif MAC + delta = GetDblTime (); + #else + delta = 500; + #endif + + if (delta < 250) + delta = 250; + + setTransparency (false); + setMouseEnabled (true); + backOffset (0 ,0); + + setBackground (pBackground); +} + +//------------------------------------------------------------------------ +CControl::~CControl () +{ +} + +//------------------------------------------------------------------------ +void CControl::beginEdit () +{ + // begin of edit parameter + getFrame ()->setFocusView(this); + getFrame ()->beginEdit (tag); +} + +//------------------------------------------------------------------------ +void CControl::endEdit () +{ + // end of edit parameter + getFrame ()->endEdit (tag); +} + +//------------------------------------------------------------------------ +bool CControl::isDirty () const +{ + if (oldValue != value || CView::isDirty ()) + return true; + return false; +} + +//------------------------------------------------------------------------ +void CControl::setDirty (const bool val) +{ + CView::setDirty (val); + if (val) + { + if (value != -1.f) + oldValue = -1.f; + else + oldValue = 0.f; + } + else + oldValue = value; +} + +//------------------------------------------------------------------------ +void CControl::setBackOffset (CPoint &offset) +{ + backOffset = offset; +} + +//----------------------------------------------------------------------------- +void CControl::copyBackOffset () +{ + backOffset (size.left, size.top); +} + +//------------------------------------------------------------------------ +void CControl::bounceValue () +{ + if (value > vmax) + value = vmax; + else if (value < vmin) + value = vmin; +} + +//----------------------------------------------------------------------------- +bool CControl::checkDefaultValue (CDrawContext *pContext, long button) +{ + if (button == (kControl|kLButton)) + { + // begin of edit parameter + beginEdit (); + + value = getDefaultValue (); + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + return true; + } + return false; +} + +//----------------------------------------------------------------------------- +bool CControl::isDoubleClick () +{ + long ticks = getFrame ()->getTicks (); + if (lastTicks <= 0) + { + lastTicks = ticks; + return false; + } + + if (lastTicks + delta > ticks) + lastTicks = 0; + else + { + lastTicks = ticks; + return false; + } + return true; +} + +//------------------------------------------------------------------------ +// COnOffButton +//------------------------------------------------------------------------ +/*! @class COnOffButton +Define a button with 2 positions. +The pixmap includes the 2 subpixmaps (i.e the rectangle used for the display of this button is half-height of the pixmap). +When its value changes, the listener is called. +*/ +COnOffButton::COnOffButton (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, long style) +: CControl (size, listener, tag, background) +, style (style) +{} + +//------------------------------------------------------------------------ +COnOffButton::~COnOffButton () +{} + +//------------------------------------------------------------------------ +void COnOffButton::draw (CDrawContext *pContext) +{ + CCoord off; + + if (value && pBackground) + off = pBackground->getHeight () / 2; + else + off = 0; + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, CPoint (0, off)); + else + pBackground->draw (pContext, size, CPoint (0, off)); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void COnOffButton::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + if (!(button & kLButton)) + return; + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + value = ((long)value) ? 0.f : 1.f; + + if (listener && style == kPostListenerUpdate) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + } + + doIdleStuff (); + + if (listener && style == kPreListenerUpdate) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + } +} + + +//------------------------------------------------------------------------ +// CKnob +//------------------------------------------------------------------------ +/*! @class CKnob +Define a knob with a given background and foreground handle. +The handle describes a circle over the background (between -45deg and +225deg). +By clicking Alt+Left Mouse the default value is used. +By clicking Alt+Left Mouse the value changes with a vertical move (version 2.1) +*/ +CKnob::CKnob (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CBitmap *handle, const CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), pHandle (handle) +{ + if (pHandle) + { + pHandle->remember (); + inset = (long)((float)pHandle->getWidth () / 2.f + 2.5f); + } + else + inset = 3; + + colorShadowHandle = kGreyCColor; + colorHandle = kWhiteCColor; + radius = (float)(size.right - size.left) / 2.f; + + rangeAngle = 1.f; + setStartAngle ((float)(5.f * kPI / 4.f)); + setRangeAngle ((float)(-3.f * kPI / 2.f)); + zoomFactor = 1.5f; + + setWantsFocus (true); +} + +//------------------------------------------------------------------------ +CKnob::~CKnob () +{ + if (pHandle) + pHandle->forget (); +} + +//------------------------------------------------------------------------ +void CKnob::draw (CDrawContext *pContext) +{ + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, offset); + else + pBackground->draw (pContext, size, offset); + } + drawHandle (pContext); + setDirty (false); +} + +//------------------------------------------------------------------------ +void CKnob::drawHandle (CDrawContext *pContext) +{ + CPoint where; + valueToPoint (where); + + if (pHandle) + { + long width = (long)pHandle->getWidth (); + long height = (long)pHandle->getHeight (); + where.offset (size.left - width / 2, size.top - height / 2); + + CRect handleSize (0, 0, width, height); + handleSize.offset (where.h, where.v); + pHandle->drawTransparent (pContext, handleSize); + } + else + { + CPoint origin (size.width () / 2, size.height () / 2); + + where.offset (size.left - 1, size.top); + origin.offset (size.left - 1, size.top); + pContext->setFrameColor (colorShadowHandle); + pContext->moveTo (where); + pContext->lineTo (origin); + + where.offset (1, -1); + origin.offset (1, -1); + pContext->setFrameColor (colorHandle); + pContext->moveTo (where); + pContext->lineTo (origin); + } +} + +//------------------------------------------------------------------------ +void CKnob::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + if (!(button & kLButton)) + return; + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + // check if default value wanted + if (checkDefaultValue (pContext, button)) + return; + + float old = oldValue; + CPoint firstPoint; + bool modeLinear = false; + float fEntryState = value; + float middle = (vmax - vmin) * 0.5f; + float range = 200.f; + float coef = (vmax - vmin) / range; + long oldButton = button; + + long mode = kCircularMode; + long newMode = getFrame ()->getKnobMode (); + if (kLinearMode == newMode) + { + if (!(button & kAlt)) + mode = newMode; + } + else if (button & kAlt) + mode = kLinearMode; + + if (mode == kLinearMode && (button & kLButton)) + { + if (button & kShift) + range *= zoomFactor; + firstPoint = where; + modeLinear = true; + coef = (vmax - vmin) / range; + } + else + { + CPoint where2 (where); + where2.offset (-size.left, -size.top); + old = valueFromPoint (where2); + } + + CPoint oldWhere (-1, -1); + + // begin of edit parameter + beginEdit (); + do + { + button = pContext->getMouseButtons (); + if (where != oldWhere) + { + oldWhere = where; + if (modeLinear) + { + CCoord diff = (firstPoint.v - where.v) + (where.h - firstPoint.h); + if (button != oldButton) + { + range = 200.f; + if (button & kShift) + range *= zoomFactor; + + float coef2 = (vmax - vmin) / range; + fEntryState += diff * (coef - coef2); + coef = coef2; + oldButton = button; + } + value = fEntryState + diff * coef; + bounceValue (); + } + else + { + where.offset (-size.left, -size.top); + value = valueFromPoint (where); + if (old - value > middle) + value = vmax; + else if (value - old > middle) + value = vmin; + else + old = value; + } + if (isDirty () && listener) + listener->valueChanged (pContext, this); + } + getMouseLocation (pContext, where); + doIdleStuff (); + + } while (button & kLButton); + + // end of edit parameter + endEdit (); +} + +//------------------------------------------------------------------------ +bool CKnob::onWheel (CDrawContext *pContext, const CPoint &where, float distance) +{ + if (!bMouseEnabled) + return false; + + long buttons = pContext->getMouseButtons (); + if (buttons & kShift) + value += 0.1f * distance * wheelInc; + else + value += distance * wheelInc; + bounceValue (); + + if (isDirty () && listener) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + } + return true; +} + +//------------------------------------------------------------------------ +long CKnob::onKeyDown (VstKeyCode& keyCode) +{ + switch (keyCode.virt) + { + case VKEY_UP : + case VKEY_RIGHT : + case VKEY_DOWN : + case VKEY_LEFT : + { + float distance = 1.f; + if (keyCode.virt == VKEY_DOWN || keyCode.virt == VKEY_LEFT) + distance = -distance; + + if (keyCode.modifier & MODIFIER_SHIFT) + value += 0.1f * distance * wheelInc; + else + value += distance * wheelInc; + bounceValue (); + + if (isDirty () && listener) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (0, this); + + // end of edit parameter + endEdit (); + } + } return 1; + } + return -1; +} + +//------------------------------------------------------------------------ +void CKnob::setStartAngle (float val) +{ + startAngle = val; + compute (); +} + +//------------------------------------------------------------------------ +void CKnob::setRangeAngle (float val) +{ + rangeAngle = val; + compute (); +} + +//------------------------------------------------------------------------ +void CKnob::compute () +{ + aCoef = (vmax - vmin) / rangeAngle; + bCoef = vmin - aCoef * startAngle; + halfAngle = ((float)k2PI - fabsf (rangeAngle)) * 0.5f; + setDirty (); +} + +//------------------------------------------------------------------------ +void CKnob::valueToPoint (CPoint &point) const +{ + float alpha = (value - bCoef) / aCoef; + point.h = (long)(radius + cosf (alpha) * (radius - inset) + 0.5f); + point.v = (long)(radius - sinf (alpha) * (radius - inset) + 0.5f); +} + +//------------------------------------------------------------------------ +float CKnob::valueFromPoint (CPoint &point) const +{ + float v; + float alpha = (float)atan2 (radius - point.v, point.h - radius); + if (alpha < 0.f) + alpha += (float)k2PI; + + float alpha2 = alpha - startAngle; + if (rangeAngle < 0) + { + alpha2 -= rangeAngle; + float alpha3 = alpha2; + if (alpha3 < 0.f) + alpha3 += (float)k2PI; + else if (alpha3 > k2PI) + alpha3 -= (float)k2PI; + if (alpha3 > halfAngle - rangeAngle) + v = vmax; + else if (alpha3 > -rangeAngle) + v = vmin; + else + { + if (alpha2 > halfAngle - rangeAngle) + alpha2 -= (float)k2PI; + else if (alpha2 < -halfAngle) + alpha2 += (float)k2PI; + v = aCoef * alpha2 + vmax; + } + } + else + { + float alpha3 = alpha2; + if (alpha3 < 0.f) + alpha3 += (float)k2PI; + else if (alpha3 > k2PI) + alpha3 -= (float)k2PI; + if (alpha3 > rangeAngle + halfAngle) + v = vmin; + else if (alpha3 > rangeAngle) + v = vmax; + else + { + if (alpha2 > rangeAngle + halfAngle) + alpha2 -= (float)k2PI; + else if (alpha2 < -halfAngle) + alpha2 += (float)k2PI; + v = aCoef * alpha2 + vmin; + } + } + + return v; +} + +//------------------------------------------------------------------------ +void CKnob::setColorShadowHandle (CColor color) +{ + colorShadowHandle = color; + setDirty (); +} + +//------------------------------------------------------------------------ +void CKnob::setColorHandle (CColor color) +{ + colorHandle = color; + setDirty (); +} + +//------------------------------------------------------------------------ +void CKnob::setHandleBitmap (CBitmap *bitmap) +{ + if (pHandle) + { + pHandle->forget (); + pHandle = 0; + } + + if (bitmap) + { + pHandle = bitmap; + pHandle->remember (); + inset = (long)((float)pHandle->getWidth () / 2.f + 2.5f); + } +} + + +//------------------------------------------------------------------------ +// CParamDisplay +//------------------------------------------------------------------------ +/*! @class CParamDisplay +Define a rectangle view where a text-value can be displayed with a given font and color. +The user can specify its convert function (from float to char) by default the string format is "%2.2f". +The text-value is centered in the given rect. +*/ +CParamDisplay::CParamDisplay (const CRect &size, CBitmap *background, const long style) +: CControl (size, 0, 0, background), stringConvert (0), stringConvert2 (0), string2FloatConvert (0), + horiTxtAlign (kCenterText), style (style), bTextTransparencyEnabled (true) +{ + backOffset (0, 0); + + fontID = kNormalFont; + txtFace = kNormalFace; + fontColor = kWhiteCColor; + backColor = kBlackCColor; + frameColor = kBlackCColor; + shadowColor = kRedCColor; + userData = 0; + if (style & kNoDrawStyle) + setDirty (false); +} + +//------------------------------------------------------------------------ +CParamDisplay::~CParamDisplay () +{} + +//------------------------------------------------------------------------ +void CParamDisplay::setStyle (long val) +{ + if (style != val) + { + style = val; + setDirty (); + } +} + +//------------------------------------------------------------------------ +void CParamDisplay::draw (CDrawContext *pContext) +{ + char string[256]; + string[0] = 0; + + if (stringConvert2) + stringConvert2 (value, string, userData); + else if (stringConvert) + stringConvert (value, string); + else + sprintf (string, "%2.2f", value); + + drawText (pContext, string); +} + +//------------------------------------------------------------------------ +void CParamDisplay::drawText (CDrawContext *pContext, char *string, CBitmap *newBack) +{ + setDirty (false); + + if (style & kNoDrawStyle) + return; + + // draw the background + if (newBack) + { + if (bTransparencyEnabled) + newBack->drawTransparent (pContext, size, backOffset); + else + newBack->draw (pContext, size, backOffset); + } + else if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, backOffset); + else + pBackground->draw (pContext, size, backOffset); + } + else + { + if (!bTransparencyEnabled) + { + pContext->setFillColor (backColor); + pContext->fillRect (size); + + if (!(style & (k3DIn|k3DOut|kNoFrame))) + { + pContext->setFrameColor (frameColor); + pContext->drawRect (size); + } + } + } + // draw the frame for the 3D effect + if (style & (k3DIn|k3DOut)) + { + CRect r (size); + r.right--; r.top++; + r.bottom--; + pContext->setLineWidth (1); + if (style & k3DIn) + pContext->setFrameColor (backColor); + else + pContext->setFrameColor (frameColor); + CPoint p; + pContext->moveTo (p (r.left, r.bottom)); + pContext->lineTo (p (r.left, r.top)); + pContext->lineTo (p (r.right, r.top)); + + if (style & k3DIn) + pContext->setFrameColor (frameColor); + else + pContext->setFrameColor (backColor); + pContext->moveTo (p (r.right, r.top)); + pContext->lineTo (p (r.right, r.bottom)); + pContext->lineTo (p (r.left, r.bottom)); + } + + if (!(style & kNoTextStyle) && string) + { + CRect oldClip; + pContext->getClipRect (oldClip); + CRect newClip (size); + newClip.bound (oldClip); + pContext->setClipRect (newClip); + pContext->setFont (fontID, 0, txtFace); + + // draw darker text (as shadow) + if (style & kShadowText) + { + CRect newSize (size); + newSize.offset (1, 1); + pContext->setFontColor (shadowColor); + pContext->drawString (string, newSize, !bTextTransparencyEnabled, horiTxtAlign); + } + pContext->setFontColor (fontColor); + pContext->drawString (string, size, !bTextTransparencyEnabled, horiTxtAlign); + pContext->setClipRect (oldClip); + } +} + +//------------------------------------------------------------------------ +void CParamDisplay::setFont (CFont fontID) +{ + // to force the redraw + if (this->fontID != fontID) + setDirty (); + this->fontID = fontID; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setTxtFace (CTxtFace txtFace) +{ + // to force the redraw + if (this->txtFace != txtFace) + setDirty (); + this->txtFace = txtFace; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setFontColor (CColor color) +{ + // to force the redraw + if (fontColor != color) + setDirty (); + fontColor = color; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setBackColor (CColor color) +{ + // to force the redraw + if (backColor != color) + setDirty (); + backColor = color; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setFrameColor (CColor color) +{ + // to force the redraw + if (frameColor != color) + setDirty (); + frameColor = color; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setShadowColor (CColor color) +{ + // to force the redraw + if (shadowColor != color) + setDirty (); + shadowColor = color; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setHoriAlign (CHoriTxtAlign hAlign) +{ + // to force the redraw + if (horiTxtAlign != hAlign) + setDirty (); + horiTxtAlign = hAlign; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setStringConvert (void (*convert) (float value, char *string)) +{ + stringConvert = convert; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setStringConvert (void (*convert) (float value, char *string, + void *userDta), void *userData) +{ + stringConvert2 = convert; + this->userData = userData; +} + +//------------------------------------------------------------------------ +void CParamDisplay::setString2FloatConvert (void (*convert) (char *string, float &output)) +{ + string2FloatConvert = convert; +} + +//------------------------------------------------------------------------ +// CTextLabel +//------------------------------------------------------------------------ +/*! @class CTextLabel +*/ +CTextLabel::CTextLabel (const CRect& size, const char* txt, CBitmap* background, const long style) +: CParamDisplay (size, background, style) +, text (0) +{ + setText (txt); +} + +//------------------------------------------------------------------------ +CTextLabel::~CTextLabel () +{ + freeText (); +} + +//------------------------------------------------------------------------ +void CTextLabel::freeText () +{ + if (text) + free (text); + text = 0; +} + +//------------------------------------------------------------------------ +void CTextLabel::setText (const char* txt) +{ + freeText (); + if (txt) + { + text = (char*)malloc (strlen (txt)+1); + strcpy (text, txt); + } +} + +//------------------------------------------------------------------------ +const char* CTextLabel::getText () const +{ + return text; +} + +//------------------------------------------------------------------------ +void CTextLabel::draw (CDrawContext *pContext) +{ + drawText (pContext, text); + setDirty (false); +} + + +//------------------------------------------------------------------------ +// CTextEdit +//------------------------------------------------------------------------ +/*! @class CTextEdit +Define a rectangle view where a text-value can be displayed and edited with a given font and color. +The user can specify its convert function (from char to char). The text-value is centered in the given rect. +A pixmap can be used as background. +*/ +CTextEdit::CTextEdit (const CRect &size, CControlListener *listener, long tag, + const char *txt, CBitmap *background, const long style) +: CParamDisplay (size, background, style), platformFontColor (0), platformControl (0), + platformFont (0), editConvert (0), editConvert2 (0) +{ +#if (MAC && !MACX) + text_edit = 0; +#endif + this->listener = listener; + this->tag = tag; + + if (txt) + strcpy (text, txt); + else + strcpy (text, ""); +#if MAC + // remember our VST plugin's resource map ID (it should be the current one at this moment) + pluginResID = CurResFile(); +#endif +#if QUARTZ + textControl = 0; +#endif + setWantsFocus (true); +} + +//------------------------------------------------------------------------ +CTextEdit::~CTextEdit () +{} + +//------------------------------------------------------------------------ +void CTextEdit::setText (char *txt) +{ + if (txt) + { + if (strcmp (text, txt)) + { + strcpy (text, txt); + + // to force the redraw + setDirty (); + } + } + else + { + if (strcmp (text, "")) + { + strcpy (text, ""); + + // to force the redraw + setDirty (); + } + } +} + +//------------------------------------------------------------------------ +void CTextEdit::getText (char *txt) const +{ + if (txt) + strcpy (txt, text); +} + +//------------------------------------------------------------------------ +void CTextEdit::draw (CDrawContext *pContext) +{ + if (platformControl) + { + #if MACX + #if QUARTZ + if (textControl) + { + HIViewSetNeedsDisplay (textControl, true); + } + else + #endif + TXNDraw ((TXNObject)platformControl, NULL); + #endif + setDirty (false); + return; + } + + char string[256]; + string[0] = 0; + + if (editConvert2) + editConvert2 (text, string, userData); + else if (editConvert) + editConvert (text, string); + // Allow to display strings through the stringConvert + // callbacks inherited from CParamDisplay + else if (stringConvert2) + { + string[0] = 0; + stringConvert2 (value, string, userData); + strcpy(text, string); + } + else if (stringConvert) + { + string[0] = 0; + stringConvert (value, string); + strcpy(text, string); + } + else + sprintf (string, "%s", text); + + drawText (pContext, string); + setDirty (false); +} + +//------------------------------------------------------------------------ +void CTextEdit::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (button & kLButton) + { + if (getFrame ()->getFocusView () != this) + { + if (style & kDoubleClickStyle) + if (!isDoubleClick ()) + return; + + beginEdit(); + takeFocus (pContext); + } + } +} + +//------------------------------------------------------------------------ +#if WINDOWS +#define WIN32_LEAN_AND_MEAN 1 +#include <windows.h> + +END_NAMESPACE_VSTGUI + +#if PLUGGUI + extern HINSTANCE ghInst; + inline HINSTANCE GetInstance () { return ghInst; } +#else + extern void* hInstance; + inline HINSTANCE GetInstance () { return (HINSTANCE)hInstance; } +#endif + +BEGIN_NAMESPACE_VSTGUI + +extern long standardFontSize []; +extern const char *standardFontName []; + +#ifdef STRICT +#define WINDOWSPROC WNDPROC +#else +#define WINDOWSPROC FARPROC +#endif + +static WINDOWSPROC oldWndProcEdit; +LONG_PTR WINAPI WindowProcEdit (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam); +LONG_PTR WINAPI WindowProcEdit (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + switch (message) + { + case WM_GETDLGCODE : + { + long flags = DLGC_WANTALLKEYS; + return flags; + } + + case WM_KEYDOWN: + { + if (wParam == VK_RETURN) + { + CTextEdit *textEdit = (CTextEdit*) GetWindowLongPtr (hwnd, GWLP_USERDATA); + if (textEdit) + { + textEdit->bWasReturnPressed = true; + textEdit->looseFocus (); + } + } + } break; + + case WM_KILLFOCUS: + { + CTextEdit *textEdit = (CTextEdit*) GetWindowLongPtr (hwnd, GWLP_USERDATA); + if (textEdit) + textEdit->looseFocus (); + } break; + } + + return CallWindowProc (oldWndProcEdit, hwnd, message, wParam, lParam); +} + +//------------------------------------------------------------------------ +#elif MOTIF +#include <Xm/Text.h> +extern XFontStruct *gFontStructs[]; +#endif + +//------------------------------------------------------------------------ +#if BEOS +#include <TextView.h> +#include <Window.h> + +class BeTextView : public BTextView +{ +public: + BeTextView (CTextEdit* cTextEdit, BRect frame, + const char *name, BRect textRect); + void MakeFocus (bool focusState = true); + void KeyDown (const char *bytes, int32 numBytes); +private: + CTextEdit *cTextEdit; +}; + +//------------------------------------------------------------------------ +BeTextView::BeTextView (CTextEdit* cTextEdit, BRect frame, const char *name, BRect textRect) +: BTextView (frame, name, textRect, B_FOLLOW_NONE), cTextEdit (cTextEdit) +{} + +//------------------------------------------------------------------------ +void BeTextView::MakeFocus (bool focusState) +{ + BTextView::MakeFocus (focusState); + if (!focusState && cTextEdit) + cTextEdit->looseFocus (); +} + +//------------------------------------------------------------------------ +void BeTextView::KeyDown (const char *bytes, int32 numBytes) +{ + if (cTextEdit && (bytes[0] == B_RETURN || bytes[0] == B_TAB)) + cTextEdit->looseFocus (); + else + BTextView::KeyDown (bytes, numBytes); +} +#endif + +#if MACX +static EventHandlerRef gTextEditEventHandler = 0; +static bool gTextEditCanceled = false; +pascal OSStatus CarbonEventsTextControlProc (EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData); +pascal OSStatus CarbonEventsTextControlProc (EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) +{ + OSStatus result = eventNotHandledErr; + UInt32 eventClass = GetEventClass (inEvent); + UInt32 eventKind = GetEventKind (inEvent); + CTextEdit* textEdit = (CTextEdit*)inUserData; + + switch (eventClass) + { + case kEventClassKeyboard: + { + switch (eventKind) + { + case kEventRawKeyDown: + case kEventRawKeyRepeat: + { + char macCharCode; + UInt32 keyCode; + UInt32 modifiers; + GetEventParameter (inEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof (char), NULL, &macCharCode); + GetEventParameter (inEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof (UInt32), NULL, &keyCode); + GetEventParameter (inEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof (UInt32), NULL, &modifiers); + if (macCharCode == 13 || macCharCode == 3 || macCharCode == 27) + { + if (macCharCode == 27) + gTextEditCanceled = true; + else + textEdit->bWasReturnPressed = true; + + WindowRef window = (WindowRef) (textEdit->getFrame ()->getSystemWindow()); + GrafPtr savedPort; + bool portChanged = window ? QDSwapPort (GetWindowPort (window), &savedPort) : false; + + // remember the current resource map ID + short currentResID = CurResFile(); + short vstResFileID = textEdit->pluginResID; + // if it's different (and if it's valid), set the current resource map ID to our plugin's resource map + if ( (vstResFileID != currentResID) && (vstResFileID > 0) ) + UseResFile(vstResFileID); + + textEdit->looseFocus (); + + // revert the window port, if we changed it + if (portChanged) + QDSwapPort (savedPort, NULL); + // revert the current resource map, if we changed it + if ( (currentResID > 0) && (vstResFileID != currentResID) && (vstResFileID > 0) ) + UseResFile(currentResID); + + result = noErr; + } + #if QUARTZ + else if (textEdit->textControl) + break; + #endif + else if (modifiers & cmdKey) + { + result = noErr; + TXNObject text_edit = (TXNObject) (textEdit->platformControl); + switch (toupper(macCharCode)) + { + // copy + case 'C': + if (!TXNIsSelectionEmpty(text_edit)) + { + OSStatus scrapErr = ClearCurrentScrap(); + scrapErr = TXNCopy(text_edit); + result = noErr; + } + break; + // cut + case 'X': + if (!TXNIsSelectionEmpty(text_edit)) + { + OSStatus scrapErr = ClearCurrentScrap(); + scrapErr = TXNCut(text_edit); + result = noErr; + } + break; + // paste + case 'V': + TXNPaste(text_edit); + result = noErr; + break; + + // select all + case 'A': + TXNSelectAll(text_edit); + break; + + default: + break; + } + } + else + { + EventRecord eventRecord; + if (ConvertEventRefToEventRecord (inEvent, &eventRecord)) + TXNKeyDown ((TXNObject)textEdit->platformControl, &eventRecord); + result = noErr; + } + break; + } + } + break; + } + case kEventClassMouse: + { + switch (eventKind) + { + case kEventMouseDown: + case kEventMouseUp: + { + WindowRef window; + GetEventParameter (inEvent, kEventParamWindowRef, typeWindowRef, NULL, sizeof (WindowRef), NULL, &window); + HIPoint p; + GetEventParameter (inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof (HIPoint), NULL, &p); + Point point = {(short)p.y, (short)p.x}; + QDGlobalToLocalPoint (GetWindowPort (window), &point); + Rect rect; + TXNGetViewRect ((TXNObject)textEdit->platformControl, &rect); + if (PtInRect (point, &rect)) + { + EventRecord eventRecord; + if (eventKind == kEventMouseDown && ConvertEventRefToEventRecord (inEvent, &eventRecord)) + TXNClick ((TXNObject)textEdit->platformControl, &eventRecord); + result = noErr; + } + break; + } + case kEventMouseMoved: + { + TXNAdjustCursor ((TXNObject)textEdit->platformControl, NULL); + break; + } + } + break; + } + case kEventClassWindow: + { + WindowRef window; + if (GetEventParameter (inEvent, kEventParamDirectObject, typeWindowRef, NULL, sizeof (WindowRef), NULL, &window) != noErr) + break; + switch (eventKind) + { + case kEventWindowDeactivated: + { + result = CallNextEventHandler (inHandlerCallRef, inEvent); + ClearKeyboardFocus (window); + + // set up the correct drawing port for the window + GrafPtr savedPort; + bool portChanged = QDSwapPort (GetWindowPort (window), &savedPort); + + // remember the current resource map ID + short currentResID = CurResFile(); + short vstResFileID = textEdit->pluginResID; + // if it's different (and if it's valid), set the current resource map ID to our plugin's resource map + if ( (vstResFileID != currentResID) && (vstResFileID > 0) ) + UseResFile(vstResFileID); + + textEdit->looseFocus (); + + // revert the window port, if we changed it + if (portChanged) + QDSwapPort (savedPort, NULL); + // revert the current resource map, if we changed it + if ( (currentResID > 0) && (vstResFileID != currentResID) && (vstResFileID > 0) ) + UseResFile(currentResID); + + break; + } + } + break; + } + } + return result; +} +#endif + +#if MAC && CALL_NOT_IN_CARBON +#include <Scrap.h> +#include <ctype.h> +#define ClearCurrentScrap ZeroScrap +#endif + +//------------------------------------------------------------------------ +void CTextEdit::takeFocus (CDrawContext *pContext) +{ + bWasReturnPressed = false; + +#if WINDOWS || MACX + // calculate offset for CViewContainers + CRect rect (size); + CView* parent = getParentView (); + CRect vSize; + while (parent) + { + if (parent->notify (this, kMsgCheckIfViewContainer) == kMessageNotified) + { + parent->getViewSize (vSize); + rect.offset (vSize.left, vSize.top); + } + parent = parent->getParentView (); + } + if (pContext) + rect.offset (pContext->offset.h, pContext->offset.v); +#endif + +#if WINDOWS + int wstyle = 0; + if (horiTxtAlign == kLeftText) + wstyle |= ES_LEFT; + else if (horiTxtAlign == kRightText) + wstyle |= ES_RIGHT; + else + wstyle |= ES_CENTER; + + wstyle |= WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL; + platformControl = (void*)CreateWindow ( + "EDIT", text, wstyle, + rect.left, rect.top, rect.width ()/* + 1*/, rect.height ()/* + 1*/, + (HWND)getFrame ()->getSystemWindow (), NULL, GetInstance (), 0); + + // get/set the current font + LOGFONT logfont = {0}; + + long fontH = gStandardFontSize [fontID]; + if (fontH > rect.height () - 2) + fontH = rect.height () - 2; + + logfont.lfWeight = FW_NORMAL; + logfont.lfHeight = -fontH; + logfont.lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS; + strcpy (logfont.lfFaceName, gStandardFontName[fontID]); + + logfont.lfClipPrecision = CLIP_STROKE_PRECIS; + logfont.lfOutPrecision = OUT_STRING_PRECIS; + logfont.lfQuality = DEFAULT_QUALITY; + logfont.lfCharSet = ANSI_CHARSET; + + platformFont = (HANDLE)CreateFontIndirect (&logfont); + platformFontColor = 0; + + SetWindowLongPtr ((HWND)platformControl, GWLP_USERDATA, (LONG_PTR)this); + SendMessage ((HWND)platformControl, WM_SETFONT, (WPARAM)platformFont, true); + SendMessage ((HWND)platformControl, EM_SETMARGINS, EC_LEFTMARGIN|EC_RIGHTMARGIN, MAKELONG (0, 0)); + SendMessage ((HWND)platformControl, EM_SETSEL, 0, -1); + SendMessage ((HWND)platformControl, EM_LIMITTEXT, 255, 0); + SetFocus ((HWND)platformControl); + + oldWndProcEdit = (WINDOWSPROC)SetWindowLongPtr ((HWND)platformControl, GWLP_WNDPROC, (LONG_PTR)WindowProcEdit); + +#elif MAC +#if MACX + WindowRef window = (WindowRef)getFrame ()->getSystemWindow (); + #if QUARTZ + WindowAttributes winAttributes; + GetWindowAttributes (window, &winAttributes); + if (winAttributes & kWindowCompositingAttribute) + { + Rect r; + r.left = (short)rect.left;// + 2; + r.right = (short)rect.right;// - 4; + r.top = (short)rect.top;// + 2; + r.bottom = (short)rect.bottom;// - 4; + if (rect.getHeight () > gStandardFontSize [fontID]) + { + r.top = (short)(rect.top + rect.getHeight () / 2 - gStandardFontSize [fontID] / 2 + 1); + r.bottom = (short)(r.top + gStandardFontSize [fontID]); + } + if (CreateEditUnicodeTextControl (NULL, &r, NULL, false, NULL, &textControl) == noErr) + { + HIViewAddSubview ((HIViewRef)getFrame ()->getPlatformControl (), textControl); + HIViewSetFirstSubViewFocus ((HIViewRef)getFrame ()->getPlatformControl (), textControl); + HIViewAdvanceFocus ((HIViewRef)getFrame ()->getPlatformControl (), 0); + EventTypeSpec eventTypes[] = { { kEventClassWindow, kEventWindowDeactivated }, { kEventClassKeyboard, kEventRawKeyDown }, { kEventClassKeyboard, kEventRawKeyRepeat } }; + InstallControlEventHandler (textControl, CarbonEventsTextControlProc, GetEventTypeCount (eventTypes), eventTypes, this, &gTextEditEventHandler); + platformControl = textControl; + if (strlen (text) > 0) + { + CFStringRef textString = CFStringCreateWithCString (NULL, text, kCFStringEncodingUTF8); + if (textString) + { + SetControlData (textControl, kControlEditTextPart, kControlEditTextCFStringTag, sizeof (CFStringRef), &textString); + CFRelease (textString); + } + ControlEditTextSelectionRec selection; + selection.selStart = 0; + selection.selEnd = strlen (text); + SetControlData (textControl, kControlEditTextPart, kControlEditTextSelectionTag, sizeof (ControlEditTextSelectionRec), &selection); + } + Boolean singleLineStyle = true; + SetControlData (textControl, kControlEditTextPart, kControlEditTextSingleLineTag, sizeof (Boolean), &singleLineStyle); + ControlFontStyleRec fontStyle; + memset (&fontStyle, 0, sizeof (fontStyle)); + fontStyle.flags = kControlUseJustMask | kControlUseSizeMask | kControlUseFontMask; + switch (horiTxtAlign) + { + case kLeftText: fontStyle.just = teFlushLeft; break; + case kRightText: fontStyle.just = teFlushRight; break; + default: fontStyle.just = teCenter; break; + } + fontStyle.size = gStandardFontSize [fontID]; + extern const char* gMacXfontNames[]; + Str255 fontName; + CopyCStringToPascal ((const char*)gMacXfontNames[fontID], fontName); + GetFNum (fontName, &fontStyle.font); + SetControlData (textControl, kControlEditTextPart, kControlFontStyleTag, sizeof (fontStyle), &fontStyle); + HIViewSetVisible (textControl, true); + } + return; + } + if (pContext) + rect.offset (pContext->offsetScreen.h, pContext->offsetScreen.v); + #endif + static bool gTXNInititalized = false; + if (!gTXNInititalized) + { + TXNMacOSPreferredFontDescription defaults; // fontID, pointSize, encoding, and fontStyle + defaults.fontID = 0; + defaults.pointSize = kTXNDefaultFontSize; + defaults.encoding = CreateTextEncoding(kTextEncodingMacRoman, kTextEncodingDefaultVariant, kTextEncodingDefaultFormat); + defaults.fontStyle = kTXNDefaultFontStyle; + TXNInitOptions options = 0; + TXNInitTextension(&defaults, 1, options); + gTXNInititalized = true; + } + gTextEditCanceled = false; + TXNFrameOptions iFrameOptions = kTXNMonostyledTextMask | kTXNDisableDragAndDropMask | kTXNSingleLineOnlyMask; //kTXNNoKeyboardSyncMask | kTXNDisableDragAndDropMask | kTXNSingleLineOnlyMask | kTXNMonostyledTextMask; + TXNFrameID frameID = 0; + TXNObjectRefcon iRefCon = 0; + TXNObject object; + Rect r; + r.left = (short)rect.left; + r.right = (short)rect.right; + r.top = (short)rect.top; + r.bottom = (short)rect.bottom; + OSStatus err; + err = TXNNewObject (NULL, window, &r, iFrameOptions, kTXNTextEditStyleFrameType, kTXNSingleStylePerTextDocumentResType, kTXNMacOSEncoding, &object, &frameID, iRefCon); + if (err == noErr) + { + platformControl = object; + TXNSetFrameBounds ((TXNObject)platformControl, r.top, r.left, r.bottom, r.right, frameID); + + if (strlen (text) > 0) + TXNSetData ((TXNObject)platformControl, kTXNTextData, (void*)text, strlen (text), kTXNStartOffset, kTXNEndOffset); + // set background + extern void CColor2RGBColor (const CColor &cc, RGBColor &rgb); + RGBColor rgbBackColor = { 0, 0, 0}; + CColor2RGBColor (kWhiteCColor /*backColor*/, rgbBackColor); + RGBColor rgbTextColor = { 32767, 32767, 32767 }; + CColor2RGBColor (kBlackCColor /*fontColor*/, rgbTextColor); + RGBBackColor (&rgbBackColor); + RGBForeColor (&rgbTextColor); + TXNBackground txnBackground; + txnBackground.bgType = kTXNBackgroundTypeRGB; + txnBackground.bg.color = rgbBackColor; + TXNSetBackground ((TXNObject)platformControl, &txnBackground); + // set justification + TXNControlTag controlTag[1]; + TXNControlData controlData[1]; + SInt32 just; + switch (horiTxtAlign) + { + case kLeftText : just = kTXNFlushLeft; break; + case kRightText : just = kTXNFlushRight; break; + default : just = kTXNCenter; break; + } + controlTag[0] = kTXNJustificationTag; + controlData[0].sValue = just; + TXNSetTXNObjectControls ((TXNObject)platformControl, false, 1, controlTag, controlData); + // set font + TXNTypeAttributes attributes[3]; + // font name + extern const unsigned char* gMacXfontNames[]; + + short familyID; + #if QUARTZ + Str255 fontName; + CopyCStringToPascal ((const char*)gMacXfontNames[fontID], fontName); + GetFNum (fontName, &familyID); + #else + GetFNum (gMacXfontNames[fontID], &familyID); + #endif + + ATSUFontID fontNameID; + + ATSUFONDtoFontID (familyID, 0, &fontNameID); + + attributes[0].tag = kATSUFontTag; + attributes[0].size = sizeof(ATSUFontID); + attributes[0].data.dataPtr = &fontNameID; + // size + long fontSize = gStandardFontSize [fontID] << 16; // needs to be in Fixed format + attributes[1].tag = kTXNQDFontSizeAttribute; + attributes[1].size = kTXNFontSizeAttributeSize; + attributes[1].data.dataValue = fontSize; + // color + attributes[2].tag = kTXNQDFontColorAttribute; + attributes[2].size = kTXNQDFontColorAttributeSize; + attributes[2].data.dataPtr = &rgbTextColor; + + TXNSetTypeAttributes ((TXNObject)platformControl, 3, attributes, kTXNStartOffset, kTXNEndOffset); + + SetUserFocusWindow (window); + AdvanceKeyboardFocus (window); + TXNActivate ((TXNObject)platformControl, frameID, false); + TXNFocus ((TXNObject)platformControl, true); + EventTypeSpec eventTypes[] = { { kEventClassMouse, kEventMouseMoved }, { kEventClassMouse, kEventMouseDown }, { kEventClassMouse, kEventMouseUp }, { kEventClassWindow, kEventWindowDeactivated }, { kEventClassKeyboard, kEventRawKeyDown }, { kEventClassKeyboard, kEventRawKeyRepeat } }; + InstallWindowEventHandler (window, CarbonEventsTextControlProc, GetEventTypeCount (eventTypes), eventTypes, this, &gTextEditEventHandler); + TXNSelectAll ((TXNObject)platformControl); + + } + +#else + bool ende = false; + char c; + EventRecord theEvent; + Rect rect, vrect; + + platformControl = new char[256]; + + rect.left = size.left; + rect.right = size.right; + rect.top = size.top; + rect.bottom = size.bottom; + #if !TARGET_API_MAC_CARBON + rect.bottom++; + rect.right++; + #endif + + if (pContext) + { + rect.left += pContext->offset.h; + rect.right += pContext->offset.h; + rect.top += pContext->offset.v; + rect.bottom += pContext->offset.v; + } + vrect = rect; + + vrect.top++; + vrect.left++; + vrect.right--; + #if TARGET_API_MAC_CARBON + vrect.bottom--; + #endif + + RGBColor blackrgb = {0, 0, 0}; + RGBColor whitergb = {0xffff, 0xffff, 0xffff}; + RGBForeColor (&blackrgb); + RGBBackColor (&whitergb); + + EraseRect (&rect); + //FrameRect (&rect); // Dave + #if !TARGET_API_MAC_CARBON + InsetRect (&vrect, 0, -2); + #endif + + TextFont (kFontIDHelvetica); + TextSize (gStandardFontSize [fontID]); + + text_edit = TENew (&rect, &vrect); + + if (horiTxtAlign == kLeftText) + TESetAlignment (teJustLeft, (TEHandle)text_edit); + else if (horiTxtAlign == kRightText) + TESetAlignment (teJustRight, (TEHandle)text_edit); + else + TESetAlignment (teJustCenter, (TEHandle)text_edit); + + char string[256]; + strcpy (string, text); + TESetText (string, strlen (string), (TEHandle)text_edit); + TESetSelect (0, strlen (string), (TEHandle)text_edit); + TEUpdate (&(**(TEHandle)text_edit).viewRect, (TEHandle)text_edit); + TEActivate ((TEHandle)text_edit); + HLock ((Handle)text_edit); + + (**(TEHandle)text_edit).crOnly = -1; + + bLoosefocusWanted = false; + + while (!ende && !bLoosefocusWanted) + { + GetNextEvent (everyEvent, &theEvent); + switch (theEvent.what) + { + case nullEvent: + doIdleStuff (); + break; + case autoKey : + case keyDown : + RGBForeColor (&blackrgb); + RGBBackColor (&whitergb); + + c = theEvent.message & charCodeMask; + if (c == 13 || c == 3 || c == 27) + { + if (c == 13) + bWasReturnPressed = true; + ende = true; + } + else if (((theEvent.message >> 8) & 0xFF) == 0x75) + { + if ((**(TEHandle)text_edit).selEnd < (**(TEHandle)text_edit).teLength) + { + if (((**(TEHandle)text_edit).selEnd - (**(TEHandle)text_edit).selStart) > 1) + TEDelete ((TEHandle)text_edit); + else + TEKey (0x1D, (TEHandle)text_edit); + c = 8; + } + else + c = -1; + } + if (theEvent.modifiers & cmdKey) + { + switch (toupper(c)) + { + // copy + case 'C': + if ((**(TEHandle)text_edit).selEnd > (**(TEHandle)text_edit).selStart) + { + OSStatus scrapErr = ClearCurrentScrap(); + TECopy((TEHandle)text_edit); + if (scrapErr == noErr) + scrapErr = TEToScrap(); + } + break; + // cut + case 'X': + if ((**(TEHandle)text_edit).selEnd > (**(TEHandle)text_edit).selStart) + { + OSStatus scrapErr = ClearCurrentScrap(); + TECut((TEHandle)text_edit); + if (scrapErr == noErr) + scrapErr = TEToScrap(); + } + break; + // paste + case 'V': + { + OSErr scrapErr = TEFromScrap(); + TEPaste((TEHandle)text_edit); + } + break; + // select all + case 'A': + TESetSelect(0, (**(TEHandle)text_edit).teLength, (TEHandle)text_edit); + break; + default: + break; + } + } + else if (!ende) + TEKey (c, (TEHandle)text_edit); + break; + case mouseDown : + GlobalToLocal (&theEvent.where); + if (PtInRect (theEvent.where, &rect)) + { + bool shiftdown = (theEvent.modifiers & shiftKey) != 0; + TEClick (theEvent.where, shiftdown, (TEHandle)text_edit); + } + else + ende = true; + break; + } + } + CharsHandle h = TEGetText ((TEHandle)text_edit); + short length = (**(TEHandle)text_edit).teLength; + if (length > 255) + length = 255; + strncpy ((char*)platformControl, (char*)*h, length); + ((char*)platformControl)[length] = 0; + + HUnlock ((Handle)text_edit); + TEDeactivate ((TEHandle)text_edit); + TEDispose ((TEHandle)text_edit); + text_edit = 0; + looseFocus (); + +#endif +#elif MOTIF + // we have to add the Text to the parent !! + Dimension posX, posY; + Widget widget = (Widget)(getFrame ()->getSystemWindow ()); + XtVaGetValues (widget, XmNx, &posX, XmNy, &posY, 0); + + Arg args[20]; + int n = 0; + XtSetArg (args[n], XmNx, size.left + posX); n++; + XtSetArg (args[n], XmNy, size.top + posY); n++; + XtSetArg (args[n], XmNwidth, size.width () + 1); n++; + XtSetArg (args[n], XmNheight, size.height () + 2); n++; + + XtSetArg (args[n], XmNvalue, text); n++; + + XtSetArg (args[n], XmNshadowType, XmSHADOW_IN); n++; + XtSetArg (args[n], XmNshadowThickness, 0); n++; + XtSetArg (args[n], XmNcursorPositionVisible, true); n++; + + XtSetArg (args[n], XmNmarginWidth, 0); n++; + XtSetArg (args[n], XmNmarginHeight, 0); n++; + XtSetArg (args[n], XmNresizeHeight, True); n++; + XtSetArg (args[n], XmNborderWidth, 0); n++; + XtSetArg (args[n], XmNeditMode, XmSINGLE_LINE_EDIT); n++; + + // get/set the current font + XmFontList fl = 0; + XFontStruct* fs = fontStructs[fontID]; + if (fs) + { + XmFontListEntry entry = XmFontListEntryCreate (XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT, fs); + XmFontList fl = XmFontListAppendEntry (0, entry); + XtSetArg (args[n], XmNfontList, fl); n++; + } + + platformControl = XmCreateText (XtParent (widget), "Text", args, n); + XtManageChild ((Widget)platformControl); + if (fl) + XmFontListFree (fl); + XmTextSetSelection ((Widget)platformControl, 0, strlen (text), 0); + XmTextSetHighlight ((Widget)platformControl, 0, strlen (text), XmHIGHLIGHT_SELECTED); + +#elif BEOS + BView* plugView = (BView*) getFrame ()->getSystemWindow (); + CRect rect; + getFrame ()->getSize (&rect); + BRect r (rect.left + size.left, rect.top + size.top, rect.left + size.right, rect.top + size.bottom); + BRect tr = r; + tr.OffsetTo (B_ORIGIN); + tr.InsetBy (1, 1); + BeTextView* textView = new BeTextView (this, r, NULL, tr); + plugView->Window ()->Activate (true); + plugView->AddChild (textView); + BFont font; + if (fontID < 0 || fontID >= kNumStandardFonts) + fontID = kSystemFont; + extern const char* gStandardFontStyle[]; + font.SetFamilyAndStyle (gStandardFontName[fontID], gStandardFontStyle[fontID]); + font.SetSize (gStandardFontSize[fontID]); + rgb_color c = { fontColor.red, fontColor.green, fontColor.blue, 255 }; + textView->SetFontAndColor (&font, B_FONT_FAMILY_AND_STYLE | B_FONT_SIZE, &c); + rgb_color cv = { backColor.red, backColor.green, backColor.blue, 255 }; + textView->SetMaxBytes (255); + textView->SetViewColor (cv); + alignment a; + if (horiTxtAlign == kRightText) + a = B_ALIGN_RIGHT; + else if (horiTxtAlign == kLeftText) + a = B_ALIGN_LEFT; + else + a = B_ALIGN_CENTER; + textView->SetAlignment (a); + textView->SetText (text); + textView->DisallowChar ('\n'); + textView->DisallowChar ('\t'); + textView->MakeResizable (true); + textView->MakeFocus (true); + textView->SelectAll (); + platformControl = textView; +#endif +} + +//------------------------------------------------------------------------ +void CTextEdit::looseFocus (CDrawContext *pContext) +{ + // Call this yet to avoid recursive call + endEdit(); + if (getFrame ()->getFocusView () == this) + getFrame ()->setFocusView (0); + + if (platformControl == 0) + return; + + char oldText[256]; + strcpy (oldText, text); + +#if WINDOWS + char newText[255]; + GetWindowText ((HWND)platformControl, newText, 255); + strcpy (text, newText); + + DestroyWindow ((HWND)platformControl); + if (platformFont) + { + DeleteObject ((HGDIOBJ)platformFont); + platformFont = 0; + } + if (platformFontColor) + { + DeleteObject (platformFontColor); + platformFontColor = 0; + } + +#elif MAC + + #if MACX + if (platformControl == 0) + return; + + if (gTextEditEventHandler) + RemoveEventHandler (gTextEditEventHandler); + gTextEditEventHandler = 0; + #if QUARTZ + if (textControl) + { + CFStringRef cfstr; + if (!gTextEditCanceled && GetControlData (textControl, kControlEditTextPart, kControlEditTextCFStringTag, sizeof cfstr, (void*)&cfstr, NULL) == noErr) + { + CFStringGetCString (cfstr, text, 255, kCFStringEncodingUTF8); + CFRelease (cfstr); + } + HIViewSetVisible (textControl, false); + HIViewRemoveFromSuperview (textControl); + textControl = 0; + pParentFrame->setCursor (kCursorDefault); + } + else + #endif + { + if (!gTextEditCanceled) + { + CharsHandle dataHandle; + TXNGetDataEncoded ((TXNObject)platformControl, kTXNStartOffset, kTXNEndOffset, &dataHandle, kTXNTextData); + if (dataHandle != NULL && GetHandleSize (dataHandle) > 0) + { + long s = GetHandleSize (dataHandle); + strncpy (text, *dataHandle, (s > 255) ? 255 : s); + text [(s > 255) ? 255 : s] = 0; + DisposeHandle (dataHandle); + } + else + text[0] = 0; + } + TXNFocus ((TXNObject)platformControl, false); + TXNDeleteObject ((TXNObject)platformControl); + } + + platformControl = 0; + + setDirty (true); + + #if 0//QUARTZ + CRect fr (size); + CPoint offset; + localToFrame (offset); + fr.offset (offset.x, offset.y); + + RgnHandle rgn = NewRgn (); + MacSetRectRgn (rgn, fr.left, fr.top, fr.right, fr.bottom); + HIViewSetNeedsDisplayInRegion ((HIViewRef)getFrame ()->getPlatformControl () , rgn, true); + DisposeRgn (rgn); + #endif +// doIdleStuff (); + + #else + + strcpy (text, (char*)platformControl); + delete[] platformControl; + #endif +#elif MOTIF + char *pNewText = XmTextGetString ((Widget)platformControl); + strcpy (text, pNewText); + XtFree (pNewText); + + XtUnmanageChild ((Widget)platformControl); + XtDestroyWidget ((Widget)platformControl); + +#elif BEOS + BTextView* textView = (BTextView*) platformControl; + strncpy (text, textView->Text (), 255); + if (textView->LockLooper ()) + { + BWindow* w = textView->Window (); + textView->RemoveSelf (); + w->Unlock (); + } + delete textView; + +#endif + CPoint origOffset; + bool resetContextOffset = false; + if (!pContext) + { + // create a local context + pContext = getFrame ()->createDrawContext (); + if (getParentView ()) + { + resetContextOffset = true; + origOffset.x = pContext->offset.x; + origOffset.y = pContext->offset.y; + CView *view= getParentView (); + CRect rect2; + view->getViewSize (rect2); + CPoint offset; + view->localToFrame (offset); + rect2.offset (offset.x, offset.y); + pContext->offset.h = rect2.left; + pContext->offset.v = rect2.top; + } + } + else + pContext->remember (); + + // update dependency + bool change = false; + if (strcmp (oldText, text)) + { + change = true; + if (listener) + listener->valueChanged (pContext, this); + } + + platformControl = 0; + if (resetContextOffset) + { + pContext->offset.x = origOffset.x; + pContext->offset.y = origOffset.y; + } + pContext->forget (); + + if (change) + doIdleStuff (); + + CView* receiver = pParentView ? pParentView : pParentFrame; + if (receiver) + receiver->notify (this, "LooseFocus"); +} + +//------------------------------------------------------------------------ +void CTextEdit::setTextEditConvert (void (*convert) (char *input, char *string)) +{ + editConvert = convert; +} + +//------------------------------------------------------------------------ +void CTextEdit::setTextEditConvert (void (*convert) (char *input, char *string, + void *userDta), void *userData) +{ + editConvert2 = convert; + this->userData = userData; +} + +//------------------------------------------------------------------------ +// COptionMenuScheme +//------------------------------------------------------------------------ +/*! @class COptionMenuScheme +Used to define the appearance (font color, background color...) of a popup-menu. +To define the scheme of a menu, use the appropriate setScheme method (see COptionMenu). +@section coptionmenuscheme_new_in_3_0 New since 3.0 +You can also use the global variable gOptionMenuScheme to use one scheme on all menus. +@section coptionmenuscheme_note Note +If you want to use it on Mac OS X, you must set the macro MAC_ENABLE_MENU_SCHEME (needs Mac OS X 10.3 or higher) +*/ +COptionMenuScheme* gOptionMenuScheme = 0; + +//------------------------------------------------------------------------ +COptionMenuScheme::COptionMenuScheme () +{ +#if WINDOWS + COLORREF c = GetSysColor (COLOR_MENU); + backgroundColor (GetRValue (c), GetGValue (c), GetBValue (c), 0); + c = GetSysColor (COLOR_HIGHLIGHT); + selectionColor (GetRValue (c), GetGValue (c), GetBValue (c), 0); + c = GetSysColor (COLOR_MENUTEXT); + textColor (GetRValue (c), GetGValue (c), GetBValue (c), 0); + c = GetSysColor (COLOR_HIGHLIGHTTEXT); + hiliteTextColor (GetRValue (c), GetGValue (c), GetBValue (c), 0); + c = GetSysColor (COLOR_GRAYTEXT); + disableTextColor (GetRValue (c), GetGValue (c), GetBValue (c), 0); +#else + backgroundColor = kGreyCColor; + selectionColor = kBlueCColor; + textColor = kBlackCColor; + hiliteTextColor = kWhiteCColor; + disableTextColor = kWhiteCColor; +#endif + font = kNormalFontSmall; + #if MAC_ENABLE_MENU_SCHEME + registerWithToolbox (); + #endif +} + +//------------------------------------------------------------------------ +COptionMenuScheme::~COptionMenuScheme () +{ + #if MAC_ENABLE_MENU_SCHEME + unregisterWithToolbox (); + #endif +} + +//------------------------------------------------------------------------ +void COptionMenuScheme::getItemSize (const char* text, CDrawContext* pContext, CPoint& size) +{ + if (!strcmp (text, kMenuSeparator)) // separator + { + #if MAC + size.h = 6; + size.v = 9; + #else + // was: size.h = size.v = 6; + size.h = 6; + size.v = 18; + // separators must have same height, otherwise we have problems + // in multi-column menus :( + #endif + } + else + { + pContext->setFont (font); + size.h = pContext->getStringWidth (text) + 18; + size.v = 18; + #if MAC + size.h += 18; + #endif + } +} + +//------------------------------------------------------------------------ +void COptionMenuScheme::drawItemBack (CDrawContext* pContext, const CRect& rect, bool hilite) +{ + if (hilite) + pContext->setFillColor (selectionColor); + else + pContext->setFillColor (backgroundColor); + pContext->fillRect (rect); +} + +//------------------------------------------------------------------------ +void COptionMenuScheme::drawItem (const char* text, long itemId, long state, CDrawContext* pContext, const CRect& rect) +{ + bool hilite = (state & kSelected) != 0; + + drawItemBack (pContext, rect, hilite); + + if (!strcmp (text, kMenuSeparator)) + { + CCoord y = rect.top + rect.height () / 2; + + const CColor bc = { 0, 0, 0, 150}; + const CColor wc = { 255, 255, 255, 150}; + + pContext->setFrameColor (bc); + pContext->moveTo (CPoint (rect.left + 2, y - 1)); + pContext->lineTo (CPoint (rect.right - 2, y - 1)); + pContext->setFrameColor (wc); + pContext->moveTo (CPoint (rect.left + 2, y)); + pContext->lineTo (CPoint (rect.right - 2, y)); + return; + } + + CRect r; + if (state & kChecked) + { + r (6, 4, 14, 12); + r.offset (rect.left, rect.top); + if (hilite) + pContext->setFillColor (hiliteTextColor); + else + pContext->setFillColor (textColor); + pContext->fillEllipse (r); + } + + r = rect; + r.left += 18; + pContext->setFont (font); + if (state & kDisabled) + pContext->setFontColor (disableTextColor); + else + { + if (hilite) + pContext->setFontColor (hiliteTextColor); + else + pContext->setFontColor (textColor); + } + + // this needs to be done right, without changing the text pointer in anyway ;-) + char *ptr = (char*)strstr (text, "\t"); + if (ptr) + { + char modifier[32]; + strcpy (modifier, ptr + 1); + *ptr = 0; + pContext->drawString (text, r, false, kLeftText); + + *ptr = '\t'; + r.left = r.right - 50; + pContext->drawString (modifier, r, false, kLeftText); + } + else + pContext->drawString (text, r, false, kLeftText); +} + +#if MAC_ENABLE_MENU_SCHEME +#define kHIMenuViewClassID CFSTR("com.apple.HIMenuView") + +struct HIMenuScheme +{ + HIViewRef hiView; + COptionMenuScheme* scheme; + COptionMenu* menu; + COffscreenContext* offscreenContext; + float maxWidth; +}; + +const EventParamName kEventParamCOptionMenuScheme = 'COMS'; +const EventParamName kEventParamCOptionMenu = 'COM '; + +#define kItemHeight 18 + +static CFStringRef gOptionMenuSchemeClassID = 0; +static HIObjectClassRef gMenuClassRef = 0; +static CFIndex gOptionMenuSchemeClassIDRefCount = 0; + +//------------------------------------------------------------------------ +void COptionMenuScheme::registerWithToolbox () +{ + if (gOptionMenuSchemeClassID == 0) + { + gOptionMenuSchemeClassID = CFStringCreateWithFormat (NULL, NULL, CFSTR("net.sourceforge.vstgui.COptionMenuSchemeClassID.%d"), this); + + static const EventTypeSpec events[] = + { + { kEventClassHIObject, kEventHIObjectConstruct } , + { kEventClassHIObject, kEventHIObjectInitialize }, + { kEventClassHIObject, kEventHIObjectDestruct }, + + { kEventClassControl, kEventControlHitTest }, + { kEventClassControl, kEventControlGetPartRegion }, + { kEventClassControl, kEventControlDraw }, + { kEventClassControl, kEventControlGetOptimalBounds }, + + { kEventClassMenu, kEventMenuCreateFrameView }, + + { kEventClassScrollable, kEventScrollableGetInfo }, + }; + + HIObjectRegisterSubclass ( gOptionMenuSchemeClassID, + kHIMenuViewClassID, + kNilOptions, + COptionMenuScheme::eventHandler, + GetEventTypeCount (events), + events, + NULL, + &gMenuClassRef); + gOptionMenuSchemeClassIDRefCount = CFGetRetainCount (gOptionMenuSchemeClassID); + } + else + CFRetain (gOptionMenuSchemeClassID); +} + +//------------------------------------------------------------------------ +void COptionMenuScheme::unregisterWithToolbox () +{ + if (gOptionMenuSchemeClassID) + { + if (CFGetRetainCount (gOptionMenuSchemeClassID) == gOptionMenuSchemeClassIDRefCount) + { + HIObjectUnregisterClass (gMenuClassRef); + gMenuClassRef = 0; + } + CFRelease (gOptionMenuSchemeClassID); + } +} + +//------------------------------------------------------------------------ +pascal OSStatus COptionMenuScheme::eventHandler (EventHandlerCallRef inCallRef, EventRef inEvent, void *inUserData) +{ + OSStatus err = eventNotHandledErr; + UInt32 eventClass = GetEventClass (inEvent); + UInt32 eventKind = GetEventKind (inEvent); + HIMenuScheme* scheme = (HIMenuScheme*)inUserData; + + switch (eventClass) + { + case kEventClassHIObject: + { + switch (eventKind) + { + case kEventHIObjectConstruct: + { + scheme = (HIMenuScheme*)calloc (1, sizeof (HIMenuScheme)); + GetEventParameter (inEvent, kEventParamHIObjectInstance, typeHIObjectRef, NULL, sizeof (HIObjectRef), NULL, &scheme->hiView); + SetEventParameter (inEvent, kEventParamHIObjectInstance, typeVoidPtr, sizeof (HIMenuScheme*), &scheme); + scheme->maxWidth = 100; + err = noErr; + break; + } + case kEventHIObjectInitialize: + { + err = CallNextEventHandler (inCallRef, inEvent); + if (err == noErr) + { + GetEventParameter (inEvent, kEventParamCOptionMenuScheme, typeVoidPtr, NULL, sizeof (COptionMenuScheme*), NULL, &scheme->scheme); + GetEventParameter (inEvent, kEventParamCOptionMenu, typeVoidPtr, NULL, sizeof (COptionMenu*), NULL, &scheme->menu); + scheme->scheme->remember (); + scheme->menu->remember (); + scheme->offscreenContext = new COffscreenContext (scheme->menu->getFrame (), 600, 100); + } + break; + } + case kEventHIObjectDestruct: + { + delete scheme->offscreenContext; + scheme->scheme->forget (); + scheme->menu->forget (); + free (scheme); + err = noErr; + break; + } + } + break; + } + case kEventClassControl: + { + HIViewRef control; + GetEventParameter (inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof (HIViewRef), NULL, &control); + switch (eventKind) + { + case kEventControlInitialize: + { + err = CallNextEventHandler (inCallRef, inEvent); + break; + } + case kEventControlHitTest: + { + HIPoint mouseLoc; + GetEventParameter (inEvent, kEventParamMouseLocation, typeHIPoint, NULL, sizeof (mouseLoc), NULL, &mouseLoc); + ControlPartCode partHit = mouseLoc.y / kItemHeight + 1; + char temp[1024]; + CPoint size; + long yPos = 0; + for (long i = 0; i < scheme->menu->getNbEntries (); i++) + { + scheme->menu->getEntry (i, temp); + scheme->scheme->getItemSize (temp, scheme->offscreenContext, size); + yPos += size.y; + if (yPos >= mouseLoc.y) + { + partHit = i + 1; + break; + } + } + SetEventParameter (inEvent, kEventParamControlPart, typeControlPartCode, sizeof (partHit), &partHit); + err = noErr; + break; + } + case kEventControlGetOptimalBounds: + { + HIRect r = { {0, 0}, { 0, 0 }}; + r.size.width = scheme->maxWidth; + char temp[1024]; + CPoint size; + for (long i = 0; i < scheme->menu->getNbEntries (); i++) + { + scheme->menu->getEntry (i, temp); + scheme->scheme->getItemSize (temp, scheme->offscreenContext, size); + if (!strncmp (temp, kMenuSubMenu, 2)) + size.x += 16; + r.size.height += size.y; + if (r.size.width < size.x) + r.size.width = size.x; + } + //r.size.height += scheme->menu->getNbEntries (); + scheme->maxWidth = r.size.width; + SetEventParameter (inEvent, kEventParamControlOptimalBounds, typeHIRect, sizeof (HIRect), &r); + err = noErr; + break; + } + case kEventControlGetPartRegion: + { + HIRect r = { {0, 0}, { 0, 0 }}; + ControlPartCode whichItem; + RgnHandle outRegion = NULL; + GetEventParameter (inEvent, kEventParamControlPart, typeControlPartCode, NULL, sizeof (whichItem), NULL, &whichItem); + GetEventParameter (inEvent, kEventParamControlRegion, typeQDRgnHandle, NULL, sizeof(outRegion), NULL, &outRegion); + if (whichItem <= 0) + { + r.size.width = scheme->maxWidth; + char temp[1024]; + CPoint size; + for (long i = 0; i < scheme->menu->getNbEntries (); i++) + { + scheme->menu->getEntry (i, temp); + scheme->scheme->getItemSize (temp, scheme->offscreenContext, size); + if (!strncmp (temp, kMenuSubMenu, 2)) + size.x += 16; + r.size.height += size.y; + if (r.size.width < size.x) + r.size.width = size.x; + } + scheme->maxWidth = r.size.width; + r.size.height += scheme->menu->getNbEntries (); + } + else + { + char temp[1024]; + CPoint size; + for (long i = 0; i < whichItem; i++) + { + r.origin.y += size.y; + scheme->menu->getEntry (i, temp); + scheme->scheme->getItemSize (temp, scheme->offscreenContext, size); + r.size.height += size.y; + } + r.size.width = scheme->maxWidth; + } + SetRectRgn (outRegion, (short) r.origin.x, (short) r.origin.y,(short) r.origin.x + r.size.width, (short) r.origin.y+ r.size.height + 1); + err = noErr; + break; + } + case kEventControlDraw: + { + CGContextRef cgContext; + GetEventParameter (inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof (cgContext), NULL, &cgContext); + HIRect r; + HIViewGetBounds (control, &r); + CGContextClearRect (cgContext, r); + if (control != scheme->hiView) + { + err = noErr; + break; + } + ControlPartCode focusPart; + HIViewGetFocusPart (scheme->hiView, &focusPart); + focusPart--; + WindowRef window = HIViewGetWindow (scheme->hiView); + CDrawContext context (NULL, cgContext, window); + char entryText[1024]; + CPoint size; + CRect rect (0, 0); + rect.setHeight (kItemHeight); + rect.setWidth (scheme->maxWidth); + for (int i = 0; i < scheme->menu->getNbEntries (); i++) + { + if (scheme->menu->getEntry (i, entryText)) + { + scheme->scheme->getItemSize (entryText, &context, size); + long state = scheme->menu->isCheckEntry (i) ? kChecked : 0; + if (focusPart >= 0 && focusPart == i) + state |= kSelected; + long offset = 0; + if (!strncmp (entryText, kMenuSubMenu, 2)) + { + state |= kSubMenu; + offset = 2; + } + else if (!strncmp (entryText, kMenuTitle, 2)) + { + state |= kTitle; + offset = 2; + } + else if (!strncmp (entryText, kMenuDisable, 2)) + { + state |= kDisabled; + offset = 2; + } + rect.setHeight (size.y+1); + context.setClipRect (rect); + scheme->scheme->drawItem (entryText+offset, i, state, &context, rect); + rect.offset (0, size.y); + } + } + break; + } + case kEventControlGetFrameMetrics: + { + err = CallNextEventHandler (inCallRef, inEvent); + HIViewFrameMetrics metrics; + GetEventParameter (inEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, NULL, sizeof (metrics), NULL, &metrics); + metrics.top = metrics.bottom = 0; + SetEventParameter (inEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, sizeof (metrics), &metrics); + break; + } + case kEventControlOwningWindowChanged: + { + WindowRef newWindow = GetControlOwner (control); + HIWindowChangeFeatures (newWindow, 0, kWindowIsOpaque); + err = noErr; + HIViewRef root = HIViewGetRoot (newWindow); + if (root) + { + HIRect bounds, frame; + HIViewGetBounds (root, &bounds); + HIViewGetFrame (root, &frame); + } + break; + } + } + break; + } + case kEventClassMenu: + { + switch (eventKind) + { + case kEventMenuCreateFrameView: + { + err = CallNextEventHandler (inCallRef, inEvent); + HIViewRef frameView; + GetEventParameter (inEvent, kEventParamMenuFrameView, typeControlRef, NULL, sizeof (ControlRef), NULL, &frameView); + HIViewFindByID (frameView, kHIViewWindowContentID, &frameView); + if (frameView) + { + EventTypeSpec events [] = { { kEventClassControl, kEventControlDraw }, { kEventClassControl, kEventControlOwningWindowChanged }, { kEventClassControl, kEventControlGetFrameMetrics } }; + InstallControlEventHandler (frameView, COptionMenuScheme::eventHandler, GetEventTypeCount (events), events, scheme, NULL); + } + break; + } + } + break; + } + case kEventClassScrollable: + { + switch (eventKind) + { + case kEventScrollableGetInfo: + { + HISize size; + HIPoint origin = { 0, 0 }; + + size.width = 200; + size.height = kItemHeight * (scheme->menu->getNbEntries () + 1);; + + SetEventParameter(inEvent, kEventParamImageSize, typeHISize, sizeof( size ), &size ); + SetEventParameter(inEvent, kEventParamViewSize, typeHISize, sizeof( size ), &size ); + SetEventParameter(inEvent, kEventParamOrigin, typeHIPoint, sizeof( origin ), &origin ); + + // line size is 1/10th total size + size.width /= 10; + size.height /= 10; + + SetEventParameter(inEvent, kEventParamLineSize, typeHISize, sizeof( size ), &size ); + + err = noErr; + break; + } + } + break; + } + } + + return err; +} +#endif + +//------------------------------------------------------------------------ +// COptionMenu +//------------------------------------------------------------------------ +/*! @class COptionMenu +Define a rectangle view where a text-value can be displayed with a given font and color. +The text-value is centered in the given rect. +A pixmap can be used as background, a second pixmap can be used when the option menu is popuped. +There are 2 styles with or without a shadowed text. When a mouse click occurs, a popup menu is displayed. +*/ +COptionMenu::COptionMenu (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CBitmap *bgWhenClick, const long style) +: CParamDisplay (size, background, style), bgWhenClick (bgWhenClick), nbItemsPerColumn (-1), + prefixNumbers (0), scheme (0) +{ + this->listener = listener; + this->tag = tag; + + nbEntries = 0; + nbSubMenus = 0; + currentIndex = -1; + lastButton = kRButton; + platformControl = 0; + lastResult = -1; + lastMenu = 0; + + #if MAC + menuID = 0; + #endif + + if (bgWhenClick) + bgWhenClick->remember (); + + nbSubMenuAllocated = nbAllocated = 0; + + check = 0; + entry = 0; + submenuEntry = 0; +} + +//------------------------------------------------------------------------ +COptionMenu::~COptionMenu () +{ + removeAllEntry (); + + if (bgWhenClick) + bgWhenClick->forget (); +} + +//------------------------------------------------------------------------ +void COptionMenu::setPrefixNumbers (long preCount) +{ + prefixNumbers = preCount; +} + +//----------------------------------------------------------------------------- +bool COptionMenu::allocateSubMenu (long nb) +{ + long newAllocated = nbSubMenuAllocated + nb; + + if (submenuEntry) + submenuEntry = (COptionMenu**)realloc (submenuEntry, newAllocated * sizeof (COptionMenu*)); + else + submenuEntry = (COptionMenu**)malloc (newAllocated * sizeof (COptionMenu*)); + + long i; + for (i = nbSubMenuAllocated; i < newAllocated; i++) + submenuEntry[i] = 0; + + nbSubMenuAllocated = newAllocated; + + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::allocateMenu (long nb) +{ + long newAllocated = nbAllocated + nb; + + if (check) + check = (bool*)realloc (check, newAllocated * sizeof (bool)); + else + check = (bool*)malloc (newAllocated * sizeof (bool)); + if (!check) + return false; + + if (entry) + entry = (char**)realloc (entry, newAllocated * sizeof (char*)); + else + entry = (char**)malloc (newAllocated * sizeof (char*)); + if (!entry) + { + free (check); + return false; + } + + long i; + for (i = nbAllocated; i < newAllocated; i++) + { + check[i] = false; + entry[i] = 0; + } + + nbAllocated = newAllocated; + + return true; +} + +//------------------------------------------------------------------------ +COptionMenu* COptionMenu::getSubMenu (long idx) const +{ + if (submenuEntry && idx < nbSubMenus) + return submenuEntry[idx]; + return 0; +} + +//------------------------------------------------------------------------ +bool COptionMenu::addEntry (COptionMenu *subMenu, char *txt) +{ + if (nbEntries >= MAX_ENTRY || !subMenu || !txt) + return false; + + if (nbEntries >= nbAllocated) + if (!allocateMenu (32)) + return false; + + entry[nbEntries] = (char*)malloc (256); + switch (prefixNumbers) + { + case 2: + sprintf (entry[nbEntries], "-M%1d %s", (int)(nbEntries + 1), txt); + break; + + case 3: + sprintf (entry[nbEntries], "-M%02d %s", (int)(nbEntries + 1), txt); + break; + + case 4: + sprintf (entry[nbEntries], "-M%03d %s", (int)(nbEntries + 1), txt); + break; + + default: + sprintf (entry[nbEntries], "-M%s", txt); + } + + + if (nbSubMenus >= nbSubMenuAllocated) + if (!allocateSubMenu (10)) + return false; + + submenuEntry[nbSubMenus++] = subMenu; + subMenu->remember (); + + nbEntries++; + + if (currentIndex < 0) + currentIndex = 0; + + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::addEntry (char *txt, long index) +{ + if (nbEntries >= MAX_ENTRY) + return false; + + if (nbEntries >= nbAllocated) + if (!allocateMenu (32)) + return false; + + entry[nbEntries] = (char*)malloc (256); + + long pos = nbEntries; + + // switch the entries for the insert + if (index >= 0) + { + for (long i = nbEntries; i > index; i--) + strcpy (entry[i], entry[i - 1]); + if (index >= nbEntries) + pos = nbEntries; + else + pos = index; + if (currentIndex >= index) + currentIndex++; + } + + *entry[pos] = 0; + if (txt) + { + switch (prefixNumbers) + { + case 2: + sprintf (entry[pos], "%1d %s", (int)(index + 1), txt); + break; + + case 3: + sprintf (entry[pos], "%02d %s", (int)(index + 1), txt); + break; + + case 4: + sprintf (entry[pos], "%03d %s", (int)(index + 1), txt); + break; + + default: + strncpy (entry[pos], txt, 256); + } + } + + nbEntries++; + + if (currentIndex < 0) + currentIndex = 0; + + return true; +} + +//------------------------------------------------------------------------ +long COptionMenu::getCurrent (char *txt, bool countSeparator) const +{ + if (currentIndex < 0) + return -1; + + long result = 0; + + if (countSeparator) + { + if (txt) + strcpy (txt, entry[currentIndex]); + result = currentIndex; + } + else + { + for (long i = 0; i < currentIndex; i++) + { + if (strcmp (entry[i], kMenuSeparator) && strncmp (entry[i], kMenuTitle, 2)) + result++; + } + if (txt) + strcpy (txt, entry[currentIndex]); + } + return result; +} + +//------------------------------------------------------------------------ +bool COptionMenu::setCurrent (long index, bool countSeparator) +{ + if (index < 0 || index >= nbEntries) + return false; + + if (countSeparator) + { + if (!strcmp (entry[index], kMenuSeparator) && strncmp (entry[index], kMenuTitle, 2)) + return false; + + currentIndex = index; + } + else + { + long newCurrent = 0; + long i = 0; + while (i <= index && newCurrent < nbEntries) + { + if (strcmp (entry[newCurrent], kMenuSeparator) && strncmp (entry[newCurrent], kMenuTitle, 2)) + i++; + newCurrent++; + } + currentIndex = newCurrent - 1; + } + if (style & (kMultipleCheckStyle & ~kCheckStyle)) + check[currentIndex] = !check[currentIndex]; + + // to force the redraw + setDirty (); + + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::getEntry (long index, char *txt) const +{ + if (index < 0 || index >= nbEntries) + return false; + + if (txt) + strcpy (txt, entry[index]); + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::setEntry (long index, char *txt) +{ + if (index < 0 || index >= nbEntries) + return false; + + if (txt) + strcpy (entry[index], txt); + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::removeEntry (long index) +{ + if (index < 0 || index >= nbEntries) + return false; + + nbEntries--; + + // switch the entries + for (long i = index; i < nbEntries; i++) + { + strcpy (entry[i], entry[i + 1]); + check[i] = check [i + 1]; + } + + if (currentIndex >= index) + currentIndex--; + + // delete the last one + free (entry[nbEntries]); + entry[nbEntries] = 0; + check[nbEntries] = false; + + if (nbEntries == 0) + currentIndex = -1; + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::removeAllEntry () +{ + long i; + for (i = 0; i < nbEntries; i++) + { + free (entry[i]); + entry[i] = 0; + check[i] = false; + } + + nbEntries = 0; + currentIndex = -1; + + for (i = 0; i < nbSubMenus; i++) + { + submenuEntry[i]->forget (); + submenuEntry[i] = 0; + } + nbSubMenus = 0; + + if (check) + free (check); + check = 0; + if (entry) + free (entry); + entry = 0; + if (submenuEntry) + free (submenuEntry); + submenuEntry = 0; + nbAllocated = 0; + nbSubMenuAllocated = 0; + + return true; +} + +//------------------------------------------------------------------------ +long COptionMenu::getIndex (char *txt) const +{ + if (!txt) + return -1; + + // search entries + for (long i = 0; i < nbEntries; i++) + if (!strcmp (entry[i], txt)) + return i; + + // not found + return -1; +} + +//------------------------------------------------------------------------ +bool COptionMenu::checkEntry (long index, bool state) +{ + if (index < 0 || index >= nbEntries) + return false; + + check[index] = state; + + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::checkEntryAlone (long index) +{ + if (index < 0 || index >= nbEntries) + return false; + for (long i = 0; i < nbEntries; i++) + check[i] = false; + check[index] = true; + + return true; +} + +//------------------------------------------------------------------------ +bool COptionMenu::isCheckEntry (long index) const +{ + if (index < 0 || index >= nbEntries) + return false; + + return check[index]; +} + +//------------------------------------------------------------------------ +void COptionMenu::draw (CDrawContext *pContext) +{ + if (currentIndex >= 0 && nbEntries) + drawText (pContext, entry[currentIndex] + prefixNumbers); + else + drawText (pContext, NULL); +} + +//------------------------------------------------------------------------ +void COptionMenu::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled || !getFrame () || !pContext) + return; + + lastButton = (button != -1) ? button : pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (lastButton & (kLButton|kRButton|kApple)) + { + if (bgWhenClick) + { + char string[256]; + if (currentIndex >= 0) + sprintf (string, "%s", entry[currentIndex]); + else + string[0] = 0; + + drawText (pContext, string, bgWhenClick); + } + + beginEdit(); + takeFocus (pContext); + } +} + +//------------------------------------------------------------------------ +#if MOTIF +#include <Xm/RowColumn.h> +#include <Xm/ToggleB.h> +#include <Xm/PushB.h> +#include <Xm/SeparatoG.h> + +static void _unmapCallback (Widget item, XtPointer clientData, XtPointer callData); +static void _activateCallback (Widget item, XtPointer clientData, XtPointer callData); + +//------------------------------------------------------------------------ +static void _unmapCallback (Widget item, XtPointer clientData, XtPointer callData) +{ + COptionMenu *optionMenu= (COptionMenu*)clientData; + optionMenu->looseFocus (); +} + +//------------------------------------------------------------------------ +static void _activateCallback (Widget item, XtPointer clientData, XtPointer callData) +{ + COptionMenu *optionMenu= (COptionMenu*)clientData; + optionMenu->setCurrentSelected ((void*)item); +} +#endif + +//------------------------------------------------------------------------ +#if BEOS +#include <PopUpMenu.h> +#include <MenuItem.h> +#endif + +//------------------------------------------------------------------------ +COptionMenu *COptionMenu::getLastItemMenu (long &idxInMenu) const +{ + idxInMenu = lastMenu ? (long)lastMenu->getValue (): -1; + return lastMenu; +} + +//------------------------------------------------------------------------ +COptionMenu *COptionMenu::getItemMenu (long idx, long &idxInMenu, long &offsetIdx) +{ +#if WINDOWS + long oldIDx = offsetIdx; + offsetIdx += nbEntries; + + if (idx < offsetIdx) + { + idxInMenu = idx - oldIDx; + return this; + } + +#elif MAC + if (menuID == offsetIdx) + { + idxInMenu = idx; + return this; + } +#endif + COptionMenu *menu = 0; + for (long i = 0; i < nbSubMenus; i++) + { + menu = submenuEntry[i]->getItemMenu (idx, idxInMenu, offsetIdx); + if (menu) + break; + } + return menu; +} + +//------------------------------------------------------------------------ +void COptionMenu::removeItems () +{ + for (long i = 0; i < nbSubMenus; i++) + submenuEntry[i]->removeItems (); + +#if WINDOWS + // destroy the menu + if (platformControl) + DestroyMenu ((HMENU)platformControl); + platformControl = 0; + +#elif MAC + // destroy the menu + if (menuID) + DeleteMenu (menuID); + if (platformControl) + DisposeMenu ((MenuHandle)platformControl); + platformControl = 0; + +#endif +} + +//------------------------------------------------------------------------ +void *COptionMenu::appendItems (long &offsetIdx) +{ + bool multipleCheck = style & (kMultipleCheckStyle & ~kCheckStyle); + +#if WINDOWS + void *menu = (void*)CreatePopupMenu (); + + bool ownerDraw = (scheme != 0) || (gOptionMenuScheme != 0); + + int flags = 0; + long idxSubmenu = 0; + long offset = offsetIdx; + offsetIdx += nbEntries; + long inc = 0; + for (long i = 0; i < nbEntries; i++) + { + //---Separator----- + if (!strcmp (entry[i], kMenuSeparator)) + { + if (ownerDraw) + AppendMenu ((HMENU)menu, MF_OWNERDRAW|MF_SEPARATOR, 0, entry[i]); + else + AppendMenu ((HMENU)menu, MF_SEPARATOR, 0, entry[i]); + } + else + { + flags = ownerDraw ? MF_OWNERDRAW : MF_STRING; + if (nbEntries < 160 && nbItemsPerColumn > 0 && inc && !(inc % nbItemsPerColumn)) + flags |= MF_MENUBARBREAK; + + if (!strncmp (entry[i], kMenuSubMenu, 2)) + { + if (idxSubmenu < nbSubMenus) + { + void *submenu = submenuEntry[idxSubmenu]->appendItems (offsetIdx); + if (submenu) + { + idxSubmenu++; + AppendMenu ((HMENU)menu, flags|MF_POPUP|MF_ENABLED, (UINT_PTR)submenu, entry[i] + 2); + } + else + continue; + } + else + continue; + } + //---Disable/Gray entry----------- + else if (!strncmp (entry[i], kMenuDisable, 2)) + { + AppendMenu ((HMENU)menu, flags|MF_GRAYED, offset + inc, entry[i] + 2); + } + //---Disable entry-------- + else if (!strncmp (entry[i], kMenuTitle, 2)) + { + AppendMenu ((HMENU)menu, flags|MF_DISABLED, offset + inc, entry[i] + 2); + } + //---Multiple Checked entry--- + else if (multipleCheck) + { + AppendMenu ((HMENU)menu, flags|MF_ENABLED | + (check[i] ? MF_CHECKED : MF_UNCHECKED), offset + inc, entry[i]); + } + //---Checked Entry--------- + else if (style & kCheckStyle) + { + AppendMenu ((HMENU)menu, flags|MF_ENABLED | + ((i == currentIndex) ? MF_CHECKED : MF_UNCHECKED), offset + inc, entry[i]); + } + else + AppendMenu ((HMENU)menu, flags|MF_ENABLED, offset + inc, entry[i]); + } + inc++; + } + platformControl = menu; + return menu; + +#elif MAC + //---Get an non-existing ID for the menu: + menuID = UniqueID ('MENU'); + + MenuHandle theMenu = 0; + //---Create the menu + #if MAC_ENABLE_MENU_SCHEME + extern long pSystemVersion; + if ((scheme || gOptionMenuScheme) && pSystemVersion >= 0x1030) + { + COptionMenuScheme* s = gOptionMenuScheme ? gOptionMenuScheme : scheme; + EventRef initEvent = NULL; + if (CreateEvent (NULL, kEventClassHIObject, kEventHIObjectInitialize, 0, 0, &initEvent) == noErr) + { + MenuDefSpec customMenuDef; + COptionMenu* optMenu = this; + SetEventParameter (initEvent, kEventParamCOptionMenu, typeVoidPtr, sizeof(COptionMenu*), &optMenu); + customMenuDef.defType = kMenuDefClassID; + customMenuDef.u.view.classID = gOptionMenuSchemeClassID; + customMenuDef.u.view.initEvent = initEvent; + SetEventParameter (initEvent, kEventParamCOptionMenuScheme, typeVoidPtr, sizeof(COptionMenuScheme*), &s); + CreateCustomMenu (&customMenuDef, menuID, 0, &theMenu); + ReleaseEvent (initEvent); + if (theMenu == NULL) + return NULL; + } + } + else + #endif + theMenu = NewMenu (menuID, "\pPopUp"); + + char text2[256]; + long keyChar; + long idxSubmenu = 0; + offsetIdx += nbEntries; + short keyModifiers; + bool useGlyph; + for (long i = 0; i < nbEntries; i++) + { + keyChar = 0; + keyModifiers = kMenuNoModifiers; + useGlyph = false; + + strcpy (text2, entry[i]); + char *ptr = strstr (text2, "\t"); + if (ptr) + { + *ptr = '\0'; + ptr++; + if (strlen (ptr) > 0) + { + if (!strstr (ptr, "Ctrl")) + keyModifiers |= kMenuNoCommandModifier; + if (strstr (ptr, "Alt")) + keyModifiers |= kMenuOptionModifier; + if (strstr (ptr, "Shift")) + keyModifiers |= kMenuShiftModifier; + if (strstr (ptr, "Apple")) + keyModifiers |= kMenuControlModifier; + + if (!strncmp (ptr, "Del", 3)) + keyChar = 0x17; + else if (!strncmp (ptr, "Left", 4)) + { + keyChar = 0x64; + useGlyph = true; + } + else if (!strncmp (ptr, "Right", 5)) + { + keyChar = 0x65; + useGlyph = true; + } + else if (!strncmp (ptr, "Up", 2)) + { + keyChar = 0x68; + useGlyph = true; + } + else if (!strncmp (ptr, "Down", 4)) + { + keyChar = 0x6a; + useGlyph = true; + } + else + keyChar = (long)ptr[strlen (ptr) - 1]; + } + else + { + keyModifiers = kMenuNoCommandModifier; + keyChar = (long)*ptr; + } + } + #if TARGET_API_MAC_CARBON + + if (!strcmp (entry[i], kMenuSeparator)) + { + AppendMenuItemTextWithCFString (theMenu, CFSTR(""), kMenuItemAttrSeparator, 0, NULL); + } + else + { + CFStringRef itemString = 0; + MenuItemAttributes itemAttribs = kMenuItemAttrIgnoreMeta; + // Submenu + if (!strncmp (entry[i], kMenuSubMenu, 2)) + { + if (idxSubmenu < nbSubMenus) + { + itemString = CFStringCreateWithCString (NULL, entry[i] + 2, kCFStringEncodingUTF8); + InsertMenuItemTextWithCFString (theMenu, itemString, i+1, itemAttribs, 0); + CFRelease (itemString); + void *submenu = submenuEntry[idxSubmenu]->appendItems (offsetIdx); + if (submenu) + { + SetMenuItemHierarchicalID (theMenu, i + 1, submenuEntry[idxSubmenu]->getMenuID ()); + idxSubmenu++; + continue; + } + else + continue; + } + else + continue; + } + //---Disable/Gray entry----------- + else if (!strncmp (entry[i], kMenuDisable, 2)) + { + itemString = CFStringCreateWithCString (NULL, entry[i] + 2, kCFStringEncodingUTF8); + itemAttribs |= kMenuItemAttrDisabled; + } + //---Disable entry-------- + else if (!strncmp (entry[i], kMenuTitle, 2)) + { + itemString = CFStringCreateWithCString (NULL, entry[i] + 2, kCFStringEncodingUTF8); + itemAttribs |= kMenuItemAttrSectionHeader; + } + else + itemString = CFStringCreateWithCString (NULL, entry[i], kCFStringEncodingUTF8); + + InsertMenuItemTextWithCFString (theMenu, itemString, i+1, itemAttribs, 0); + CFRelease (itemString); + } + + #else + Str255 menuItem; + strcpy ((char*)menuItem, (const char*)"\p\0"); + menuItem[0] = strlen ((const char*)text2); + AppendMenu (theMenu, "\pjunk"); + + if (!strncmp (text2, kMenuTitle, 2) || !strncmp (text2, kMenuDisable, 2) || !strncmp (text2, kMenuSubMenu, 2)) + { + menuItem[0] -= 2; + strcat ((char*)menuItem, text2 + 2); + + //---Disable item-------- + if (!strncmp (text2, kMenuDisable, 2)) + { + #if TARGET_API_MAC_CARBON + DisableMenuItem (theMenu, i + 1); + #else + DisableItem (theMenu, i + 1); + #endif + } + //---Submenu------------- + else if (!strncmp (text2, kMenuSubMenu, 2)) + { + if (idxSubmenu < nbSubMenus) + { + void *submenu = submenuEntry[idxSubmenu]->appendItems (offsetIdx); + if (submenu) + { + SetMenuItemHierarchicalID (theMenu, i + 1, submenuEntry[idxSubmenu]->getMenuID ()); + idxSubmenu++; + } + else + continue; + } + else + continue; + } + } + else + { + strcat ((char*)menuItem, text2); + } + SetMenuItemText (theMenu, i + 1, menuItem); + + #endif // !TARGET_API_MAC_CARBON + + //---Set the shortcut + if (keyChar != 0) + { + SetItemCmd (theMenu, i + 1, keyChar); + if (useGlyph) + SetMenuItemKeyGlyph (theMenu, i + 1, keyChar); + SetMenuItemModifiers (theMenu, i + 1, keyModifiers); + } + + if (multipleCheck && check[i]) + CheckMenuItem (theMenu, i + 1, true); + + } + + // set the check + if (style & kCheckStyle && !multipleCheck) + CheckMenuItem (theMenu, currentIndex + 1, true); + + InsertMenu ((MenuHandle)theMenu, -1); + + platformControl = (void*)theMenu; + return platformControl; +#endif +} + +//------------------------------------------------------------------------ +void COptionMenu::setValue (float val) +{ + if ((long)val < 0 || (long)val >= nbEntries) + return; + + currentIndex = (long)val; + if (style & (kMultipleCheckStyle & ~kCheckStyle)) + check[currentIndex] = !check[currentIndex]; + CParamDisplay::setValue (val); + + // to force the redraw + setDirty (); +} + +//------------------------------------------------------------------------ +void COptionMenu::takeFocus (CDrawContext *pContext) +{ + if (!getFrame ()) + return; + + bool multipleCheck = style & (kMultipleCheckStyle & ~kCheckStyle); + lastResult = -1; + lastMenu = 0; + +#if MAC || WINDOWS + // calculate Screen Position + #if WINDOWS + HWND hwnd = (HWND)getFrame ()->getSystemWindow (); + + #endif + + CRect rect; + if (pContext) + { + rect.left = pContext->offsetScreen.h; + rect.top = pContext->offsetScreen.v; + } + else + { + #if WINDOWS + RECT rctWinParent; + GetWindowRect (hwnd, &rctWinParent); + rect.left = rctWinParent.left; + rect.top = rctWinParent.top; + #elif QUARTZ + HIRect bounds; + HIViewRef control = (HIViewRef)getFrame ()->getPlatformControl (); + HIViewGetFrame (control, &bounds); + WindowRef window = (WindowRef)getFrame ()->getSystemWindow (); + WindowAttributes attr; + GetWindowAttributes (window, &attr); + if (attr & kWindowCompositingAttribute) + { + HIViewRef contentView; + HIViewFindByID (HIViewGetRoot (window), kHIViewWindowContentID, &contentView); + if (HIViewGetSuperview (control) != contentView) + HIViewConvertRect (&bounds, control, contentView); + bounds.origin.x += getFrame ()->hiScrollOffset.x; + bounds.origin.y += getFrame ()->hiScrollOffset.y; + } + rect.left = (CCoord)bounds.origin.x; + rect.top = (CCoord)bounds.origin.y; + #endif + } + CView* parent = getParentView (); + while (parent) + { + if (parent->notify (this, kMsgCheckIfViewContainer) == kMessageNotified) + { + CRect vSize; + parent->getViewSize (vSize); + rect.offset (vSize.left, vSize.top); + } + parent = parent->getParentView (); + } +#endif + +#if WINDOWS + MSG msg; + long result = -1; + + //---Create the popup menu--- + long offIdx = 0; + appendItems (offIdx); + + //---Popup the menu--- + long offset; + if (style & kPopupStyle) + offset = (long)(rect.top + size.top); + else + offset = (long)(rect.top + size.bottom); + + int flags = TPM_LEFTALIGN; + if (lastButton & kRButton) + flags |= TPM_RIGHTBUTTON; + + if (TrackPopupMenu ((HMENU)platformControl, flags, + (int)(rect.left + size.left), offset, 0, hwnd, 0)) + { + if (PeekMessage (&msg, hwnd, WM_COMMAND, WM_COMMAND, PM_REMOVE)) + { + if (HIWORD (msg.wParam) == 0) + { + result = LOWORD (msg.wParam); + lastResult = result; + } + } + } + + //---Destroy the menu---- + removeItems (); + + //---Update the dependencies + if (result != -1 || bgWhenClick) + { + CDrawContext *pContextTemp = 0; + HDC hdc; + if (!pContext && result != -1) + { + // create a local context + hdc = GetDC (hwnd); + pContextTemp = new CDrawContext (getFrame (), hdc, hwnd); + } + else + pContextTemp = pContext; + + // to force the redraw + if (bgWhenClick) + setDirty (); + + if (result != -1) + { + long idx = 0; + offIdx = 0; + COptionMenu *menu = getItemMenu (result, idx, offIdx); + if (menu) + { + lastMenu = menu; + menu->setValue ((float)idx); + + // update dependency + if (listener) + listener->valueChanged (pContextTemp, menu); + } + } + + // redraw the display + // AAAAARRRRGHHHHHHHHHHHHH!! + //doIdleStuff (); + //setDirty (false); + + if (!pContext && pContextTemp) + { + delete pContextTemp; + ReleaseDC (hwnd, hdc); + } + } + +#elif MAC + // no entries, no menu + if (nbEntries == 0) + { + endEdit(); + getFrame ()->setFocusView (0); + return; + } + + //---Transform local coordinates to global coordinates + long offset; + + if (style & kPopupStyle) + offset = (long)size.top; + else + offset = (long)size.bottom; + + CCoord gx = 0, gy = 0; + Point LToG; + getFrame()->getPosition(gx, gy); + LToG.v = (short)(gy + rect.top + offset); + LToG.h = (short)(gx + rect.left + size.left); + + //---Create the popup menu--- + long offIdx = 0; + MenuHandle theMenu = (MenuHandle)appendItems (offIdx); + + // Calculate the menu size (height and width) + CalcMenuSize (theMenu); + + // Get a handle to the screen + RgnHandle rgn = GetGrayRgn (); + #if TARGET_API_MAC_CARBON + Rect bounds; + GetRegionBounds (rgn, &bounds); + int bottom = bounds.bottom; + long menuHeight = GetMenuHeight (theMenu); + #else + int bottom = (*rgn)->rgnBBox.bottom; + long menuHeight = (*theMenu)->menuHeight; + #endif + + // Calculate the size of one menu item (round to the next int) + int menuItemSize = (menuHeight + nbEntries - 1) / nbEntries; + + setDirty (false); + + //---Popup the Menu + long popUpItem = 1; + long PopUpMenuItem = 0; + + if (LToG.v + menuHeight >= bottom - menuItemSize / 2) + { + if (nbEntries * menuItemSize >= bottom) + { + popUpItem = currentIndex + 2; + if (popUpItem > nbEntries) + popUpItem = nbEntries; + } + if (nbEntries * menuItemSize >= bottom) + PopUpMenuItem = PopUpMenuSelect (theMenu, LToG.v, LToG.h, popUpItem); + else + PopUpMenuItem = PopUpMenuSelect (theMenu, bottom - menuHeight - menuItemSize, LToG.h, popUpItem); + } + else + PopUpMenuItem = PopUpMenuSelect (theMenu, LToG.v, LToG.h, popUpItem); + + //---Destroy the menu---- + removeItems (); + + // HiWord indicates MenuID, LoWord indicates the item index + short result = LoWord (PopUpMenuItem) - 1; + lastResult = result; + short menuIDResult = HiWord (PopUpMenuItem); + if (menuIDResult != 0 || bgWhenClick) + { + // to force the redraw + if (bgWhenClick) + setDirty (); + + if (!pContext && menuIDResult != 0) + { + pContext = getFrame ()->createDrawContext (); + } + else if (pContext) + pContext->remember (); + + if (menuIDResult != 0) + { + long idx = 0; + offIdx = menuIDResult; + COptionMenu *menu = getItemMenu (result, idx, offIdx); + if (menu) + { + lastMenu = menu; + menu->setValue (result); + if (listener) + listener->valueChanged (pContext, menu); + } + } + + if (pContext) + pContext->forget (); + } + +#elif MOTIF + Arg args[10]; + int n = 0; + + // get the position of the pParent + CRect rect; + getFrame ()->getSize (&rect); + + if (pContext) + { + rect.left += pContext->offset.h; + rect.top += pContext->offset.v; + } + + // create a popup menu + int offset; + if (style & kPopupStyle) + offset = (int)(rect.top + size.top); + else + offset = (int)(rect.top + size.bottom); + + XtSetArg (args[n], XmNx, rect.left + size.left); n++; + XtSetArg (args[n], XmNy, offset); n++; + XtSetArg (args[n], XmNmenuHistory, currentIndex); n++; + XtSetArg (args[n], XmNtraversalOn, true); n++; + + platformControl = (void*)XmCreatePopupMenu ((Widget)(getFrame ()->getSystemWindow ()), + "popup", args, n); + + XtAddCallback ((Widget)platformControl, XmNunmapCallback, _unmapCallback, this); + + // insert the menu items + for (long i = 0; i < nbEntries; i++) + { + if (!strcmp (entry[i], kMenuSeparator)) + { + itemWidget[i] = (void*)XtCreateManagedWidget ("separator", + xmSeparatorGadgetClass, (Widget)platformControl, 0, 0); + } + else + { + if (multipleCheck) + { + itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i], + xmToggleButtonWidgetClass, (Widget)platformControl, + XmNset, check[i], XmNvisibleWhenOff, false, 0); + XtAddCallback ((Widget)itemWidget[i], XmNvalueChangedCallback, _activateCallback, this); + } + else if (style & kCheckStyle) + { + itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i], + xmToggleButtonWidgetClass, (Widget)platformControl, + XmNset, (i == currentIndex) ? true : false, XmNvisibleWhenOff, false, 0); + XtAddCallback ((Widget)itemWidget[i], XmNvalueChangedCallback, _activateCallback, this); + } + else + { + itemWidget[i] = (void*)XtVaCreateManagedWidget (entry[i], + xmPushButtonWidgetClass, (Widget)platformControl, 0); + XtAddCallback ((Widget)itemWidget[i], XmNactivateCallback, _activateCallback, this); + } + } + } + + XtManageChild ((Widget)platformControl); + +#elif BEOS + BPopUpMenu* popup = new BPopUpMenu ("popup", false, false); + BMessage* message; + BMenuItem* item; + for (long i = 0; i < nbEntries; i++) + { + if (strcmp (entry[i], kMenuSeparator) == 0) + popup->AddSeparatorItem (); + else + { + message = new BMessage (i); + item = new BMenuItem (entry[i], message); + popup->AddItem (item); + if (multipleCheck) + { + if (check[i]) + item->SetMarked (true); + } + else if ((style & kCheckStyle) && currentIndex == i) + item->SetMarked (true); + } + } + CRect rect; + getFrame ()->getSize (&rect); + if (pContext) + { + rect.left += pContext->offset.h; + rect.top += pContext->offset.v; + } + long offset; + if (style & kPopupStyle) + offset = (int)(rect.top + size.top); + else + offset = (int)(rect.top + size.bottom); + BPoint where (rect.left + size.left, offset); + BView* plugView = (BView*) getFrame ()->getSystemWindow (); + plugView->ConvertToScreen (&where); + item = popup->Go (where); + if (item) + { + message = item->Message (); + if (message) + { + CDrawContext *pContextTemp = pContext; + // create a local context + if (!pContextTemp) + pContextTemp = new CDrawContext (getFrame (), plugView, NULL); + + setValue (message->what); + + if (listener) + listener->valueChanged (pContextTemp, this); + + // redraw the display + draw (pContextTemp); + + if (!pContext && pContextTemp) + delete pContextTemp; + } + } + delete popup; +#endif + + getFrame ()->setFocusView (0); + endEdit(); +} + +//------------------------------------------------------------------------ +void COptionMenu::looseFocus (CDrawContext *pContext) +{ + if (platformControl == 0) + return; + +#if WINDOWS +#elif MAC +#elif MOTIF + for (long i = 0; i < nbEntries; i++) + if (itemWidget[i]) + XtDestroyWidget ((Widget)itemWidget[i]); + + if (platformControl) + { + XtUnmanageChild ((Widget)platformControl); + XtDestroyWidget ((Widget)platformControl); + } +#endif + + platformControl = 0; +} + +#if MOTIF +//------------------------------------------------------------------------ +void COptionMenu::setCurrentSelected (void *itemSelected) +{ + // retrieve the current index + if (itemSelected != 0) + { + for (long i = 0; i < nbEntries; i++) + if (itemWidget[i] == itemSelected) + { + currentIndex = i; + break; + } + } + + // update dependency + CDrawContext *pContext = new CDrawContext (getFrame (), (void*)getFrame ()->getGC (), (void*)getFrame ()->getWindow ()); + + setValue (currentIndex); + + if (listener) + listener->valueChanged (pContext, this); + delete pContext; +} +#endif + + +//------------------------------------------------------------------------ +// CAnimKnob +//------------------------------------------------------------------------ +/*! @class CAnimKnob +Such as a CKnob control object, but there is a unique pixmap which contains different views (subpixmaps) of this knob. +According to the value, a specific subpixmap is displayed. The different subpixmaps are stacked in the pixmap object. +*/ +CAnimKnob::CAnimKnob (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) +: CKnob (size, listener, tag, background, 0, offset), bInverseBitmap (false) +{ + heightOfOneImage = size.height (); + subPixmaps = (short)(background->getHeight () / heightOfOneImage); + inset = 0; +} + +//------------------------------------------------------------------------ +CAnimKnob::CAnimKnob (const CRect &size, CControlListener *listener, long tag, + long subPixmaps, // number of subPixmaps + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset) +: CKnob (size, listener, tag, background, 0, offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage), bInverseBitmap (false) +{ + inset = 0; +} + +//------------------------------------------------------------------------ +CAnimKnob::~CAnimKnob () +{} + +//----------------------------------------------------------------------------------------------- +bool CAnimKnob::isDirty () const +{ + if (!bDirty) + { + CPoint p; + valueToPoint (p); + if (p == lastDrawnPoint) + return false; + } + return CKnob::isDirty (); +} + +//------------------------------------------------------------------------ +void CAnimKnob::draw (CDrawContext *pContext) +{ + CPoint where (0, 0); + if (value >= 0.f) + { + CCoord tmp = heightOfOneImage * (subPixmaps - 1); + if (bInverseBitmap) + where.v = (long)((1 - value) * (float)tmp); + else + where.v = (long)(value * (float)tmp); + for (CCoord realY = 0; realY <= tmp; realY += heightOfOneImage) + { + if (where.v < realY) + { + where.v = realY - heightOfOneImage; + if (where.v < 0) + where.v = 0; + break; + } + } + } + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + valueToPoint (lastDrawnPoint); + setDirty (false); +} + +//------------------------------------------------------------------------ +// CVerticalSwitch +//------------------------------------------------------------------------ +/*! @class CVerticalSwitch +Define a switch with a given number of positions, the current position is defined by the position +of the last click on this object (the object is divided in its height by the number of position). +Each position has its subpixmap, each subpixmap is stacked in the given handle pixmap. +By clicking Alt+Left Mouse the default value is used. +*/ +CVerticalSwitch::CVerticalSwitch (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset) +{ + heightOfOneImage = size.height (); + subPixmaps = (long)(background->getHeight () / heightOfOneImage); + iMaxPositions = subPixmaps; + + setDefaultValue (0.f); +} + +//------------------------------------------------------------------------ +CVerticalSwitch::CVerticalSwitch (const CRect &size, CControlListener *listener, long tag, + long subPixmaps, // number of subPixmaps + CCoord heightOfOneImage, // height of one image in pixel + long iMaxPositions, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage), + iMaxPositions (iMaxPositions) +{ + setDefaultValue (0.f); +} + +//------------------------------------------------------------------------ +CVerticalSwitch::~CVerticalSwitch () +{} + +//------------------------------------------------------------------------ +void CVerticalSwitch::draw (CDrawContext *pContext) +{ + if (pBackground) + { + // source position in bitmap + CPoint where (0, heightOfOneImage * ((long)(value * (iMaxPositions - 1) + 0.5f))); + + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void CVerticalSwitch::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + if (!(button & kLButton)) + return; + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + // check if default value wanted + if (checkDefaultValue (pContext, button)) + return; + + double coef = (double)heightOfOneImage / (double)iMaxPositions; + + // begin of edit parameter + beginEdit (); + do + { + value = (long)((where.v - size.top) / coef) / (float)(iMaxPositions - 1); + if (value > 1.f) + value = 1.f; + else if (value < 0.f) + value = 0.f; + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + while (pContext->getMouseButtons () == button); + + // end of edit parameter + endEdit (); +} + + +//------------------------------------------------------------------------ +// CHorizontalSwitch +//------------------------------------------------------------------------ +/*! @class CHorizontalSwitch +Same as the CVerticalSwitch but horizontal. +*/ +CHorizontalSwitch::CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset) +{ + heightOfOneImage = size.width (); + subPixmaps = (long)(background->getWidth () / heightOfOneImage); + iMaxPositions = subPixmaps; + + setDefaultValue (0.f); +} + +//------------------------------------------------------------------------ +CHorizontalSwitch::CHorizontalSwitch (const CRect &size, CControlListener *listener, long tag, + long subPixmaps, // number of subPixmaps + CCoord heightOfOneImage, // height of one image in pixel + long iMaxPositions, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage), + iMaxPositions (iMaxPositions) +{ + setDefaultValue (0.f); +} + +//------------------------------------------------------------------------ +CHorizontalSwitch::~CHorizontalSwitch () +{} + +//------------------------------------------------------------------------ +void CHorizontalSwitch::draw (CDrawContext *pContext) +{ + if (pBackground) + { + // source position in bitmap + CPoint where (0, heightOfOneImage * ((long)(value * (iMaxPositions - 1) + 0.5f))); + + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void CHorizontalSwitch::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + // check if default value wanted + if (checkDefaultValue (pContext, button)) + return; + + double coef = (double)pBackground->getWidth () / (double)iMaxPositions; + + // begin of edit parameter + beginEdit (); + do + { + value = (long)((where.h - size.left) / coef) / (float)(iMaxPositions - 1); + if (value > 1.f) + value = 1.f; + else if (value < 0.f) + value = 0.f; + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + while (pContext->getMouseButtons () == button); + + // end of edit parameter + endEdit (); +} + + +//------------------------------------------------------------------------ +// CRockerSwitch +//------------------------------------------------------------------------ +/*! @class CRockerSwitch +Define a rocker switch with 3 states using 3 subpixmaps. +One click on its leftside, then the first subpixmap is displayed. +One click on its rightside, then the third subpixmap is displayed. +When the mouse button is relaxed, the second subpixmap is framed. +*/ +CRockerSwitch::CRockerSwitch (const CRect &size, CControlListener *listener, long tag, // identifier tag (ID) + CBitmap *background, CPoint &offset, const long style) +: CControl (size, listener, tag, background), offset (offset), style (style) +{ + heightOfOneImage = size.width (); +} + +//------------------------------------------------------------------------ +CRockerSwitch::CRockerSwitch (const CRect &size, CControlListener *listener, long tag, // identifier tag (ID) + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset, const long style) +: CControl (size, listener, tag, background), offset (offset), + heightOfOneImage (heightOfOneImage), style (style) +{} + +//------------------------------------------------------------------------ +CRockerSwitch::~CRockerSwitch () +{} + +//------------------------------------------------------------------------ +void CRockerSwitch::draw (CDrawContext *pContext) +{ + CPoint where (offset.h, offset.v); + + if (value == 1.f) + where.v += 2 * heightOfOneImage; + else if (value == 0.f) + where.v += heightOfOneImage; + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void CRockerSwitch::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + float fEntryState = value; + + CCoord width_2 = size.width () / 2; + CCoord height_2 = size.height () / 2; + + // begin of edit parameter + beginEdit (); + + if (button) + { + do + { + if (style & kHorizontal) + { + if (where.h >= size.left && where.v >= size.top && + where.h <= (size.left + width_2) && where.v <= size.bottom) + value = -1.0f; + else if (where.h >= (size.left + width_2) && where.v >= size.top && + where.h <= size.right && where.v <= size.bottom) + value = 1.0f; + else + value = fEntryState; + } + else + { + if (where.h >= size.left && where.v >= size.top && + where.h <= size.right && where.v <= (size.top + height_2)) + value = -1.0f; + else if (where.h >= size.left && where.v >= (size.top + height_2) && + where.h <= size.right && where.v <= size.bottom) + value = 1.0f; + else + value = fEntryState; + } + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + while (pContext->getMouseButtons ()); + } + else + { + if (where.h >= size.left && where.v >= size.top && + where.h <= (size.left + width_2) && where.v <= size.bottom) + value = -1.0f; + else if (where.h >= (size.left + width_2) && where.v >= size.top && + where.h <= size.right && where.v <= size.bottom) + value = 1.0f; + + if (listener) + listener->valueChanged (pContext, this); + } + + value = 0.f; // set button to UNSELECTED state + if (listener) + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); +} + +//------------------------------------------------------------------------ +bool CRockerSwitch::onWheel (CDrawContext *pContext, const CPoint &where, float distance) +{ + if (!bMouseEnabled) + return false; + + if (distance > 0) + value = -1.0f; + else + value = 1.0f; + + // begin of edit parameter + beginEdit (); + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + value = 0.0f; // set button to UNSELECTED state + if (listener) + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + + return true; +} + + +//------------------------------------------------------------------------ +// CMovieBitmap +//------------------------------------------------------------------------ +/*! @class CMovieBitmap +A movie pixmap allows to display different subpixmaps according to its current value. +*/ +CMovieBitmap::CMovieBitmap (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) + : CControl (size, listener, tag, background), offset (offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage) +{ + heightOfOneImage = size.height (); + subPixmaps = (long)(background->getHeight () / heightOfOneImage); +} + +//------------------------------------------------------------------------ +CMovieBitmap::CMovieBitmap (const CRect &size, CControlListener *listener, long tag, + long subPixmaps, // number of subPixmaps + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset) + : CControl (size, listener, tag, background), offset (offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage) +{} + +//------------------------------------------------------------------------ +CMovieBitmap::~CMovieBitmap () +{} + +//------------------------------------------------------------------------ +void CMovieBitmap::draw (CDrawContext *pContext) +{ + CPoint where (offset.h, offset.v); + + if (value > 1.0f) + value = 1.0f; + + if (value > 0.0f) + where.v += heightOfOneImage * (int)(value * (subPixmaps - 1) + 0.5); + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + setDirty (false); +} + + +//------------------------------------------------------------------------ +// CMovieButton +//------------------------------------------------------------------------ +/*! @class CMovieButton +A movie button is a bi-states button with 2 subpixmaps. These subpixmaps are stacked in the pixmap. +*/ +CMovieButton::CMovieButton (const CRect &size, CControlListener *listener, long tag, // identifier tag (ID) + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), buttonState (value) +{ + heightOfOneImage = size.height (); +} + +//------------------------------------------------------------------------ +CMovieButton::CMovieButton (const CRect &size, CControlListener *listener, long tag, + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset) + : CControl (size, listener, tag, background), offset (offset), + heightOfOneImage (heightOfOneImage), buttonState (value) +{} + +//------------------------------------------------------------------------ +CMovieButton::~CMovieButton () +{} + +//------------------------------------------------------------------------ +void CMovieButton::draw (CDrawContext *pContext) +{ + CPoint where; + + where.h = 0; + + bounceValue (); + + if (value) + where.v = heightOfOneImage; + else + where.v = 0; + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + buttonState = value; + + setDirty (false); +} + +//------------------------------------------------------------------------ +void CMovieButton::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + // this simulates a real windows button + float fEntryState = value; + + // begin of edit parameter + beginEdit (); + + if (pContext->getMouseButtons ()) + { + do + { + if (where.h >= size.left && + where.v >= size.top && + where.h <= size.right && + where.v <= size.bottom) + value = !fEntryState; + else + value = fEntryState; + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + while (pContext->getMouseButtons () == button); + } + else + { + value = !value; + if (listener) + listener->valueChanged (pContext, this); + } + + // end of edit parameter + endEdit (); + + buttonState = value; +} + + +//------------------------------------------------------------------------ +// CAutoAnimation +//------------------------------------------------------------------------ +/*! @class CAutoAnimation +An auto-animation control contains a given number of subpixmap which can be displayed in loop. +Two functions allows to get the previous or the next subpixmap (these functions increase or decrease the current value of this control). +*/ +// displays bitmaps within a (child-) window +CAutoAnimation::CAutoAnimation (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), bWindowOpened (false) +{ + heightOfOneImage = size.height (); + subPixmaps = (long)(background->getHeight () / heightOfOneImage); + + totalHeightOfBitmap = heightOfOneImage * subPixmaps; +} + +//------------------------------------------------------------------------ +CAutoAnimation::CAutoAnimation (const CRect &size, CControlListener *listener, long tag, + long subPixmaps, // number of subPixmaps... + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset) + : CControl (size, listener, tag, background), offset (offset), + subPixmaps (subPixmaps), heightOfOneImage (heightOfOneImage), + bWindowOpened (false) +{ + totalHeightOfBitmap = heightOfOneImage * subPixmaps; +} + +//------------------------------------------------------------------------ +CAutoAnimation::~CAutoAnimation () +{} + +//------------------------------------------------------------------------ +void CAutoAnimation::draw (CDrawContext *pContext) +{ + if (isWindowOpened ()) + { + CPoint where; + where.v = (long)value + offset.v; + where.h = offset.h; + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void CAutoAnimation::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + if (!isWindowOpened ()) + { + value = 0; + openWindow (); + setDirty (); // force to redraw + if (listener) + listener->valueChanged (pContext, this); + } + else + { + // stop info animation + value = 0; // draw first pic of bitmap + setDirty (); + closeWindow (); + } +} + +//------------------------------------------------------------------------ +void CAutoAnimation::openWindow () +{ + bWindowOpened = true; +} + +//------------------------------------------------------------------------ +void CAutoAnimation::closeWindow () +{ + bWindowOpened = false; +} + +//------------------------------------------------------------------------ +void CAutoAnimation::nextPixmap () +{ + value += heightOfOneImage; + if (value >= (totalHeightOfBitmap - heightOfOneImage)) + value = 0; +} + +//------------------------------------------------------------------------ +void CAutoAnimation::previousPixmap () +{ + value -= heightOfOneImage; + if (value < 0.f) + value = (float)(totalHeightOfBitmap - heightOfOneImage - 1); +} + + +//------------------------------------------------------------------------ +// CSlider +//------------------------------------------------------------------------ +/*! @class CSlider +Define a slider with a given background and handle. +The range of variation of the handle should be defined. +By default the handler is drawn with transparency (white color). +By clicking Alt+Left Mouse the default value is used. +*/ +CSlider::CSlider (const CRect &rect, CControlListener *listener, long tag, + long iMinPos, // min position in pixel + long iMaxPos, // max position in pixel + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical) + : CControl (rect, listener, tag, background), offset (offset), pHandle (handle), + pOScreen (0), style (style), bFreeClick (true) +{ + setDrawTransparentHandle (true); + + if (pHandle) + { + pHandle->remember (); + widthOfSlider = pHandle->getWidth (); + heightOfSlider = pHandle->getHeight (); + } + else + { + widthOfSlider = 1; + heightOfSlider = 1; + } + + widthControl = size.width (); + heightControl = size.height (); + + if (style & kHorizontal) + { + minPos = iMinPos - size.left; + rangeHandle = iMaxPos - iMinPos; + CPoint p (0, 0); + setOffsetHandle (p); + } + else + { + minPos = iMinPos - size.top; + rangeHandle = iMaxPos - iMinPos; + CPoint p (0, 0); + setOffsetHandle (p); + } + + zoomFactor = 10.f; + + setWantsFocus (true); +} + +//------------------------------------------------------------------------ +CSlider::CSlider (const CRect &rect, CControlListener *listener, long tag, + CPoint &offsetHandle, // handle offset + long _rangeHandle, // size of handle range + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kBottom,kRight,kTop,kLeft,kHorizontal,kVertical) +: CControl (rect, listener, tag, background), offset (offset), pHandle (handle), + pOScreen (0), style (style), minPos (0), bFreeClick (true) +{ + setDrawTransparentHandle (true); + + if (pHandle) + { + pHandle->remember (); + widthOfSlider = pHandle->getWidth (); + heightOfSlider = pHandle->getHeight (); + } + else + { + widthOfSlider = 1; + heightOfSlider = 1; + } + + widthControl = size.width (); + heightControl = size.height (); + if (style & kHorizontal) + rangeHandle = _rangeHandle - widthOfSlider; + else + rangeHandle = _rangeHandle - heightOfSlider; + + setOffsetHandle (offsetHandle); + + zoomFactor = 10.f; + + setWantsFocus (true); +} + +//------------------------------------------------------------------------ +CSlider::~CSlider () +{ + if (pHandle) + pHandle->forget (); +} + +//------------------------------------------------------------------------ +void CSlider::setOffsetHandle (CPoint &val) +{ + offsetHandle = val; + + if (style & kHorizontal) + { + minTmp = offsetHandle.h + minPos; + maxTmp = minTmp + rangeHandle + widthOfSlider; + } + else + { + minTmp = offsetHandle.v + minPos; + maxTmp = minTmp + rangeHandle + heightOfSlider; + } +} + +//----------------------------------------------------------------------------- +bool CSlider::attached (CView *parent) +{ + if (pOScreen) + delete pOScreen; + #if !MACX + pOScreen = new COffscreenContext (getFrame (), widthControl, heightControl, kBlackCColor); + #endif + return CControl::attached (parent); +} + +//----------------------------------------------------------------------------- +bool CSlider::removed (CView *parent) +{ + if (pOScreen) + { + delete pOScreen; + pOScreen = 0; + } + return CControl::removed (parent); +} + +//------------------------------------------------------------------------ +void CSlider::draw (CDrawContext *pContext) +{ + CDrawContext* drawContext = pOScreen ? pOScreen : pContext; + + #if 1 + if (pOScreen && bTransparencyEnabled) + pOScreen->copyTo (pContext, size); + #endif + float fValue; + if (style & kLeft || style & kTop) + fValue = value; + else + fValue = 1.f - value; + + // (re)draw background + CRect rect (0, 0, widthControl, heightControl); + if (!pOScreen) + rect.offset (size.left, size.top); + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (drawContext, rect, offset); + else + pBackground->draw (drawContext, rect, offset); + } + + // calc new coords of slider + CRect rectNew; + if (style & kHorizontal) + { + rectNew.top = offsetHandle.v; + rectNew.bottom = rectNew.top + heightOfSlider; + + rectNew.left = offsetHandle.h + (int)(fValue * 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.h; + rectNew.right = rectNew.left + widthOfSlider; + + rectNew.top = offsetHandle.v + (int)(fValue * rangeHandle); + rectNew.top = (rectNew.top < minTmp) ? minTmp : rectNew.top; + + rectNew.bottom = rectNew.top + heightOfSlider; + rectNew.bottom = (rectNew.bottom > maxTmp) ? maxTmp : rectNew.bottom; + } + if (!pOScreen) + rectNew.offset (size.left, size.top); + + // draw slider at new position + if (pHandle) + { + if (bDrawTransparentEnabled) + pHandle->drawTransparent (drawContext, rectNew); + else + pHandle->draw (drawContext, rectNew); + } + + if (pOScreen) + pOScreen->copyFrom (pContext, size); + + setDirty (false); +} + +//------------------------------------------------------------------------ +void CSlider::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + // check if default value wanted + if (checkDefaultValue (pContext, button)) + return; + + // allow left mousebutton only + if (!(button & kLButton)) + return; + + CCoord delta; + if (style & kHorizontal) + delta = size.left + offsetHandle.h; + else + delta = size.top + offsetHandle.v; + if (!bFreeClick) + { + float fValue; + if (style & kLeft || style & kTop) + fValue = value; + else + fValue = 1.f - value; + CCoord actualPos; + CRect rect; + + if (style & kHorizontal) + { + actualPos = offsetHandle.h + (int)(fValue * rangeHandle) + size.left; + + rect.left = actualPos; + rect.top = size.top + offsetHandle.v; + rect.right = rect.left + widthOfSlider; + rect.bottom = rect.top + heightOfSlider; + + if (!where.isInside (rect)) + return; + else + delta += where.h - actualPos; + } + else + { + actualPos = offsetHandle.v + (int)(fValue * rangeHandle) + size.top; + + rect.left = size.left + offsetHandle.h; + rect.top = actualPos; + rect.right = rect.left + widthOfSlider; + rect.bottom = rect.top + heightOfSlider; + + if (!where.isInside (rect)) + return; + else + delta += where.v - actualPos; + } + } + else + { + if (style & kHorizontal) + delta += widthOfSlider / 2 - 1; + else + delta += heightOfSlider / 2 - 1; + } + + float oldVal = value; + long oldButton = button; + + // begin of edit parameter + beginEdit (); + + while (1) + { + button = pContext->getMouseButtons (); + if (!(button & kLButton)) + break; + + if ((oldButton != button) && (button & kShift)) + { + oldVal = value; + oldButton = button; + } + else if (!(button & kShift)) + oldVal = value; + + if (style & kHorizontal) + value = (float)(where.h - delta) / (float)rangeHandle; + else + value = (float)(where.v - delta) / (float)rangeHandle; + + if (style & kRight || style & kBottom) + value = 1.f - value; + + if (button & kShift) + value = oldVal + ((value - oldVal) / zoomFactor); + bounceValue (); + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + + // end of edit parameter + endEdit (); +} + +//------------------------------------------------------------------------ +bool CSlider::onWheel (CDrawContext *pContext, const CPoint &where, float distance) +{ + if (!bMouseEnabled) + return false; + + long buttons = pContext->getMouseButtons (); + if (buttons & kShift) + value += 0.1f * distance * wheelInc; + else + value += distance * wheelInc; + bounceValue (); + + if (isDirty () && listener) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); + } + + return true; +} + +//------------------------------------------------------------------------ +long CSlider::onKeyDown (VstKeyCode& keyCode) +{ + switch (keyCode.virt) + { + case VKEY_UP : + case VKEY_RIGHT : + case VKEY_DOWN : + case VKEY_LEFT : + { + float distance = 1.f; + if (keyCode.virt == VKEY_DOWN || keyCode.virt == VKEY_LEFT) + distance = -distance; + + if (keyCode.modifier & MODIFIER_SHIFT) + value += 0.1f * distance * wheelInc; + else + value += distance * wheelInc; + bounceValue (); + + if (isDirty () && listener) + { + // begin of edit parameter + beginEdit (); + + listener->valueChanged (0, this); + + // end of edit parameter + endEdit (); + } + } return 1; + } + return -1; +} + +//------------------------------------------------------------------------ +void CSlider::setHandle (CBitmap *_pHandle) +{ + if (pHandle) + pHandle->forget (); + pHandle = _pHandle; + if (pHandle) + { + pHandle->remember (); + widthOfSlider = pHandle->getWidth (); + heightOfSlider = pHandle->getHeight (); + } +} + + +//------------------------------------------------------------------------ +// CVerticalSlider +//------------------------------------------------------------------------ +/*! @class CVerticalSlider +This is the vertical slider. See CSlider. +*/ +CVerticalSlider::CVerticalSlider (const CRect &rect, CControlListener *listener, long tag, + long iMinPos, // min position in pixel + long iMaxPos, // max position in pixel + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kLeft, kRight) + : CSlider (rect, listener, tag, iMinPos, iMaxPos, handle, background, offset, style|kVertical) +{} + +//------------------------------------------------------------------------ +CVerticalSlider::CVerticalSlider (const CRect &rect, CControlListener *listener, long tag, + CPoint &offsetHandle, // handle offset + long rangeHandle, // size of handle range + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kLeft, kRight) +: CSlider (rect, listener, tag, offsetHandle, rangeHandle, handle, background, offset, style|kVertical) +{} + + +//------------------------------------------------------------------------ +// CHorizontalSlider +//------------------------------------------------------------------------ +/*! @class CHorizontalSlider +This is the horizontal slider. See CSlider. +*/ +CHorizontalSlider::CHorizontalSlider (const CRect &rect, CControlListener *listener, long tag, + long iMinPos, // min Y position in pixel + long iMaxPos, // max Y position in pixel + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kLeft, kRight) + : CSlider (rect, listener, tag, iMinPos, iMaxPos, handle, background, offset, style|kHorizontal) +{} + +//------------------------------------------------------------------------ +CHorizontalSlider::CHorizontalSlider (const CRect &rect, CControlListener *listener, long tag, + CPoint &offsetHandle, // handle offset + long rangeHandle, // size of handle range + CBitmap *handle, // bitmap of slider + CBitmap *background, // bitmap of background + CPoint &offset, // offset in the background + const long style) // style (kLeft, kRight) +: CSlider (rect, listener, tag, offsetHandle, rangeHandle, handle, background, offset, style|kHorizontal) +{} + + +//------------------------------------------------------------------------ +// CSpecialDigit +//------------------------------------------------------------------------ +/*! @class CSpecialDigit +Can be used to display a counter with maximum 7 digits. +All digit have the same size and are stacked in height in the pixmap. +*/ +CSpecialDigit::CSpecialDigit (const CRect &size, + CControlListener *listener, + long tag, // tag identifier + long dwPos, // actual value + long iNumbers, // amount of numbers (max 7) + long *xpos, // array of all XPOS + long *ypos, // array of all YPOS + long width, // width of ONE number + long height, // height of ONE number + CBitmap *background) // bitmap numbers + : CControl (size, listener, tag, background), + iNumbers (iNumbers), width (width), height (height) +{ + setValue ((float)dwPos); // actual value + + if (iNumbers > 7) + iNumbers = 7; + + if (xpos == NULL) + { + // automatically init xpos/ypos if not provided by caller + const int numw = (const int)background->getWidth(); + int x = (int)size.left; + for (long i = 0; i < iNumbers; i++) + { + this->xpos[i] = x; + this->ypos[i] = (long)size.top; + x += numw; + } + } + else + { + // store coordinates of x/y pos of each digit + for (long i = 0; i < iNumbers; i++) + { + this->xpos[i] = xpos[i]; + this->ypos[i] = ypos[i]; + } + } + + setMax ((float)pow (10., (double)iNumbers) - 1.0f); + setMin (0.0f); +} + +//------------------------------------------------------------------------ +CSpecialDigit::~CSpecialDigit () +{} + +//------------------------------------------------------------------------ +void CSpecialDigit::draw (CDrawContext *pContext) +{ + CPoint where; + CRect rectDest; + long i, j; + long dwValue; + long one_digit[16]; + + if ((long)value >= getMax ()) + dwValue = (long)getMax (); + else if ((long)value < getMin ()) + dwValue = (long)getMin (); + else + dwValue = (long)value; + + for (i = 0, j = ((long)getMax () + 1) / 10; i < iNumbers; i++, j /= 10) + { + one_digit[i] = dwValue / j; + dwValue -= (one_digit[i] * j); + } + + where.h = 0; + for (i = 0; i < iNumbers; i++) + { + j = one_digit[i]; + if (j > 9) + j = 9; + + rectDest.left = xpos[i]; + rectDest.top = ypos[i]; + + rectDest.right = rectDest.left + width; + rectDest.bottom = rectDest.top + height; + + // where = src from bitmap + where.v = j * height; + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, rectDest, where); + else + pBackground->draw (pContext, rectDest, where); + } + } + + setDirty (false); +} + +//------------------------------------------------------------------------ +float CSpecialDigit::getNormValue () const +{ + float fTemp; + fTemp = value / getMax (); + if (fTemp > 1.0f) + fTemp = 1.0f; + else if (fTemp < 0.0f) + fTemp = 0.0f; + + return fTemp; +} + + +//------------------------------------------------------------------------ +// CKickButton +//------------------------------------------------------------------------ +/*! @class CKickButton +Define a button with 2 states using 2 subpixmaps. +One click on it, then the second subpixmap is displayed. +When the mouse button is relaxed, the first subpixmap is framed. +*/ +CKickButton::CKickButton (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset) +{ + heightOfOneImage = size.height (); +} + +//------------------------------------------------------------------------ +CKickButton::CKickButton (const CRect &size, CControlListener *listener, long tag, + CCoord heightOfOneImage, // height of one image in pixel + CBitmap *background, CPoint &offset) +: CControl (size, listener, tag, background), offset (offset), + heightOfOneImage (heightOfOneImage) +{} + +//------------------------------------------------------------------------ +CKickButton::~CKickButton () +{} + +//------------------------------------------------------------------------ +void CKickButton::draw (CDrawContext *pContext) +{ + CPoint where (offset.h, offset.v); + + bounceValue (); + + if (value) + where.v += heightOfOneImage; + + if (pBackground) + { + if (bTransparencyEnabled) + pBackground->drawTransparent (pContext, size, where); + else + pBackground->draw (pContext, size, where); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +void CKickButton::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + // this simulates a real windows button + float fEntryState = value; + + // begin of edit parameter + beginEdit (); + + if (pContext->getMouseButtons () == kLButton) + { + do + { + if (where.h >= size.left && where.v >= size.top && + where.h <= size.right && where.v <= size.bottom) + value = !fEntryState; + else + value = fEntryState; + + if (isDirty () && listener) + listener->valueChanged (pContext, this); + + getMouseLocation (pContext, where); + + doIdleStuff (); + } + while (pContext->getMouseButtons () == kLButton); + } + else + { + value = !value; + if (listener) + listener->valueChanged (pContext, this); + } + + value = 0.0f; // set button to UNSELECTED state + if (listener) + listener->valueChanged (pContext, this); + + // end of edit parameter + endEdit (); +} + + +//------------------------------------------------------------------------ +class CSplashScreenView : public CView +{ +public: + CSplashScreenView (const CRect& size, CSplashScreen* splashScreen) + : CView (size) + , splashScreen (splashScreen) + { + setTransparency (splashScreen->getTransparency ()); + setBackground (splashScreen->getBackground ()); + } + + void draw (CDrawContext *pContext) + { + if (bTransparencyEnabled) + { + if (splashScreen->getBitmapTransparency ()) + pBackground->drawAlphaBlend (pContext, size, splashScreen->getOffset (), splashScreen->getBitmapTransparency ()); + else + pBackground->drawTransparent (pContext, size, splashScreen->getOffset ()); + } + else + pBackground->draw (pContext, size, splashScreen->getOffset ()); + setDirty (false); + } + + void mouse (CDrawContext *pContext, CPoint &where, long button) + { + if (button & kLButton) + { + splashScreen->unSplash (pContext); + getFrame ()->setDirty (true); + getFrame ()->setModalView (0); + forget (); + } + } + +protected: + CSplashScreen* splashScreen; +}; + +//------------------------------------------------------------------------ +// CSplashScreen +//------------------------------------------------------------------------ +/*! @class CSplashScreen +One click on its activated region and its pixmap is displayed, in this state the other control can not be used, +an another click on the displayed area reinstalls the normal frame. +This can be used to display a help view over the other views. +*/ +// one click draw its pixmap, an another click redraw its parent +CSplashScreen::CSplashScreen (const CRect &size, CControlListener *listener, long tag, + CBitmap *background, + CRect &toDisplay, + CPoint &offset) +: CControl (size, listener, tag, background), + toDisplay (toDisplay), offset (offset), bitmapTransparency (255) +{} + +//------------------------------------------------------------------------ +CSplashScreen::~CSplashScreen () +{} + +//------------------------------------------------------------------------ +void CSplashScreen::setBitmapTransparency (unsigned char transparency) +{ + bitmapTransparency = transparency; + setTransparency (bitmapTransparency != 255); +} + +//------------------------------------------------------------------------ +void CSplashScreen::draw (CDrawContext *pContext) +{ + if (value && pBackground) + { + if (bTransparencyEnabled) + { + if (bitmapTransparency) + pBackground->drawAlphaBlend (pContext, toDisplay, offset, bitmapTransparency); + else + pBackground->drawTransparent (pContext, toDisplay, offset); + } + else + pBackground->draw (pContext, toDisplay, offset); + } + setDirty (false); +} + +//------------------------------------------------------------------------ +bool CSplashScreen::hitTest (const CPoint& where, const long buttons) +{ + bool result = CView::hitTest (where, buttons); + if (result && !(buttons & kLButton)) + return false; + return result; +} + +//------------------------------------------------------------------------ +void CSplashScreen::mouse (CDrawContext *pContext, CPoint &where, long button) +{ + if (!bMouseEnabled) + return; + + if (button == -1) button = pContext->getMouseButtons (); + + if (listener && button & (kAlt | kShift | kControl | kApple)) + { + if (listener->controlModifierClicked (pContext, this, button) != 0) + return; + } + + if (!(button & kLButton)) + return; + + value = !value; + if (value) + { + CSplashScreenView* ssv = new CSplashScreenView (toDisplay, this); + if (getFrame () && getFrame ()->setModalView (ssv)) + { +// keepSize = size; +// size = toDisplay; +// mouseableArea = size; + if (listener) + listener->valueChanged (pContext, this); + } + setDirty (); + } +// else +// { +// size = keepSize; +// mouseableArea = size; +// if (listener) +// listener->valueChanged (pContext, this); +// if (getFrame ()) +// { +// getFrame ()->setDirty (true); +// getFrame ()->setModalView (NULL); +// } +// } +} + +//------------------------------------------------------------------------ +void CSplashScreen::unSplash (CDrawContext* pContext) +{ +// setDirty (); +// value = 0.f; +// +// size = keepSize; +// if (getFrame ()) +// { +// if (getFrame ()->getModalView () == this) +// { +// getFrame ()->setModalView (NULL); +// getFrame ()->redraw (); +// } +// } + if (value) + { + value = 0; + if (listener) + listener->valueChanged (pContext, this); + } +} + +//------------------------------------------------------------------------ +// CVuMeter +//------------------------------------------------------------------------ +CVuMeter::CVuMeter (const CRect &size, CBitmap *onBitmap, CBitmap *offBitmap, + long nbLed, const long style) + : CControl (size, 0, 0), + onBitmap (onBitmap), offBitmap (offBitmap), pOScreen (0), + nbLed (nbLed), style (style) +{ + setDecreaseStepValue (0.1f); + +#if WINDOWS && !USE_LIBPNG + setUseOffscreen (true); +#endif + + if (onBitmap) + onBitmap->remember (); + if (offBitmap) + offBitmap->remember (); + + rectOn (size.left, size.top, size.right, size.bottom); + rectOff (size.left, size.top, size.right, size.bottom); +} + +//------------------------------------------------------------------------ +CVuMeter::~CVuMeter () +{ + if (onBitmap) + onBitmap->forget (); + if (offBitmap) + offBitmap->forget (); +} + +//------------------------------------------------------------------------ +void CVuMeter::setDirty (const bool val) +{ + CView::setDirty (val); +} + +//----------------------------------------------------------------------------- +bool CVuMeter::attached (CView *parent) +{ + if (pOScreen) + delete pOScreen; + + if (bUseOffscreen) + { + pOScreen = new COffscreenContext (getFrame (), (long)size.width (), (long)size.height (), kBlackCColor); + rectOn (0, 0, size.width (), size.height ()); + rectOff (0, 0, size.width (), size.height ()); + } + else + { + rectOn (size.left, size.top, size.right, size.bottom); + rectOff (size.left, size.top, size.right, size.bottom); + } + + return CControl::attached (parent); +} + +//------------------------------------------------------------------------ +void CVuMeter::setUseOffscreen (bool val) +{ + bUseOffscreen = val; +} + +//----------------------------------------------------------------------------- +bool CVuMeter::removed (CView *parent) +{ + if (pOScreen) + { + delete pOScreen; + pOScreen = 0; + } + return CControl::removed (parent); +} + +//------------------------------------------------------------------------ +void CVuMeter::draw (CDrawContext *_pContext) +{ + if (!onBitmap) + return; + + CPoint pointOn; + CPoint pointOff; + CDrawContext *pContext = _pContext; + + bounceValue (); + + float newValue = oldValue - decreaseValue; + if (newValue < value) + newValue = value; + oldValue = newValue; + + if (bUseOffscreen) + { + if (!pOScreen) + { + pOScreen = new COffscreenContext (getFrame (), (long)size.width (), (long)size.height (), kBlackCColor); + rectOn (0, 0, size.width (), size.height ()); + rectOff (0, 0, size.width (), size.height ()); + } + pContext = pOScreen; + } + + if (style & kHorizontal) + { + CCoord tmp = (long)(((long)(nbLed * newValue + 0.5f) / (float)nbLed) * onBitmap->getWidth ()); + pointOff (tmp, 0); + if (!bUseOffscreen) + tmp += size.left; + + rectOff.left = tmp; + rectOn.right = tmp; + } + else + { + CCoord tmp = (long)(((long)(nbLed * (getMax () - newValue) + 0.5f) / (float)nbLed) * onBitmap->getHeight ()); + pointOn (0, tmp); + if (!bUseOffscreen) + tmp += size.top; + + rectOff.bottom = tmp; + rectOn.top = tmp; + } + + if (offBitmap) + { + if (bTransparencyEnabled) + offBitmap->drawTransparent (pContext, rectOff, pointOff); + else + offBitmap->draw (pContext, rectOff, pointOff); + } + + if (bTransparencyEnabled) + onBitmap->drawTransparent (pContext, rectOn, pointOn); + else + onBitmap->draw (pContext, rectOn, pointOn); + + if (pOScreen) + pOScreen->copyFrom (_pContext, size); + setDirty (false); +} + +END_NAMESPACE_VSTGUI +//------------------------------------------------------------------------ +// END. +//------------------------------------------------------------------------ |