diff options
Diffstat (limited to 'vstgui/vstgui.cpp')
| -rw-r--r-- | vstgui/vstgui.cpp | 4008 |
1 files changed, 0 insertions, 4008 deletions
diff --git a/vstgui/vstgui.cpp b/vstgui/vstgui.cpp deleted file mode 100644 index 6757b5e..0000000 --- a/vstgui/vstgui.cpp +++ /dev/null @@ -1,4008 +0,0 @@ -/* ---------------------------------------------------------------------------- - * VSTGUI for X11/LV2/PNG - * Author: David Robillard - * Released under the revised BSD license, as below - * ---------------------------------------------------------------------------- - * - * Based on: - * ---------------------------------------------------------------------------- - * VSTGUIL: Graphical User Interface Framework for VST plugins on LINUX - * Version: 0.1, Date: 2007/01/21 - * Author: kRAkEn/gORe - * - * Which was based on: - * ---------------------------------------------------------------------------- - * VSTGUI: Graphical User Interface Framework for VST plugins - * Version 3.0 $Date: 2005/08/12 12:45:00 $ - * ---------------------------------------------------------------------------- - * 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 <cstdio> -#include <cstdlib> -#include <cmath> -#include <iostream> -#include <string.h> - -#include "vstgui.h" -#include "audioeffectx.h" -#include "vstkeycode.h" - -//----------------------------------------------------------------------------- -// Some defines -//----------------------------------------------------------------------------- -#ifdef DEBUG - #define DBG(x) std::cout << x << std::endl; - #define assertfalse assert (false); -#else - #define DBG(x) - #define assertfalse -#endif - -#define USE_ALPHA_BLEND 0 -#define USE_CLIPPING_DRAWRECT 1 -#define NEW_UPDATE_MECHANISM 1 - - -//----------------------------------------------------------------------------- -// our global display -Display* display = 0; - - -//----------------------------------------------------------------------------- -// AEffGUIEditor Implementation -//----------------------------------------------------------------------------- -#define kIdleRate 100 // host idle rate in ms -#define kIdleRate2 50 -#define kIdleRateMin 4 // minimum time between 2 idles in ms - -//----------------------------------------------------------------------------- -VstInt32 AEffGUIEditor::knobMode = kCircularMode; - -//----------------------------------------------------------------------------- -AEffGUIEditor::AEffGUIEditor (AudioEffect* effect) -: AEffEditor (effect), - lLastTicks (0), - inIdleStuff (false), - frame (0) -{ - rect.left = rect.top = rect.right = rect.bottom = 0; - lLastTicks = getTicks (); - - effect->setEditor (this); -} - -//----------------------------------------------------------------------------- -AEffGUIEditor::~AEffGUIEditor () -{ -} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::setParameter (VstInt32 index, float value) -{} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::beginEdit (VstInt32 index) -{ - ((AudioEffectX*)effect)->beginEdit (index); -} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::endEdit (VstInt32 index) -{ - ((AudioEffectX*)effect)->endEdit (index); -} - -//----------------------------------------------------------------------------- -#if VST_2_1_EXTENSIONS -long AEffGUIEditor::onKeyDown (VstKeyCode& keyCode) -{ - return frame && frame->onKeyDown (keyCode) == 1 ? 1 : 0; -} - -//----------------------------------------------------------------------------- -long AEffGUIEditor::onKeyUp (VstKeyCode& keyCode) -{ - return frame && frame->onKeyUp (keyCode) == 1 ? 1 : 0; -} - -//----------------------------------------------------------------------------- -long AEffGUIEditor::setKnobMode (VstInt32 val) -{ - knobMode = val; - return 1; -} - -//----------------------------------------------------------------------------- -bool AEffGUIEditor::onWheel (float distance) -{ -/* - if (frame) - { - CDrawContext context (frame, NULL, systemWindow); - CPoint where; - context.getMouseLocation (where); - return frame->onWheel (&context, where, distance); - } -*/ - return false; -} -#endif - -//----------------------------------------------------------------------------- -long AEffGUIEditor::getRect (ERect **ppErect) -{ - *ppErect = ▭ - return 1; -} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::idle () -{ - if (inIdleStuff) - return; - - AEffEditor::idle (); - if (frame) - frame->idle (); -} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::wait (unsigned int ms) -{ - usleep (ms * 1000); -} - -//----------------------------------------------------------------------------- -unsigned int AEffGUIEditor::getTicks () -{ - return _getTicks (); -} - -//----------------------------------------------------------------------------- -void AEffGUIEditor::doIdleStuff () -{ - // get the current time - unsigned int currentTicks = getTicks (); - - // YG TEST idle (); - if (currentTicks < lLastTicks) - { - wait (kIdleRateMin); - - currentTicks += kIdleRateMin; - if (currentTicks < lLastTicks - kIdleRate2) - return; - } - - idle (); - - // save the next time - lLastTicks = currentTicks + kIdleRate; - - inIdleStuff = true; - - if (effect) - effect->masterIdle (); - - inIdleStuff = false; -} - -void AEffGUIEditor::update () -{ - if (frame) - frame->invalidate (CRect (0, 0, rect.right, rect.bottom)); -} - -//----------------------------------------------------------------------------- -//----------------------------------------------------------------------------- - -//---For Debugging------------------------ -#if DEBUG -long gNbCBitmap = 0; -long gNbCView = 0; -long gNbCDrawContext = 0; -long gNbCOffscreenContext = 0; -long gBitmapAllocation = 0; -long gNbDC = 0; -#include <stdarg.h> -void DebugPrint (const char *format, ...); -void DebugPrint (const char *format, ...) -{ - char string[300]; - va_list marker; - va_start (marker, format); - vsprintf (string, format, marker); - if (!strcmp(string, "")) - strcpy (string, "Empty string\n"); - fprintf (stderr, string); -} -#endif -//---End For Debugging------------------------ - -#include <assert.h> -#include <time.h> -#include <stdlib.h> -#include <math.h> -#include <X11/Xlib.h> -#include <X11/Xutil.h> - -#define XDRAWPARAM display, (Window)pWindow, (GC) pSystemContext -#define XWINPARAM display, (Window)pFrame->getWindow() -#define XGCPARAM display, (GC) pSystemContext - -// #define XDRAWPARAM display, (Window)pWindow, (GC)pSystemContext -// #define XWINPARAM display, (Window)pWindow -// #define XGCPARAM display, (GC)pSystemContext - -// init the static variable about font -bool gFontInit = false; -XFontStruct *gFontStructs[] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; - -struct SFontTable { const char* name; const char* string; }; - -static SFontTable gFontTable[] = { - {"SystemFont", "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"}, // kSystemFont - {"NormalFontVeryBig", "-*-fixed-*-*-*--18-*-*-*-*-*-*-*"}, // kNormalFontVeryBig - {"NormalFontBig", "-*-fixed-*-*-*--18-*-*-*-*-*-*-*"}, // kNormalFontBig - {"NormalFont", "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"}, // kNormalFont - {"NormalFontSmall", "-*-courier-*-*-*--10-*-*-*-*-*-*-*"}, // kNormalFontSmall - {"NormalFontSmaller", "-*-courier-*-*-*--9-*-*-*-*-*-*-*"}, // kNormalFontSmaller - {"NormalFontVerySmall", "-*-courier-*-*-*--8-*-*-*-*-*-*-*"}, // kNormalFontVerySmall - {"SymbolFont", "-*-fixed-*-*-*--12-*-*-*-*-*-*-*"} // kSymbolFont -}; - -long gStandardFontSize[] = { 12, 18, 18, 12, 10, 9, 8, 13 }; - -// declaration of different local functions -static long convertPoint2Angle (CPoint &pm, CPoint &pt); - -// stuff for color -long CDrawContext::nbNewColor = 0; - -//----------------------------------------------------------------------------- -bool CRect::pointInside (const CPoint& where) const -{ - return where.h >= left && where.h < right && where.v >= top && where.v < bottom; -} - -//----------------------------------------------------------------------------- -bool CRect::isEmpty () const -{ - if (right <= left) - return true; - if (bottom <= top) - return true; - return false; -} - -//----------------------------------------------------------------------------- -void CRect::bound (const CRect& rect) -{ - if (left < rect.left) - left = rect.left; - if (top < rect.top) - top = rect.top; - if (right > rect.right) - right = rect.right; - if (bottom > rect.bottom) - bottom = rect.bottom; - if (bottom < top) - bottom = top; - if (right < left) - right = left; -} - -namespace VSTGUI { - -char* bundlePath = NULL; -void setBundlePath(const char* path) { - VSTGUI::bundlePath = strdup(path); -} - -CColor kTransparentCColor = {255, 255, 255, 0}; -CColor kBlackCColor = { 0, 0, 0, 255}; -CColor kWhiteCColor = {255, 255, 255, 255}; -CColor kGreyCColor = {127, 127, 127, 255}; -CColor kRedCColor = {255, 0, 0, 255}; -CColor kGreenCColor = { 0, 255, 0, 255}; -CColor kBlueCColor = { 0, 0, 255, 255}; -CColor kYellowCColor = {255, 255, 0, 255}; -CColor kMagentaCColor = {255, 0, 255, 255}; -CColor kCyanCColor = { 0, 255, 255, 255}; - -#define kDragDelay 0 - -//----------------------------------------------------------------------------- -// CDrawContext Implementation -//----------------------------------------------------------------------------- -/** - * CDrawContext constructor. - * @param inFrame the parent CFrame - * @param inSystemContext the platform system context, can be NULL - * @param inWindow the platform window object - */ -CDrawContext::CDrawContext (CFrame *inFrame, void *inSystemContext, void *inWindow) -: pSystemContext (inSystemContext) -, pWindow (inWindow) -, pFrame (inFrame) -, fontSize (-1) -, fontStyle (0) -, fontId (kNumStandardFonts) -, frameWidth (0) -, lineStyle (kLineOnOffDash) -, drawMode (kAntialias) -{ -#if DEBUG - gNbCDrawContext++; -#endif - - // initialize values - if (pFrame) - pFrame->getViewSize (clipRect); - else - clipRect (0, 0, 1000, 1000); - - const CColor notInitalized = {0, 0, 0, 0}; - frameColor = notInitalized; - fillColor = notInitalized; - fontColor = notInitalized; - - // offsets use by offscreen - offset (0, 0); - offsetScreen (0, 0); - - // set the current font - if (pSystemContext) - { - // set the default values - setFont (kNormalFont); - setFrameColor (kWhiteCColor); - setLineStyle (kLineSolid); - setLineWidth (1); - setFont (kSystemFont); - setDrawMode (kCopyMode); - } -} - -//----------------------------------------------------------------------------- -CDrawContext::~CDrawContext () -{ -#if DEBUG - gNbCDrawContext--; -#endif -} - -//----------------------------------------------------------------------------- -void CDrawContext::setLineStyle (CLineStyle style) -{ - if (lineStyle == style) - return; - - lineStyle = style; - - long line_width; - long line_style; - if (frameWidth == 1) - line_width = 0; - else - line_width = frameWidth; - - switch (lineStyle) - { - case kLineOnOffDash: - line_style = LineOnOffDash; - break; - default: - line_style = LineSolid; - break; - } - - XSetLineAttributes (XGCPARAM, line_width, line_style, CapNotLast, JoinRound); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setLineWidth (CCoord width) -{ - if (frameWidth == width) - return; - - frameWidth = width; - - setLineStyle (lineStyle); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setDrawMode (CDrawMode mode) -{ - if (drawMode == mode) - return; - - drawMode = mode; - - long iMode = 0; - switch (drawMode) - { - case kXorMode : - iMode = GXinvert; - break; - case kOrMode : - iMode = GXor; - break; - default: - iMode = GXcopy; - } - - ((XGCValues*)pSystemContext)->function = iMode; - - XChangeGC (XGCPARAM, GCFunction, (XGCValues*)pSystemContext); -} - -//------------------------------------------------------------------------------ -void CDrawContext::setClipRect (const CRect &clip) -{ - CRect _clip (clip); - _clip.offset (offset.h, offset.v); - - if (clipRect == _clip) - return; - - clipRect = _clip; - - XRectangle r; - r.x = 0; - r.y = 0; - r.width = clipRect.right - clipRect.left + 1; - r.height = clipRect.bottom - clipRect.top + 1; - - XSetClipRectangles (XGCPARAM, clipRect.left, clipRect.top, &r, 1, Unsorted); -} - -//------------------------------------------------------------------------------ -void CDrawContext::resetClipRect () -{ - CRect newClip; - if (pFrame) - pFrame->getViewSize (newClip); - else - newClip (0, 0, 1000, 1000); - - setClipRect (newClip); - - clipRect = newClip; -} - -//----------------------------------------------------------------------------- -void CDrawContext::moveTo (const CPoint &_point) -{ - CPoint point (_point); - point.offset (offset.h, offset.v); - - penLoc = point; -} - -//----------------------------------------------------------------------------- -void CDrawContext::lineTo (const CPoint& _point) -{ - CPoint point (_point); - point.offset (offset.h, offset.v); - - CPoint start (penLoc); - CPoint end (point); - if (start.h == end.h) - { - if (start.v < -5) - start.v = -5; - else if (start.v > 10000) - start.v = 10000; - - if (end.v < -5) - end.v = -5; - else if (end.v > 10000) - end.v = 10000; - } - if (start.v == end.v) - { - if (start.h < -5) - start.h = -5; - else if (start.h > 10000) - start.h = 10000; - - if (end.h < -5) - end.h = -5; - else if (end.h > 10000) - end.h = 10000; - } - - XDrawLine (XDRAWPARAM, start.h, start.v, end.h, end.v); - - // keep trace of the new position - penLoc = point; -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawLines (const CPoint* points, const long& numLines) -{ - // default implementation, when no platform optimized code is implemented - for (long i = 0; i < numLines * 2; i+=2) - { - moveTo (points[i]); - lineTo (points[i+1]); - } -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawPolygon (const CPoint *pPoints, long numberOfPoints, const CDrawStyle drawStyle) -{ - if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked) - fillPolygon (pPoints, numberOfPoints); - if (drawStyle == kDrawStroked || drawStyle == kDrawFilledAndStroked) - polyLine (pPoints, numberOfPoints); -} - -//----------------------------------------------------------------------------- -void CDrawContext::polyLine (const CPoint *pPoints, long numberOfPoints) -{ - XPoint* pt = (XPoint*)malloc (numberOfPoints * sizeof (XPoint)); - if (!pt) - return; - for (long i = 0; i < numberOfPoints; i++) - { - pt[i].x = (short)pPoints[i].h + offset.h; - pt[i].y = (short)pPoints[i].v + offset.v; - } - - XDrawLines (XDRAWPARAM, pt, numberOfPoints, CoordModeOrigin); - - free (pt); -} - -//----------------------------------------------------------------------------- -void CDrawContext::fillPolygon (const CPoint *pPoints, long numberOfPoints) -{ - // convert the points - XPoint* pt = (XPoint*)malloc (numberOfPoints * sizeof (XPoint)); - if (!pt) - return; - for (long i = 0; i < numberOfPoints; i++) - { - pt[i].x = (short)pPoints[i].h + offset.h; - pt[i].y = (short)pPoints[i].v + offset.v; - } - - XFillPolygon (XDRAWPARAM, pt, numberOfPoints, Convex, CoordModeOrigin); - - free (pt); -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawRect (const CRect &_rect, const CDrawStyle drawStyle) -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - - XDrawRectangle (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height ()); -} - -//----------------------------------------------------------------------------- -void CDrawContext::fillRect (const CRect &_rect) -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - - // Don't draw boundary - XFillRectangle (XDRAWPARAM, rect.left + 1, rect.top + 1, rect.width () - 1, rect.height () - 1); -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawEllipse (const CRect &_rect, const CDrawStyle drawStyle) -{ - CPoint point (_rect.left + (_rect.right - _rect.left) / 2, _rect.top); - drawArc (_rect, point, point); -} - -//----------------------------------------------------------------------------- -void CDrawContext::fillEllipse (const CRect &_rect) -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - - // Don't draw boundary - CPoint point (_rect.left + ((_rect.right - _rect.left) / 2), _rect.top); - fillArc (_rect, point, point); -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawPoint (const CPoint &_point, CColor color) -{ - CPoint point (_point); - - CColor oldframecolor = frameColor; - setFrameColor (color); - - XDrawPoint (XDRAWPARAM, point.h, point.v); - - setFrameColor (oldframecolor); -} - -//----------------------------------------------------------------------------- -CColor CDrawContext::getPoint (const CPoint& _point) -{ -// CPoint point (_point); -// point.offset (offset.h, offset.v); - - assertfalse // not implemented ! - - CColor color = kBlackCColor; - return color; -} - -//----------------------------------------------------------------------------- -void CDrawContext::floodFill (const CPoint& _start) -{ -// CPoint start (_start); -// start.offset (offset.h, offset.v); - - assertfalse // not implemented ! -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawArc (const CRect &_rect, const float _startAngle, const float _endAngle, const CDrawStyle drawStyle) // in degree -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - - XDrawArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (), - (int) _startAngle * 64, (int) _endAngle * 64); -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawArc (const CRect &_rect, const CPoint &_point1, const CPoint &_point2) -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - CPoint point1 (_point1); - point1.offset (offset.h, offset.v); - CPoint point2 (_point2); - point2.offset (offset.h, offset.v); - - int angle1, angle2; - if ((point1.v == point2.v) && (point1.h == point2.h)) - { - angle1 = 0; - angle2 = 23040; // 360 * 64 - } - else - { - CPoint pm ((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2); - angle1 = convertPoint2Angle (pm, point1); - angle2 = convertPoint2Angle (pm, point2) - angle1; - if (angle2 < 0) - angle2 += 23040; // 360 * 64 - } - - XDrawArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (), - angle1, angle2); -} - -//----------------------------------------------------------------------------- -void CDrawContext::fillArc (const CRect &_rect, const CPoint &_point1, const CPoint &_point2) -{ - CRect rect (_rect); - rect.offset (offset.h, offset.v); - CPoint point1 (_point1); - point1.offset (offset.h, offset.v); - CPoint point2 (_point2); - point2.offset (offset.h, offset.v); - - // Don't draw boundary - int angle1, angle2; - if ((point1.v == point2.v) && (point1.h == point2.h)) - { - angle1 = 0; - angle2 = 23040; // 360 * 64 - } - else - { - CPoint pm ((rect.left + rect.right) / 2, (rect.top + rect.bottom) / 2); - angle1 = convertPoint2Angle (pm, point1); - angle2 = convertPoint2Angle (pm, point2); - } - - XFillArc (XDRAWPARAM, rect.left, rect.top, rect.width (), rect.height (), - angle1, angle2); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setFontColor (const CColor color) -{ - fontColor = color; - - setFrameColor (fontColor); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setFrameColor (const CColor color) -{ - if (frameColor == color) - return; - - frameColor = color; - - XSetForeground (XGCPARAM, getIndexColor (frameColor)); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setFillColor (const CColor color) -{ - if (fillColor == color) - return; - - fillColor = color; - - // set the background for the text - //XSetBackground (XGCPARAM, getIndexColor (fillColor)); - XSetBackground (display, pFrame->getGC(), getIndexColor (fillColor)); - - // set the foreground for the fill - setFrameColor (fillColor); -} - -//----------------------------------------------------------------------------- -void CDrawContext::setFont (CFont fontID, const long size, long style) -{ - if (fontID < 0 || fontID >= kNumStandardFonts) - fontID = kSystemFont; - - if (fontId == fontID && fontSize == (size != 0 ? size : gStandardFontSize[fontID]) && fontStyle == style) - return; - - fontStyle = style; - fontId = fontID; - if (size != 0) - fontSize = size; - else - fontSize = gStandardFontSize[fontID]; - - if (gFontStructs[fontID] != NULL) - XSetFont (display, pFrame->getGC(), gFontStructs[fontID]->fid); - else - fprintf(stderr, "ERROR: Font not defined\n"); - - // keep trace of the current font - pFontInfoStruct = gFontStructs[fontID]; - -#ifdef DEBUG -// if (!pFontInfoStruct) assert (false); // fonts have invalid pointers ! -#endif -} - -//------------------------------------------------------------------------------ -CCoord CDrawContext::getStringWidth (const char *pStr) -{ - CCoord result = 0; - - result = (long) XTextWidth (pFontInfoStruct, pStr, strlen (pStr)); - - return result; -} - -//----------------------------------------------------------------------------- -void CDrawContext::drawString (const char *string, const CRect &_rect, - const short opaque, const CHoriTxtAlign hAlign) -{ - if (!string) - return; - - CRect rect (_rect); - rect.offset (offset.h, offset.v); - - int width; - int fontHeight = pFontInfoStruct->ascent + pFontInfoStruct->descent; - int xPos; - int yPos; - int rectHeight = rect.height (); - - if (rectHeight >= fontHeight) - yPos = rect.bottom - (rectHeight - fontHeight) / 2; - else - yPos = rect.bottom; - yPos -= pFontInfoStruct->descent; - - switch (hAlign) - { - case kCenterText: - width = XTextWidth (pFontInfoStruct, string, strlen (string)); - xPos = (rect.right + rect.left - width) / 2; - break; - - case kRightText: - width = XTextWidth (pFontInfoStruct, string, strlen (string)); - xPos = rect.right - width; - break; - - default: // left adjust - xPos = rect.left + 1; - } - - if (opaque) - XDrawImageString (XDRAWPARAM, xPos, yPos, string, strlen (string)); - else - XDrawString (XDRAWPARAM, xPos, yPos, string, strlen (string)); -} - -//----------------------------------------------------------------------------- -long CDrawContext::getMouseButtons () -{ - long buttons = 0; - - Window root, child; - int rootX, rootY, childX, childY; - unsigned int mask; - - XQueryPointer (XWINPARAM, - &root, - &child, - &rootX, - &rootY, - &childX, - &childY, - &mask); - - if (mask & Button1Mask) - buttons |= kLButton; - if (mask & Button2Mask) - buttons |= kMButton; - if (mask & Button3Mask) - buttons |= kRButton; - - if (mask & ShiftMask) - buttons |= kShift; - if (mask & ControlMask) - buttons |= kControl; - if (mask & Mod1Mask) - buttons |= kAlt; - - return buttons; -} - -//----------------------------------------------------------------------------- -void CDrawContext::getMouseLocation (CPoint &point) -{ - Window root, child; - int rootX, rootY, childX, childY; - unsigned int mask; - - XQueryPointer (XWINPARAM, - &root, - &child, - &rootX, - &rootY, - &childX, - &childY, - &mask); - - point (childX, childY); - - point.offset (-offsetScreen.h, -offsetScreen.v); -} - -//----------------------------------------------------------------------------- -bool CDrawContext::waitDoubleClick () -{ - bool doubleClick = false; - - long currentTime = _getTicks (); - long clickTime = currentTime + 200; // XtGetMultiClickTime (display); - - XEvent e; - while (currentTime < clickTime) - { - if (XCheckTypedEvent (display, ButtonPress, &e)) - { - doubleClick = true; - break; - } - - currentTime = _getTicks (); - } - - return doubleClick; -} - -//----------------------------------------------------------------------------- -bool CDrawContext::waitDrag () -{ - if (!pFrame) - return false; - - CPoint mouseLoc; - getMouseLocation (mouseLoc); - CRect observe (mouseLoc.h - 2, mouseLoc.v - 2, mouseLoc.h + 2, mouseLoc.v + 2); - - long currentTime = pFrame->getTicks (); - bool wasOutside = false; - - while (((getMouseButtons () & ~(kMButton|kRButton)) & kLButton) != 0) - { - pFrame->doIdleStuff (); - if (!wasOutside) - { - getMouseLocation (mouseLoc); - if (!observe.pointInside (mouseLoc)) - { - if (kDragDelay <= 0) - return true; - wasOutside = true; - } - } - - if (wasOutside && (pFrame->getTicks () - currentTime > kDragDelay)) - return true; - } - return false; -} - -//----------------------------------------------------------------------------- -void CDrawContext::forget () -{ - CReferenceCounter::forget (); -} - -//----------------------------------------------------------------------------- -long CDrawContext::getIndexColor (CColor color) -{ - /*XColor xcol; - xcol.red = color.red << 8; - xcol.green = color.green << 8; - xcol.blue = color.blue << 8; - xcol.flags = (DoRed | DoGreen | DoBlue); - XAllocColor (display, getColormap(), &xcol); - return xcol.pixel;*/ - return (color.red << 16) + (color.green << 8) + color.blue; -} - -//----------------------------------------------------------------------------- -Colormap CDrawContext::getColormap () -{ - if (pFrame) - return pFrame->getColormap (); - else - return None; -} - -//----------------------------------------------------------------------------- -Visual* CDrawContext::getVisual () -{ - if (pFrame) - return pFrame->getVisual (); - else - return None; -} - -//----------------------------------------------------------------------------- -unsigned int CDrawContext::getDepth () -{ - if (pFrame) - return pFrame->getDepth (); - else - return None; -} - - -//----------------------------------------------------------------------------- -// COffscreenContext Implementation -//----------------------------------------------------------------------------- -COffscreenContext::COffscreenContext (CDrawContext *pContext, CBitmap *pBitmapBg, bool drawInBitmap) -: CDrawContext (pContext->pFrame, NULL, NULL) -, pBitmap (0) -, pBitmapBg (pBitmapBg) -, height (20) -, width (20) -{ - std::cout << "COffscreenContext::COffscreenContext with bitmap" << std::endl; - - if (pBitmapBg) - { - height = pBitmapBg->getHeight (); - width = pBitmapBg->getWidth (); - - clipRect (0, 0, width, height); - } - -#if DEBUG - gNbCOffscreenContext++; - gBitmapAllocation += (long)height * (long)width; -#endif - - bDestroyPixmap = false; - -// Window root = RootWindow (display, DefaultScreen (display)); - - // if no bitmap handle => create one - if (! pWindow) - { - pWindow = (void*) XCreatePixmap (display, pFrame->getWindow(), width, height, pFrame->getDepth ()); - bDestroyPixmap = true; - } - - // set the current font - if (pSystemContext) - setFont (kNormalFont); - - if (!drawInBitmap) - { - // draw bitmap to Offscreen - CRect r (0, 0, width, height); - if (pBitmapBg) - pBitmapBg->draw (this, r); - else - { - setFillColor (kBlackCColor); - fillRect (r); - } - } -} - -//----------------------------------------------------------------------------- -COffscreenContext::COffscreenContext (CFrame *pFrame, long width, long height, const CColor backgroundColor) -: CDrawContext (pFrame, NULL, NULL) -, pBitmap (0) -, pBitmapBg (0) -, height (height) -, width (width) -, backgroundColor (backgroundColor) -{ - std::cout << "COffscreenContext::COffscreenContext without bitmap" << std::endl; - - clipRect (0, 0, width, height); - -#if DEBUG - gNbCOffscreenContext++; - gBitmapAllocation += height * width; -#endif - - bDestroyPixmap = true; - - pWindow = (void*) XCreatePixmap (display, - pFrame->getWindow(), - width, - height, - pFrame->getDepth ()); - -/* - // clear the pixmap - XGCValues values; - values.foreground = getIndexColor (backgroundColor); - GC gc = XCreateGC (display, (Window)pWindow, GCForeground, &values); - XFillRectangle (display, (Window)pWindow, gc, 0, 0, width, height); - XFreeGC (display, gc); -*/ - - XGCValues values; - values.foreground = getIndexColor (backgroundColor); - pSystemContext = XCreateGC (display, (Window)pWindow, GCForeground, &values); - XFillRectangle (display, (Window)pWindow, (GC) pSystemContext, 0, 0, width, height); - - // set the current font - if (pSystemContext) - setFont (kNormalFont); -} - -//----------------------------------------------------------------------------- -COffscreenContext::~COffscreenContext () -{ -#if DEBUG - gNbCOffscreenContext--; - gBitmapAllocation -= (long)height * (long)width; -#endif - - if (pBitmap) - pBitmap->forget (); - - if (bDestroyPixmap && pWindow) - XFreePixmap (display, (Pixmap)pWindow); - - if (pSystemContext) - XFreeGC (display, (GC) pSystemContext); -} - -//----------------------------------------------------------------------------- -void COffscreenContext::copyTo (CDrawContext* pContext, CRect& srcRect, CPoint destOffset) -{ - std::cout << "COffscreenContext::copyTo" << std::endl; - - XCopyArea (display, - (Drawable) pContext->pWindow, - (Drawable) pWindow, - (GC) pSystemContext, - srcRect.left, - srcRect.top, - srcRect.width (), - srcRect.height (), - destOffset.h, - destOffset.v); -} - -//----------------------------------------------------------------------------- -void COffscreenContext::copyFrom (CDrawContext *pContext, CRect destRect, CPoint srcOffset) -{ - //std::cout << "COffscreenContext::copyFrom "; - - XCopyArea (display, - (Drawable) pContext->pWindow, - (Drawable) pWindow, - (GC) pSystemContext, - srcOffset.h, - srcOffset.v, - destRect.width(), - destRect.height(), - destRect.left, - destRect.top); - - pContext->setFrameColor (kRedCColor); - pContext->drawRect (destRect); -} - - -//----------------------------------------------------------------------------- -class CAttributeListEntry -{ -public: - CAttributeListEntry (long size, CViewAttributeID id) - : nextEntry (0) - , pointer (0) - , sizeOfPointer (size) - , id (id) - { - pointer = malloc (size); - } - - ~CAttributeListEntry () - { - if (pointer) - free (pointer); - } - - CViewAttributeID getID () const { return id; } - long getSize () const { return sizeOfPointer; } - void* getPointer () const { return pointer; } - CAttributeListEntry* getNext () const { return nextEntry; } - - void setNext (CAttributeListEntry* entry) { nextEntry = entry; } - -protected: - CAttributeListEntry () : nextEntry (0), pointer (0), sizeOfPointer (0), id (0) {} - - CAttributeListEntry* nextEntry; - void* pointer; - long sizeOfPointer; - CViewAttributeID id; -}; - -//----------------------------------------------------------------------------- -const char* kMsgCheckIfViewContainer = "kMsgCheckIfViewContainer"; - -//----------------------------------------------------------------------------- -// CView -//----------------------------------------------------------------------------- -/*! @class CView -base class of all view objects -*/ -//----------------------------------------------------------------------------- -CView::CView (const CRect& size) -: size (size) -, mouseableArea (size) -, pParentFrame (0) -, pParentView (0) -, bDirty (false) -, bMouseEnabled (true) -, bTransparencyEnabled (false) -, bWantsFocus (false) -, bVisible (true) -, pBackground (0) -, pAttributeList (0) -{ -#if DEBUG - gNbCView++; -#endif -} - -//----------------------------------------------------------------------------- -CView::~CView () -{ - if (pBackground) - pBackground->forget (); - - if (pAttributeList) - { - CAttributeListEntry* entry = pAttributeList; - while (entry) - { - CAttributeListEntry* nextEntry = entry->getNext (); - delete entry; - entry = nextEntry; - } - } -#if DEBUG - gNbCView--; -#endif -} - -//----------------------------------------------------------------------------- -void CView::getMouseLocation (CDrawContext* context, CPoint &point) -{ - if (context) - { - if (pParentView && pParentView->notify (this, kMsgCheckIfViewContainer) == kMessageNotified) - { - CCoord save[4]; - ((CViewContainer*)pParentView)->modifyDrawContext (save, context); - pParentView->getMouseLocation (context, point); - ((CViewContainer*)pParentView)->restoreDrawContext (context, save); - } - else - context->getMouseLocation (point); - } -} - -//----------------------------------------------------------------------------- -CPoint& CView::frameToLocal (CPoint& point) const -{ - if (pParentView && pParentView->isTypeOf ("CViewContainer")) - return pParentView->frameToLocal (point); - return point; -} - -//----------------------------------------------------------------------------- -CPoint& CView::localToFrame (CPoint& point) const -{ - if (pParentView && pParentView->isTypeOf ("CViewContainer")) - return pParentView->localToFrame (point); - return point; -} - -//----------------------------------------------------------------------------- -void CView::redraw () -{ - if (pParentFrame) - pParentFrame->draw (this); -} - -//----------------------------------------------------------------------------- -void CView::redrawRect (CDrawContext* context, const CRect& rect) -{ - if (pParentView) - pParentView->redrawRect (context, rect); - else if (pParentFrame) - pParentFrame->drawRect (context, rect); -} - -//----------------------------------------------------------------------------- -void CView::draw (CDrawContext *pContext) -{ - if (pBackground) - { - if (bTransparencyEnabled) - pBackground->drawTransparent (pContext, size); - else - pBackground->draw (pContext, size); - } - setDirty (false); -} - -//----------------------------------------------------------------------------- -void CView::mouse (CDrawContext *pContext, CPoint &where, long buttons) -{} - -//----------------------------------------------------------------------------- -bool CView::onWheel (CDrawContext *pContext, const CPoint &where, float distance) -{ - return false; -} - -//------------------------------------------------------------------------ -bool CView::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance) -{ - return onWheel (pContext, where, distance); -} - -//------------------------------------------------------------------------ -void CView::update (CDrawContext *pContext) -{ - if (isDirty ()) - { -#if NEW_UPDATE_MECHANISM - if (pContext) - redrawRect (pContext, size); - else - redraw (); -#else - #if USE_ALPHA_BLEND - if (pContext) - { - if (bTransparencyEnabled) - getFrame ()->drawRect (pContext, size); - else - draw (pContext); - } - #else - if (pContext) - draw (pContext); - #endif - else - redraw (); -#endif - setDirty (false); - } -} - -//------------------------------------------------------------------------------ -long CView::onKeyDown (VstKeyCode& keyCode) -{ - return -1; -} - -//------------------------------------------------------------------------------ -long CView::onKeyUp (VstKeyCode& keyCode) -{ - return -1; -} - -//------------------------------------------------------------------------------ -long CView::notify (CView* sender, const char* message) -{ - return kMessageUnknown; -} - -//------------------------------------------------------------------------------ -void CView::looseFocus (CDrawContext *pContext) -{} - -//------------------------------------------------------------------------------ -void CView::takeFocus (CDrawContext *pContext) -{} - -//------------------------------------------------------------------------------ -void CView::setViewSize (CRect &rect) -{ - size = rect; - setDirty (); -} - -//----------------------------------------------------------------------------- -void *CView::getEditor () const -{ - return pParentFrame ? pParentFrame->getEditor () : 0; -} - -//----------------------------------------------------------------------------- -void CView::setBackground (CBitmap *background) -{ - if (pBackground) - pBackground->forget (); - pBackground = background; - if (pBackground) - pBackground->remember (); - setDirty (true); -} - -//----------------------------------------------------------------------------- -const CViewAttributeID kCViewAttributeReferencePointer = (CViewAttributeID) "cvrp"; - -//----------------------------------------------------------------------------- -/** - * @param id the ID of the Attribute - * @param outSize on return the size of the attribute - */ -bool CView::getAttributeSize (const CViewAttributeID id, long& outSize) const -{ - if (pAttributeList) - { - CAttributeListEntry* entry = pAttributeList; - while (entry) - { - if (entry->getID () == id) - break; - entry = entry->getNext (); - } - if (entry) - { - outSize = entry->getSize (); - return true; - } - } - return false; -} - -//----------------------------------------------------------------------------- -/** - * @param id the ID of the Attribute - * @param inSize the size of the outData pointer - * @param outData a pointer where to copy the attribute data - * @param outSize the size in bytes which was copied into outData - */ -bool CView::getAttribute (const CViewAttributeID id, const long inSize, void* outData, long& outSize) const -{ - if (pAttributeList) - { - CAttributeListEntry* entry = pAttributeList; - while (entry) - { - if (entry->getID () == id) - break; - entry = entry->getNext (); - } - if (entry && inSize >= entry->getSize ()) - { - outSize = entry->getSize (); - memcpy (outData, entry->getPointer (), outSize); - return true; - } - } - return false; -} - -//----------------------------------------------------------------------------- -/** - * copies data into the attribute. If it does not exist, creates a new attribute. - * @param id the ID of the Attribute - * @param inSize the size of the outData pointer - * @param inData a pointer to the data - */ -bool CView::setAttribute (const CViewAttributeID id, const long inSize, void* inData) -{ - CAttributeListEntry* lastEntry = 0; - if (pAttributeList) - { - CAttributeListEntry* entry = pAttributeList; - while (entry) - { - if (entry->getID () == id) - break; - if (entry->getNext () == 0) - lastEntry = entry; - entry = entry->getNext (); - } - if (entry) - { - if (entry->getSize () >= inSize) - { - memcpy (entry->getPointer (), inData, inSize); - return true; - } - else - return false; - } - } - - // create a new attribute - CAttributeListEntry* newEntry = new CAttributeListEntry (inSize, id); - memcpy (newEntry->getPointer (), inData, inSize); - if (lastEntry) - lastEntry->setNext (newEntry); - else if (!pAttributeList) - pAttributeList = newEntry; - else - { - delete newEntry; - return false; - } - return true; -} - -#if DEBUG -//----------------------------------------------------------------------------- -void CView::dumpInfo () -{ - CRect viewRect = getViewSize (viewRect); - DebugPrint ("left:%4d, top:%4d, width:%4d, height:%4d ", viewRect.left, viewRect.top, viewRect.getWidth (), viewRect.getHeight ()); - if (getMouseEnabled ()) - DebugPrint ("(Mouse Enabled) "); - if (getTransparency ()) - DebugPrint ("(Transparent) "); - CRect mouseRect = getMouseableArea (mouseRect); - if (mouseRect != viewRect) - DebugPrint (" (Mouseable Area: left:%4d, top:%4d, width:%4d, height:%4d ", mouseRect.left, mouseRect.top, mouseRect.getWidth (), mouseRect.getHeight ()); -} -#endif - -#define FOREACHSUBVIEW for (CCView *pSv = pFirstView; pSv; pSv = pSv->pNext) {CView *pV = pSv->pView; -#define FOREACHSUBVIEW_REVERSE(reverse) for (CCView *pSv = reverse ? pLastView : pFirstView; pSv; pSv = reverse ? pSv->pPrevious : pSv->pNext) {CView *pV = pSv->pView; -#define ENDFOR } - -//----------------------------------------------------------------------------- -// CFrame Implementation -//----------------------------------------------------------------------------- -/*! @class CFrame -It creates a platform dependend view object. -On classic Mac OS it just draws into the provided window. -On Mac OS X it is a ControlRef. -On Windows it's a WS_CHILD Window. -*/ -CFrame::CFrame (const CRect &inSize, void *inSystemWindow, void *inEditor) -: CViewContainer (inSize, 0, 0) -, pEditor (inEditor) -, pModalView (0) -, pFocusView (0) -, bFirstDraw (true) -, bDropActive (false) -, bUpdatesDisabled (false) -, pSystemWindow ((Window)inSystemWindow) -, pFrameContext (0) -, bAddedWindow (false) -, defaultCursor (0) -{ - setOpenFlag (true); - - pParentFrame = this; - - depth = 0; - pVisual = 0; - window = 0; - gc = 0; - - if (display == NULL) - display = XOpenDisplay(NULL); - - initFrame ((void*)pSystemWindow); - backBuffer = XdbeAllocateBackBufferName(display, (Window)window, XdbeUndefined); - - XGCValues values; - values.foreground = 1; - gc = XCreateGC (display, (Window)backBuffer, GCForeground, &values); - - pFrameContext = new CDrawContext (this, gc, (void*)backBuffer); -} - -//----------------------------------------------------------------------------- -CFrame::~CFrame () -{ - if (pModalView) - removeView (pModalView, false); - - setCursor (kCursorDefault); - - setDropActive (false); - - if (pFrameContext) - pFrameContext->forget (); - - if (getOpenFlag ()) - close (); - - if (window) - XDestroyWindow (display, (Window) window); - window = 0; - - // remove callbacks to avoid undesirable update - if (gc) - freeGc (); -} - -//----------------------------------------------------------------------------- -bool CFrame::open () -{ - if (! window) - return false; - - XMapRaised (display, window); - - return getOpenFlag (); -} - -//----------------------------------------------------------------------------- -bool CFrame::close () -{ - if (!window || !getOpenFlag () || !pSystemWindow) - return false; - - XUnmapWindow (display, window); - - return true; -} - -//----------------------------------------------------------------------------- -bool xerror; -int errorHandler (Display *dp, XErrorEvent *e) -{ - xerror = true; - return 0; -} -int getProperty (Window handle, Atom atom) -{ - int result = 0, userSize; - unsigned long bytes, userCount; - unsigned char *data; - Atom userType; - xerror = false; - XErrorHandler olderrorhandler = XSetErrorHandler (errorHandler); - XGetWindowProperty (display, handle, atom, 0, 1, false, AnyPropertyType, - &userType, &userSize, &userCount, &bytes, &data); - if (xerror == false && userCount == 1) - result = *(int*)data; - XSetErrorHandler (olderrorhandler); - return result; -} - -void eventProc (XEvent* ev) -{ - CFrame* frame = (CFrame*) getProperty (ev->xany.window, XInternAtom (display, "_this", false)); - if (frame == 0) - return; - - switch (ev->type) - { - case ButtonPress: - { - CPoint where (ev->xbutton.x, ev->xbutton.y); - frame->mouse (frame->createDrawContext(), where); - break; - } - - case MotionNotify: - { - CPoint where (ev->xbutton.x, ev->xbutton.y); - frame->mouse (frame->createDrawContext(), where); - break; - } - - case ButtonRelease: - { - break; - } - - case Expose: - { - CRect rc (ev->xexpose.x, ev->xexpose.y, - ev->xexpose.x + ev->xexpose.width, ev->xexpose.y + ev->xexpose.height); - - while (XCheckTypedWindowEvent (display, ev->xexpose.window, Expose, ev)) - { - rc.left = std::min ((int) rc.left, ev->xexpose.x); - rc.top = std::min ((int) rc.top, ev->xexpose.y); - rc.right = std::max ((int) rc.right, ev->xexpose.x + ev->xexpose.width); - rc.bottom = std::max ((int) rc.bottom, ev->xexpose.y + ev->xexpose.height); - } - - frame->drawRect (0, rc); - break; - } - - case EnterNotify: - break; - - case LeaveNotify: - { - XCrossingEvent *xevent = (XCrossingEvent*) ev; - if (frame->getFocusView ()) - { - if (xevent->x < 0 || xevent->x >= frame->getWidth () - || xevent->y < 0 || xevent->y >= frame->getHeight ()) - { - // if button pressed => don't defocus - if (xevent->state & (Button1Mask | Button2Mask | Button3Mask)) - break; - - frame->getFocusView ()->looseFocus (); - frame->setFocusView (0); - } - } - break; - } - - case ConfigureNotify: - { - frame->draw (); // @XXX - keep out ? - break; - } - } -} - -//----------------------------------------------------------------------------- -bool CFrame::initFrame (void *systemWin) -{ - if (!systemWin) - return false; - - // window attributes - XSetWindowAttributes swa; - swa.override_redirect = false; - swa.background_pixmap = None; - swa.colormap = 0; - swa.event_mask = - StructureNotifyMask | ExposureMask | KeyPressMask | KeyReleaseMask | - ButtonPressMask | ButtonReleaseMask | FocusChangeMask | PointerMotionMask | - EnterWindowMask | LeaveWindowMask | PropertyChangeMask; - - // create child window of host supplied window - window = XCreateWindow (display, (Window)systemWin, - 0, 0, size.width(), size.height(), - 0, CopyFromParent, InputOutput, (Visual*) CopyFromParent, - CWEventMask | CWOverrideRedirect | CWColormap | CWBackPixmap | CWEventMask, &swa); - - XGrabButton (display, AnyButton, AnyModifier, window, False, - ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, - GrabModeAsync, GrabModeAsync, None, None); - -#if 0 - // remove window caption/frame - #define MWM_HINTS_DECORATIONS (1L << 1) - #define PROP_MOTIF_WM_HINTS_ELEMENTS 5 - typedef struct - { - unsigned long flags; - unsigned long functions; - unsigned long decorations; - long inputMode; - unsigned long status; - } - PropMotifWmHints; - - PropMotifWmHints motif_hints; - motif_hints.flags = MWM_HINTS_DECORATIONS; - motif_hints.decorations = 0; - Atom prop = XInternAtom (display, "_MOTIF_WM_HINTS", True ); - XChangeProperty (display, window, prop, prop, 32, PropModeReplace, - (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS); -#endif - - Atom atom; - void* data = this; - atom = XInternAtom (display, "_this", false); - XChangeProperty (display, (Window)window, atom, atom, 32, - PropModeReplace, (unsigned char*)&data, 1); - - data = (void*)&eventProc; - atom = XInternAtom (display, "_XEventProc", false); - XChangeProperty (display, (Window)window, atom, atom, 32, - PropModeReplace, (unsigned char*)&data, 1); - - XGCValues values; - values.foreground = 1; - gc = XCreateGC (display, (Window)window, GCForeground, &values); - - // get the std colormap - XWindowAttributes attr; - XGetWindowAttributes (display, (Window) window, &attr); - colormap = attr.colormap; - pVisual = attr.visual; - depth = attr.depth; - - // init and load the fonts - if (! gFontInit) { - for (long i = 0; i < kNumStandardFonts; i++) { - DBG (gFontTable[i].string); - gFontStructs[i] = XLoadQueryFont (display, gFontTable[i].string); - assert (gFontStructs[i] != 0); - } - gFontInit = true; - } - - setDropActive (true); - bAddedWindow = true; - - //XReparentWindow (display, window, (Window) systemWin, 0, 0); - //XMapRaised (display, window); - - return true; -} - -//----------------------------------------------------------------------------- -bool CFrame::setDropActive (bool val) -{ - if (!bDropActive && !val) - return true; - - bDropActive = val; - return true; -} - -//----------------------------------------------------------------------------- -void CFrame::freeGc () -{ - XFreeGC (display, gc); -} - -//----------------------------------------------------------------------------- -CDrawContext* CFrame::createDrawContext () -{ - if (pFrameContext) - { - pFrameContext->remember (); - return pFrameContext; - } - - pFrameContext = new CDrawContext (this, gc, (void*)window); - - return pFrameContext; -} - -//----------------------------------------------------------------------------- -void CFrame::draw (CDrawContext *pContext) -{ - if (bFirstDraw) - bFirstDraw = false; - - bool localContext = false; - if (! pContext) - { - localContext = true; - pContext = createDrawContext (); - } - - // draw the background and the children - CViewContainer::draw (pContext); - - if (localContext) - pContext->forget (); -} - -//----------------------------------------------------------------------------- -void CFrame::drawRect (CDrawContext *pContext, const CRect& updateRect) -{ - if (bFirstDraw) - bFirstDraw = false; - - bool localContext = false; - if (! pContext) - { - localContext = true; - pContext = createDrawContext (); - } - -#if USE_CLIPPING_DRAWRECT - CRect oldClip; - pContext->getClipRect (oldClip); - CRect newClip (updateRect); - newClip.bound (oldClip); - pContext->setClipRect (newClip); -#endif - - // draw the background and the children - if (updateRect.getWidth () > 0 && updateRect.getHeight () > 0) - CViewContainer::drawRect (pContext, updateRect); - -#if USE_CLIPPING_DRAWRECT - pContext->setClipRect (oldClip); -#endif - - if (localContext) - pContext->forget (); -} - -//----------------------------------------------------------------------------- -void CFrame::draw (CView *pView) -{ - CView *pViewToDraw = 0; - - // Search it in the view list - if (pView && isChild(pView)) - pViewToDraw = pView; - - CDrawContext *pContext = createDrawContext (); - if (pContext) - { - if (pViewToDraw && pViewToDraw->isVisible()) - pViewToDraw->draw (pContext); - else - draw (pContext); - - pContext->forget (); - } -} - -//----------------------------------------------------------------------------- -void CFrame::mouse (CDrawContext *pContext, CPoint &where, long buttons) -{ -/* - XGrabPointer (display, - window, - False, - ButtonPressMask | ButtonReleaseMask | - EnterWindowMask | LeaveWindowMask | - PointerMotionMask | Button1MotionMask | - Button2MotionMask | Button3MotionMask | - Button4MotionMask | Button5MotionMask, - GrabModeAsync, - GrabModeAsync, - None, - None, - CurrentTime); -*/ - - if (!pContext) - pContext = pFrameContext; - - if (pFocusView) - setFocusView (NULL); - - if (buttons == -1 && pContext) - buttons = pContext->getMouseButtons (); - - if (pModalView && pModalView->isVisible()) - { - if (pModalView->hitTest (where, buttons)) - pModalView->mouse (pContext, where, buttons); - } - else - { - CViewContainer::mouse (pContext, where, buttons); - } - -// XUngrabPointer (display, CurrentTime); -} - -//----------------------------------------------------------------------------- -long CFrame::onKeyDown (VstKeyCode& keyCode) -{ - long result = -1; - - if (pFocusView && pFocusView->isVisible()) - result = pFocusView->onKeyDown (keyCode); - - if (result == -1 && pModalView && pModalView->isVisible()) - result = pModalView->onKeyDown (keyCode); - - if (result == -1 && keyCode.virt == VKEY_TAB) - result = advanceNextFocusView (pFocusView, (keyCode.modifier & MODIFIER_SHIFT) ? true : false) ? 1 : -1; - - return result; -} - -//----------------------------------------------------------------------------- -long CFrame::onKeyUp (VstKeyCode& keyCode) -{ - long result = -1; - - if (pFocusView && pFocusView->isVisible()) - result = pFocusView->onKeyUp (keyCode); - - if (result == -1 && pModalView && pModalView->isVisible()) - result = pModalView->onKeyUp (keyCode); - - return result; -} - -//------------------------------------------------------------------------ -bool CFrame::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance) -{ - bool result = false; - - CView *view = pModalView ? pModalView : getViewAt (where); - if (view && view->isVisible()) - { - bool localContext = false; - if (!pContext) - { - localContext = true; - pContext = createDrawContext (); - } - - result = view->onWheel (pContext, where, axis, distance); - - if (localContext) - pContext->forget (); - } - return result; -} - -//----------------------------------------------------------------------------- -bool CFrame::onWheel (CDrawContext *pContext, const CPoint &where, float distance) -{ - return onWheel (pContext, where, kMouseWheelAxisY, distance); -} - -//----------------------------------------------------------------------------- -void CFrame::update (CDrawContext *pContext) -{ - if (!getOpenFlag () || updatesDisabled ()) - return; - - CDrawContext* dc = pContext; - - if (bDirty) - { - draw (dc); - setDirty (false); - } - else - { -#if USE_CLIPPING_DRAWRECT - CRect oldClipRect; - dc->getClipRect (oldClipRect); -#endif -#if NEW_UPDATE_MECHANISM - if (pModalView && pModalView->isVisible () && pModalView->isDirty ()) - pModalView->update (dc); -#endif - FOREACHSUBVIEW -#if USE_CLIPPING_DRAWRECT - CRect viewSize (pV->size); - viewSize.bound (oldClipRect); - dc->setClipRect (viewSize); -#endif - pV->update (dc); - ENDFOR -#if USE_CLIPPING_DRAWRECT - dc->setClipRect (oldClipRect); -#endif - } -} - -//----------------------------------------------------------------------------- -void CFrame::idle () -{ - if (!getOpenFlag ()) - return; - - // don't do an idle before a draw - if (bFirstDraw) - return; - - if (!isDirty ()) - return; - - XdbeBeginIdiom(display); - XdbeSwapInfo swap_info; - swap_info.swap_window = window; - swap_info.swap_action = XdbeUndefined; - XdbeSwapBuffers(display, &swap_info, 1); - - CDrawContext *pContext = createDrawContext (); - - update (pContext); - - pContext->forget (); - - XdbeEndIdiom(display); -} - -//----------------------------------------------------------------------------- -void CFrame::doIdleStuff () -{ - if (pEditor) - ((AEffGUIEditor*)pEditor)->doIdleStuff (); -} - -//----------------------------------------------------------------------------- -unsigned long CFrame::getTicks () const -{ - if (pEditor) - return ((AEffGUIEditor*)pEditor)->getTicks (); - return 0; -} - -//----------------------------------------------------------------------------- -long CFrame::getKnobMode () const -{ - return AEffGUIEditor::getKnobMode (); -} - -//----------------------------------------------------------------------------- -bool CFrame::setPosition (CCoord x, CCoord y) -{ - size.left = 0; - size.top = 0; - - XWindowChanges attr; - attr.x = x; - attr.y = y; - - XConfigureWindow (display, window, CWX | CWY, &attr); - - return false; -} - -//----------------------------------------------------------------------------- -bool CFrame::getPosition (CCoord &x, CCoord &y) const -{ - x = size.left; - y = size.top; - return true; -} - -//----------------------------------------------------------------------------- -void CFrame::setViewSize (CRect& inRect) -{ - setSize (inRect.width (), inRect.height ()); -} - -//----------------------------------------------------------------------------- -bool CFrame::setSize (CCoord width, CCoord height) -{ - if ((width == size.width ()) && (height == size.height ())) - return false; - - // set the new size - size.right = size.left + width; - size.bottom = size.top + height; - - XResizeWindow (display, window, size.width (), size.height ()); - - CRect myViewSize (0, 0, size.width (), size.height ()); - CViewContainer::setViewSize (myViewSize); - - return true; -} - -//----------------------------------------------------------------------------- -bool CFrame::getSize (CRect *pRect) const -{ -// if (!getOpenFlag ()) -// return false; - - pRect->left = 0; - pRect->top = 0; - pRect->right = size.width () + pRect->left; - pRect->bottom = size.height () + pRect->top; - - return true; -} - -//----------------------------------------------------------------------------- -bool CFrame::getSize (CRect& outSize) const -{ - return getSize (&outSize); -} - -//----------------------------------------------------------------------------- -long CFrame::setModalView (CView *pView) -{ - // There's already a modal view so we get out - if (pView && pModalView) - return 0; - - if (pModalView) - removeView (pModalView, false); - - pModalView = pView; - if (pModalView) - addView (pModalView); - - return 1; -} - -//----------------------------------------------------------------------------- -void CFrame::beginEdit (long index) -{ - if (pEditor) - ((AEffGUIEditor*)pEditor)->beginEdit (index); -} - -//----------------------------------------------------------------------------- -void CFrame::endEdit (long index) -{ - if (pEditor) - ((AEffGUIEditor*)pEditor)->endEdit (index); -} - -//----------------------------------------------------------------------------- -CView *CFrame::getCurrentView () const -{ - if (pModalView) - return pModalView; - - return CViewContainer::getCurrentView (); -} - -//----------------------------------------------------------------------------- -bool CFrame::getCurrentLocation (CPoint &where) -{ - // create a local context - CDrawContext *pContext = createDrawContext (); - if (pContext) - { - // get the current position - pContext->getMouseLocation (where); - pContext->forget (); - } - return true; -} - -//----------------------------------------------------------------------------- -void CFrame::setCursor (CCursorType type) -{ -} - -//----------------------------------------------------------------------------- -void CFrame::setFocusView (CView *pView) -{ - if (pView && ! pView->isVisible()) - return; - - CView *pOldFocusView = pFocusView; - pFocusView = pView; - - if (pFocusView && pFocusView->wantsFocus ()) - pFocusView->setDirty (); - - if (pOldFocusView) - { - pOldFocusView->looseFocus (); - if (pOldFocusView->wantsFocus ()) - pOldFocusView->setDirty (); - } -} - -//----------------------------------------------------------------------------- -bool CFrame::advanceNextFocusView (CView* oldFocus, bool reverse) -{ - if (pModalView) - return false; // currently not supported, but should be done sometime - if (oldFocus == 0) - { - if (pFocusView == 0) - return CViewContainer::advanceNextFocusView (0, reverse); - oldFocus = pFocusView; - } - if (isChild (oldFocus)) - { - if (CViewContainer::advanceNextFocusView (oldFocus, reverse)) - return true; - else - { - setFocusView (NULL); - return false; - } - } - CView* parentView = oldFocus->getParentView (); - if (parentView && parentView->isTypeOf ("CViewContainer")) - { - CView* tempOldFocus = oldFocus; - CViewContainer* vc = (CViewContainer*)parentView; - while (vc) - { - if (vc->advanceNextFocusView (tempOldFocus, reverse)) - return true; - else - { - tempOldFocus = vc; - if (vc->getParentView () && vc->getParentView ()->isTypeOf ("CViewContainer")) - vc = (CViewContainer*)vc->getParentView (); - else - vc = 0; - } - } - } - return CViewContainer::advanceNextFocusView (oldFocus, reverse); -} - -//----------------------------------------------------------------------------- -void CFrame::invalidate (const CRect &rect) -{ - CRect rectView; - FOREACHSUBVIEW - if (pV) - { - pV->getViewSize (rectView); - if (rect.rectOverlap (rectView)) - pV->setDirty (true); - } - ENDFOR - - XClearArea (display, - window, - rect.left, - rect.top, - rect.right - rect.left, - rect.bottom - rect.top, - true); - - XSync (display, false); - -/* - XEvent ev; - memset (&ev, 0, sizeof (XEvent)); - ev.xexpose.type = Expose; - ev.xexpose.display = display; - ev.xexpose.window = (Window) window; - - ev.xexpose.x = rect.left; - ev.xexpose.y = rect.top; - ev.xexpose.width = rect.right - rect.left; - ev.xexpose.height = rect.bottom - rect.top; - - XSendEvent (display, (Window) window, False, 0L, &ev); - XFlush (display); -*/ -} - -#if DEBUG -//----------------------------------------------------------------------------- -void CFrame::dumpHierarchy () -{ - dumpInfo (); - DebugPrint ("\n"); - CViewContainer::dumpHierarchy (); -} -#endif - -//----------------------------------------------------------------------------- -// CCView Implementation -//----------------------------------------------------------------------------- -CCView::CCView (CView *pView) - : pView (pView), pNext (0), pPrevious (0) -{ - if (pView) - pView->remember (); -} - -//----------------------------------------------------------------------------- -CCView::~CCView () -{ - if (pView) - pView->forget (); -} - -//----------------------------------------------------------------------------- -// CViewContainer Implementation -//----------------------------------------------------------------------------- -/** - * CViewContainer constructor. - * @param rect the size of the container - * @param pParent the parent CFrame - * @param pBackground the background bitmap, can be NULL - */ -CViewContainer::CViewContainer (const CRect &rect, CFrame *pParent, CBitmap *pBackground) - : CView (rect), - pFirstView (0), - pLastView (0), - mode (kNormalUpdate), - pOffscreenContext (0), - bDrawInOffscreen (false), - currentDragView (0) -{ - pParentFrame = pParent; - - backgroundOffset (0, 0); - - setBackground (pBackground); - backgroundColor = kBlackCColor; - -#if NEW_UPDATE_MECHANISM - mode = kOnlyDirtyUpdate; -#endif -} - -//----------------------------------------------------------------------------- -CViewContainer::~CViewContainer () -{ - // remove all views - removeAll (true); - - if (pOffscreenContext) - pOffscreenContext->forget (); - pOffscreenContext = 0; -} - -//----------------------------------------------------------------------------- -/** - * @param rect the new size of the container - */ -void CViewContainer::setViewSize (CRect &rect) -{ - CView::setViewSize (rect); - - if (pOffscreenContext && bDrawInOffscreen) - { - pOffscreenContext->forget (); - pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor); - } -} - -//----------------------------------------------------------------------------- -/** - * @param color the new background color of the container - */ -void CViewContainer::setBackgroundColor (CColor color) -{ - backgroundColor = color; - setDirty (true); -} - -//------------------------------------------------------------------------------ -long CViewContainer::notify (CView* sender, const char* message) -{ - if (message == kMsgCheckIfViewContainer) - return kMessageNotified; - return kMessageUnknown; -} - -//----------------------------------------------------------------------------- -/** - * @param pView the view object to add to this container - */ -void CViewContainer::addView (CView *pView) -{ - if (!pView) - return; - - CCView *pSv = new CCView (pView); - - pView->pParentFrame = pParentFrame; - pView->pParentView = this; - - CCView *pV = pFirstView; - if (!pV) - { - pLastView = pFirstView = pSv; - } - else - { - while (pV->pNext) - pV = pV->pNext; - pV->pNext = pSv; - pSv->pPrevious = pV; - pLastView = pSv; - } - pView->attached (this); - pView->setDirty (); -} - -//----------------------------------------------------------------------------- -/** - * @param pView the view object to add to this container - * @param mouseableArea the view area in where the view will get mouse events - * @param mouseEnabled bool to set if view will get mouse events - */ -void CViewContainer::addView (CView *pView, CRect &mouseableArea, bool mouseEnabled) -{ - if (!pView) - return; - - pView->setMouseEnabled (mouseEnabled); - pView->setMouseableArea (mouseableArea); - - addView (pView); -} - -//----------------------------------------------------------------------------- -/** - * @param withForget bool to indicate if the view's reference counter should be decreased after removed from the container - */ -void CViewContainer::removeAll (const bool &withForget) -{ - CCView *pV = pFirstView; - while (pV) - { - CCView *pNext = pV->pNext; - if (pV->pView) - { - pV->pView->removed (this); - if (withForget) - pV->pView->forget (); - } - - delete pV; - - pV = pNext; - } - pFirstView = 0; - pLastView = 0; -} - -//----------------------------------------------------------------------------- -/** - * @param pView the view which should be removed from the container - * @param withForget bool to indicate if the view's reference counter should be decreased after removed from the container - */ -void CViewContainer::removeView (CView *pView, const bool &withForget) -{ - if (pParentFrame && pParentFrame->getFocusView () == pView) - pParentFrame->setFocusView (0); - CCView *pV = pFirstView; - while (pV) - { - if (pView == pV->pView) - { - CCView *pNext = pV->pNext; - CCView *pPrevious = pV->pPrevious; - if (pV->pView) - { - pV->pView->removed (this); - if (withForget) - pV->pView->forget (); - } - delete pV; - if (pPrevious) - { - pPrevious->pNext = pNext; - if (pNext) - pNext->pPrevious = pPrevious; - else - pLastView = pPrevious; - } - else - { - pFirstView = pNext; - if (pNext) - pNext->pPrevious = 0; - else - pLastView = 0; - } - break; - } - else - pV = pV->pNext; - } -} - -//----------------------------------------------------------------------------- -/** - * @param pView the view which should be checked if it is a child of this container - */ -bool CViewContainer::isChild (CView *pView) const -{ - bool found = false; - - CCView *pV = pFirstView; - while (pV) - { - if (pView == pV->pView) - { - found = true; - break; - } - pV = pV->pNext; - } - return found; -} - -//----------------------------------------------------------------------------- -long CViewContainer::getNbViews () const -{ - long nb = 0; - CCView *pV = pFirstView; - while (pV) - { - pV = pV->pNext; - nb++; - } - return nb; -} - -//----------------------------------------------------------------------------- -/** - * @param index the index of the view to return - */ -CView *CViewContainer::getView (long index) const -{ - long nb = 0; - CCView *pV = pFirstView; - while (pV) - { - if (nb == index) - return pV->pView; - pV = pV->pNext; - nb++; - } - return 0; -} - -//----------------------------------------------------------------------------- -/** - * @param pContext the context which to use to draw this container and its subviews - */ -void CViewContainer::draw (CDrawContext *pContext) -{ - CDrawContext *pC; - CCoord save[4]; - - if (!pOffscreenContext && bDrawInOffscreen) - pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor); - -#if USE_ALPHA_BLEND - if (pOffscreenContext && bTransparencyEnabled) - pOffscreenContext->copyTo (pContext, size); -#endif - - if (bDrawInOffscreen) - pC = pOffscreenContext; - else - { - pC = pContext; - modifyDrawContext (save, pContext); - } - - CRect r (0, 0, size.width (), size.height ()); - -#if USE_CLIPPING_DRAWRECT - CRect oldClip; - pContext->getClipRect (oldClip); - CRect oldClip2 (oldClip); - if (bDrawInOffscreen && getFrame () != this) - oldClip.offset (-oldClip.left, -oldClip.top); - - CRect newClip (r); - newClip.bound (oldClip); - pC->setClipRect (newClip); -#endif - - // draw the background - if (pBackground) - { - if (bTransparencyEnabled) - pBackground->drawTransparent (pC, r, backgroundOffset); - else - pBackground->draw (pC, r, backgroundOffset); - } - else if (!bTransparencyEnabled) - { - pC->setFillColor (backgroundColor); - pC->fillRect (r); - } - - // draw each view - FOREACHSUBVIEW -#if USE_CLIPPING_DRAWRECT - CRect vSize (pV->size); - vSize.bound (oldClip); - pC->setClipRect (vSize); -#endif - if (pV->isVisible()) - pV->draw (pC); - ENDFOR - -#if USE_CLIPPING_DRAWRECT - pC->setClipRect (oldClip2); -#endif - - // transfert offscreen - if (bDrawInOffscreen) - ((COffscreenContext*)pC)->copyFrom (pContext, size); - else - restoreDrawContext (pContext, save); - - setDirty (false); -} - -//----------------------------------------------------------------------------- -/** - * @param pContext the context which to use to draw the background - * @param _updateRect the area which to draw - */ -void CViewContainer::drawBackgroundRect (CDrawContext *pContext, CRect& _updateRect) -{ - if (pBackground) - { - CRect oldClip; - pContext->getClipRect (oldClip); - CRect newClip (_updateRect); - newClip.bound (oldClip); - pContext->setClipRect (newClip); - CRect tr (0, 0, pBackground->getWidth (), pBackground->getHeight ()); - if (bTransparencyEnabled) - pBackground->drawTransparent (pContext, tr, backgroundOffset); - else - pBackground->draw (pContext, tr, backgroundOffset); - pContext->setClipRect (oldClip); - } - else if (!bTransparencyEnabled) - { - pContext->setFillColor (backgroundColor); - pContext->fillRect (_updateRect); - } -} - -//----------------------------------------------------------------------------- -/** - * @param pContext the context which to use to draw - * @param _updateRect the area which to draw - */ -void CViewContainer::drawRect (CDrawContext *pContext, const CRect& _updateRect) -{ - CDrawContext *pC; - CCoord save[4]; - - if (!pOffscreenContext && bDrawInOffscreen) - pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor); - -#if USE_ALPHA_BLEND - if (pOffscreenContext && bTransparencyEnabled) - pOffscreenContext->copyTo (pContext, size); -#endif - - if (bDrawInOffscreen) - pC = pOffscreenContext; - else - { - pC = pContext; - modifyDrawContext (save, pContext); - } - - CRect updateRect (_updateRect); - updateRect.bound (size); - - CRect clientRect (updateRect); - clientRect.offset (-size.left, -size.top); - -#if USE_CLIPPING_DRAWRECT - CRect oldClip; - pContext->getClipRect (oldClip); - CRect oldClip2 (oldClip); - if (bDrawInOffscreen && getFrame () != this) - oldClip.offset (-oldClip.left, -oldClip.top); - - CRect newClip (clientRect); - newClip.bound (oldClip); - pC->setClipRect (newClip); -#endif - - // draw the background - drawBackgroundRect (pC, clientRect); - - // draw each view - FOREACHSUBVIEW - if (pV->isVisible() && pV->checkUpdate (clientRect)) - { -#if USE_CLIPPING_DRAWRECT - CRect viewSize (pV->size); - viewSize.bound (newClip); - if (viewSize.getWidth () == 0 || viewSize.getHeight () == 0) - continue; - pC->setClipRect (viewSize); -#endif - - bool wasDirty = pV->isDirty (); - pV->drawRect (pC, clientRect); - -#if DEBUG_FOCUS_DRAWING - if (getFrame ()->getFocusView() == pV && pV->wantsFocus ()) - { - pC->setDrawMode (kCopyMode); - pC->setFrameColor (kRedCColor); - pC->drawRect (pV->size); - } -#endif - if (wasDirty && /* pV->size != viewSize &&*/ !isTypeOf ("CScrollContainer")) - { - pV->setDirty (true); - } - } - ENDFOR - -#if USE_CLIPPING_DRAWRECT - pC->setClipRect (oldClip2); -#endif - - // transfer offscreen - if (bDrawInOffscreen) - ((COffscreenContext*)pC)->copyFrom (pContext, updateRect, CPoint (clientRect.left, clientRect.top)); - else - restoreDrawContext (pContext, save); - -#if EVENT_DRAW_FIX - if (bDirty && newClip == size) -#endif - setDirty (false); -} - -//----------------------------------------------------------------------------- -/** - * @param context the context which to use to redraw this container - * @param rect the area which to redraw - */ -void CViewContainer::redrawRect (CDrawContext* context, const CRect& rect) -{ - CRect _rect (rect); - _rect.offset (size.left, size.top); - if (bTransparencyEnabled) - { - // as this is transparent, we call the parentview to redraw this area. - if (pParentView) - pParentView->redrawRect (context, _rect); - else if (pParentFrame) - pParentFrame->drawRect (context, _rect); - } - else - { - CCoord save[4]; - if (pParentView) - { - CPoint off; - pParentView->localToFrame (off); - // store - save[0] = context->offsetScreen.h; - save[1] = context->offsetScreen.v; - save[2] = context->offset.h; - save[3] = context->offset.v; - - context->offsetScreen.h += off.x; - context->offsetScreen.v += off.y; - context->offset.h += off.x; - context->offset.v += off.y; - - drawRect (context, _rect); - - // restore - context->offsetScreen.h = save[0]; - context->offsetScreen.v = save[1]; - context->offset.h = save[2]; - context->offset.v = save[3]; - } - else - { - drawRect (context, _rect); - } - } -} - -//----------------------------------------------------------------------------- -bool CViewContainer::hitTestSubViews (const CPoint& where, const long buttons) -{ - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - CCView *pSv = pLastView; - while (pSv) - { - CView *pV = pSv->pView; - if (pV && pV->getMouseEnabled () && pV->hitTest (where2, buttons)) - return true; - pSv = pSv->pPrevious; - } - return false; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::hitTest (const CPoint& where, const long buttons) -{ - //return hitTestSubViews (where); would change default behavior - return CView::hitTest (where, buttons); -} - -//----------------------------------------------------------------------------- -void CViewContainer::mouse (CDrawContext *pContext, CPoint &where, long buttons) -{ - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - if (buttons == -1 && pContext) - buttons = pContext->getMouseButtons (); - - CCView *pSv = pLastView; - while (pSv) - { - CView *pV = pSv->pView; - if (pV && pV->getMouseEnabled () && pV->hitTest (where2, buttons)) - { - pV->mouse (pContext, where2, buttons); - break; - } - pSv = pSv->pPrevious; - } -} - -//----------------------------------------------------------------------------- -long CViewContainer::onKeyDown (VstKeyCode& keyCode) -{ - long result = -1; - - CCView* pSv = pLastView; - while (pSv) - { - long result = pSv->pView->onKeyDown (keyCode); - if (result != -1) - break; - - pSv = pSv->pPrevious; - } - - return result; -} - -//----------------------------------------------------------------------------- -long CViewContainer::onKeyUp (VstKeyCode& keyCode) -{ - long result = -1; - - CCView* pSv = pLastView; - while (pSv) - { - long result = pSv->pView->onKeyUp (keyCode); - if (result != -1) - break; - - pSv = pSv->pPrevious; - } - - return result; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::onWheel (CDrawContext *pContext, const CPoint &where, const CMouseWheelAxis axis, float distance) -{ - bool result = false; - CView *view = getViewAt (where); - if (view) - { - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - CCoord save[4]; - modifyDrawContext (save, pContext); - - result = view->onWheel (pContext, where2, axis, distance); - - restoreDrawContext (pContext, save); - } - return result; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::onWheel (CDrawContext *pContext, const CPoint &where, float distance) -{ - return onWheel (pContext, where, kMouseWheelAxisY, distance); -} - -//----------------------------------------------------------------------------- -bool CViewContainer::onDrop (CDrawContext* context, CDragContainer* drag, const CPoint& where) -{ - if (!pParentFrame) - return false; - - bool result = false; - - CCoord save[4]; - modifyDrawContext (save, context); - - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - CView* view = getViewAt (where); - if (view != currentDragView) - { - if (currentDragView) - currentDragView->onDragLeave (context, drag, where2); - currentDragView = view; - } - if (currentDragView) - { - result = currentDragView->onDrop (context, drag, where2); - currentDragView->onDragLeave (context, drag, where2); - } - currentDragView = 0; - - restoreDrawContext (context, save); - - return result; -} - -//----------------------------------------------------------------------------- -void CViewContainer::onDragEnter (CDrawContext* context, CDragContainer* drag, const CPoint& where) -{ - if (!pParentFrame) - return; - - CCoord save[4]; - modifyDrawContext (save, context); - - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - if (currentDragView) - currentDragView->onDragLeave (context, drag, where2); - CView* view = getViewAt (where); - currentDragView = view; - if (view) - view->onDragEnter (context, drag, where2); - - restoreDrawContext (context, save); -} - -//----------------------------------------------------------------------------- -void CViewContainer::onDragLeave (CDrawContext* context, CDragContainer* drag, const CPoint& where) -{ - if (!pParentFrame) - return; - - CCoord save[4]; - modifyDrawContext (save, context); - - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - if (currentDragView) - currentDragView->onDragLeave (context, drag, where2); - currentDragView = 0; - - restoreDrawContext (context, save); -} - -//----------------------------------------------------------------------------- -void CViewContainer::onDragMove (CDrawContext* context, CDragContainer* drag, const CPoint& where) -{ - if (!pParentFrame) - return; - - CCoord save[4]; - modifyDrawContext (save, context); - - // convert to relativ pos - CPoint where2 (where); - where2.offset (-size.left, -size.top); - - CView* view = getViewAt (where); - if (view != currentDragView) - { - if (currentDragView) - currentDragView->onDragLeave (context, drag, where2); - if (view) - view->onDragEnter (context, drag, where2); - currentDragView = view; - } - else if (currentDragView) - currentDragView->onDragMove (context, drag, where2); - - restoreDrawContext (context, save); -} - -//----------------------------------------------------------------------------- -void CViewContainer::update (CDrawContext *pContext) -{ - switch (mode) - { - //---Normal : redraw all... - case kNormalUpdate: - if (isDirty ()) - { -#if NEW_UPDATE_MECHANISM - CRect ur (0, 0, size.width (), size.height ()); - redrawRect (pContext, ur); -#else - #if USE_ALPHA_BLEND - if (bTransparencyEnabled) - { - CRect updateRect (size); - CPoint offset (0,0); - localToFrame (offset); - updateRect.offset (offset.x, offset.y); - getFrame ()->drawRect (pContext, updateRect); - } - else - #endif - draw (pContext); - #endif - setDirty (false); - } - break; - - //---Redraw only dirty controls----- - case kOnlyDirtyUpdate: - { -#if NEW_UPDATE_MECHANISM - if (bDirty) - { - CRect ur (0, 0, size.width (), size.height ()); - redrawRect (pContext, ur); - } - else - { - CRect updateRect (size); - updateRect.offset (-size.left, -size.top); - FOREACHSUBVIEW - if (pV->isDirty () && pV->checkUpdate (updateRect)) - { - if (pV->notify (this, kMsgCheckIfViewContainer)) - pV->update (pContext); - else - { - CRect drawSize (pV->size); - drawSize.bound (updateRect); - pV->redrawRect (pContext, drawSize); - } - } - ENDFOR - } -#else - #if USE_ALPHA_BLEND - if (bTransparencyEnabled) - { - if (bDirty) - { - CRect updateRect (size); - CPoint offset (0,0); - localToFrame (offset); - updateRect.offset (offset.x, offset.y); - getFrame ()->drawRect (pContext, updateRect); - } - else - { - CRect updateRect (size); - updateRect.offset (-size.left, -size.top); - FOREACHSUBVIEW - if (pV->isDirty () && pV->checkUpdate (updateRect)) - { - if (pV->notify (this, kMsgCheckIfViewContainer)) - { - pV->update (pContext); - } - else - { - CPoint offset; - CRect viewSize (pV->size); - pV->localToFrame (offset); - viewSize.offset (offset.x, offset.y); - getFrame ()->drawRect (pContext, viewSize); - } - } - ENDFOR - } - setDirty (false); - return; - } - #endif - if (bDirty) - draw (pContext); - else if (bDrawInOffscreen && pOffscreenContext) - { - bool doCopy = false; - if (isDirty ()) - doCopy = true; - - FOREACHSUBVIEW - pV->update (pOffscreenContext); - ENDFOR - - // transfert offscreen - if (doCopy) - pOffscreenContext->copyFrom (pContext, size); - } - else - { - long save[4]; - modifyDrawContext (save, pContext); - - FOREACHSUBVIEW - if (pV->isDirty ()) - { - long oldMode = 0; - CViewContainer* child = 0; - if (pV->notify (this, kMsgCheckIfViewContainer)) - { - child = (CViewContainer*)pV; - oldMode = child->getMode (); - child->setMode (kNormalUpdate); - } - CRect viewSize (pV->size); - drawBackgroundRect (pContext, viewSize); - pV->update (pContext); - if (child) - child->setMode (oldMode); - } - ENDFOR - - restoreDrawContext (pContext, save); - } -#endif - setDirty (false); - break; - } - } -} - -//----------------------------------------------------------------------------- -void CViewContainer::looseFocus (CDrawContext *pContext) -{ - FOREACHSUBVIEW - pV->looseFocus (pContext); - ENDFOR -} - -//----------------------------------------------------------------------------- -void CViewContainer::takeFocus (CDrawContext *pContext) -{ - FOREACHSUBVIEW - pV->takeFocus (pContext); - ENDFOR -} - -//----------------------------------------------------------------------------- -bool CViewContainer::advanceNextFocusView (CView* oldFocus, bool reverse) -{ - bool foundOld = false; - FOREACHSUBVIEW_REVERSE(reverse) - if (oldFocus && !foundOld) - { - if (oldFocus == pV) - { - foundOld = true; - continue; - } - } - else - { - if (pV->wantsFocus ()) - { - getFrame ()->setFocusView (pV); - return true; - } - else if (pV->isTypeOf ("CViewContainer")) - { - if (((CViewContainer*)pV)->advanceNextFocusView (0, reverse)) - return true; - } - } - ENDFOR - return false; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::isDirty () const -{ - if (bDirty) - return true; - - CRect viewSize (size); - viewSize.offset (-size.left, -size.top); - - FOREACHSUBVIEW - if (pV->isDirty ()) - { - CRect r (pV->size); - r.bound (viewSize); - if (r.getWidth () > 0 && r.getHeight () > 0) - return true; - } - ENDFOR - return false; -} - -//----------------------------------------------------------------------------- -CView *CViewContainer::getCurrentView () const -{ - if (!pParentFrame) - return 0; - - // get the current position - CPoint where; - pParentFrame->getCurrentLocation (where); - - frameToLocal (where); - - CCView *pSv = pLastView; - while (pSv) - { - CView *pV = pSv->pView; - if (pV && where.isInside (pV->mouseableArea)) - return pV; - pSv = pSv->pPrevious; - } - - return 0; -} - -//----------------------------------------------------------------------------- -CView *CViewContainer::getViewAt (const CPoint& p, bool deep) const -{ - if (!pParentFrame) - return 0; - - CPoint where (p); - - // convert to relativ pos - where.offset (-size.left, -size.top); - - CCView *pSv = pLastView; - while (pSv) - { - CView *pV = pSv->pView; - if (pV && where.isInside (pV->mouseableArea)) - { - if (deep) - { - if (pV->isTypeOf ("CViewContainer")) - return ((CViewContainer*)pV)->getViewAt (where, deep); - } - return pV; - } - pSv = pSv->pPrevious; - } - - return 0; -} - -//----------------------------------------------------------------------------- -CPoint& CViewContainer::frameToLocal (CPoint& point) const -{ - point.offset (-size.left, -size.top); - if (pParentView && pParentView->isTypeOf ("CViewContainer")) - return pParentView->frameToLocal (point); - return point; -} - -//----------------------------------------------------------------------------- -CPoint& CViewContainer::localToFrame (CPoint& point) const -{ - point.offset (size.left, size.top); - if (pParentView && pParentView->isTypeOf ("CViewContainer")) - return pParentView->localToFrame (point); - return point; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::removed (CView* parent) -{ - if (pOffscreenContext) - pOffscreenContext->forget (); - pOffscreenContext = 0; - - return true; -} - -//----------------------------------------------------------------------------- -bool CViewContainer::attached (CView* view) -{ - // create offscreen bitmap - if (!pOffscreenContext && bDrawInOffscreen) - pOffscreenContext = new COffscreenContext (pParentFrame, (long)size.width (), (long)size.height (), kBlackCColor); - - return true; -} - -//----------------------------------------------------------------------------- -void CViewContainer::useOffscreen (bool b) -{ - bDrawInOffscreen = b; - - if (!bDrawInOffscreen && pOffscreenContext) - { - pOffscreenContext->forget (); - pOffscreenContext = 0; - } -} - -//----------------------------------------------------------------------------- -void CViewContainer::modifyDrawContext (CCoord save[4], CDrawContext* pContext) -{ - // store - save[0] = pContext->offsetScreen.h; - save[1] = pContext->offsetScreen.v; - save[2] = pContext->offset.h; - save[3] = pContext->offset.v; - - pContext->offsetScreen.h += size.left; - pContext->offsetScreen.v += size.top; - pContext->offset.h += size.left; - pContext->offset.v += size.top; -} - -//----------------------------------------------------------------------------- -void CViewContainer::restoreDrawContext (CDrawContext* pContext, CCoord save[4]) -{ - // restore - pContext->offsetScreen.h = save[0]; - pContext->offsetScreen.v = save[1]; - pContext->offset.h = save[2]; - pContext->offset.v = save[3]; -} - -#if DEBUG -static long _debugDumpLevel = 0; -//----------------------------------------------------------------------------- -void CViewContainer::dumpInfo () -{ - static const char* modeString[] = { "Normal Update Mode", "Only Dirty Update Mode"}; - DebugPrint ("CViewContainer: Mode: %s, Offscreen:%s ", modeString[mode], bDrawInOffscreen ? "Yes" : "No"); - CView::dumpInfo (); -} - -//----------------------------------------------------------------------------- -void CViewContainer::dumpHierarchy () -{ - _debugDumpLevel++; - FOREACHSUBVIEW - for (long i = 0; i < _debugDumpLevel; i++) - DebugPrint ("\t"); - pV->dumpInfo (); - DebugPrint ("\n"); - if (pV->isTypeOf ("CViewContainer")) - ((CViewContainer*)pV)->dumpHierarchy (); - ENDFOR - _debugDumpLevel--; -} - -#endif - - -//----------------------------------------------------------------------------- -// CBitmap Implementation -//----------------------------------------------------------------------------- -/*! @class CBitmap - * Image resources must be in PNG format. - * Filenames are specified by the pngResources table defined in the GUI. - */ -CBitmap::CBitmap (long ID) - : resourceID (ID), width (0), height (0), noAlpha (true) -{ -#if DEBUG - gNbCBitmap++; -#endif - - pHandle = 0; - pngRead = NULL; - pngInfo = NULL; - - bool found = false; - long i = 0; - - const char* p = NULL; - while (pngResources[i].id != 0) { - if (pngResources[i].id == resourceID) { - if (pngResources[i].path != NULL) { - found = true; - p = pngResources[i].path; - break; - } - } - ++i; - } - - if (VSTGUI::bundlePath == NULL) { - std::cerr << "ERROR: No bundle path set, unable to load images" << std::endl; - } else { - std::string path = std::string(VSTGUI::bundlePath) + p; - if (openPng(path.c_str())) // reads width, height - closePng(); - } - - setTransparentColor (kTransparentCColor); - -#if DEBUG - gBitmapAllocation += (long)height * (long)width; -#endif -} - -//----------------------------------------------------------------------------- -CBitmap::CBitmap (CFrame &frame, CCoord width, CCoord height) - : width (width), height (height), noAlpha (true), pMask (0) -{ -#if DEBUG - gNbCBitmap++; -#endif - - pHandle = (void*) XCreatePixmap (display, - frame.getBackBuffer (), - width, - height, - frame.getDepth ()); - - setTransparentColor (kTransparentCColor); -} - -//----------------------------------------------------------------------------- -CBitmap::CBitmap () - : resourceID (0) - , width (0) - , height (0) - , noAlpha (true) -{ - pMask = 0; - pHandle = 0; -} - -//----------------------------------------------------------------------------- -CBitmap::~CBitmap () -{ - dispose (); -} - -//----------------------------------------------------------------------------- -void CBitmap::dispose () -{ -#if DEBUG - gNbCBitmap--; - gBitmapAllocation -= (long)height * (long)width; -#endif - - if (pHandle) - XFreePixmap (display, (Pixmap)pHandle); - if (pMask) - XFreePixmap (display, (Pixmap)pMask); - - pHandle = 0; - pMask = 0; - - width = 0; - height = 0; - -} - -//----------------------------------------------------------------------------- -void *CBitmap::getHandle () const -{ - return pHandle; -} - -//----------------------------------------------------------------------------- -bool CBitmap::loadFromResource (long resourceID) -{ - dispose (); - fprintf (stderr, "CBitmap::loadFromResource not implemented\n"); - return false; -} - -//----------------------------------------------------------------------------- -bool CBitmap::loadFromPath (const void* platformPath) -{ - if (pHandle != NULL) - dispose (); - - bool success = openPng ((char*)platformPath); - if (success) - closePng (); - - return success; -} - -//----------------------------------------------------------------------------- -bool CBitmap::isLoaded () const -{ - return (pHandle != NULL); -} - -//----------------------------------------------------------------------------- -void CBitmap::draw (CDrawContext *pContext, CRect &rect, const CPoint &offset) -{ - if (!pHandle) - { - // the first time try to decode the pixmap - pHandle = createPixmapFromPng (pContext); - if (!pHandle) - return; - } - - CFrame* frame = pContext->pFrame; - - XCopyArea (display, - (Drawable) pHandle, - (Drawable) frame->getBackBuffer(), - (GC) frame->getGC(), - offset.h, - offset.v, - std::min (rect.width (), getWidth()), - std::min (rect.height (), getHeight()), - rect.left + pContext->offset.h, - rect.top + pContext->offset.v); -} - -//----------------------------------------------------------------------------- -void CBitmap::drawTransparent (CDrawContext *pContext, CRect &rect, const CPoint &offset) -{ - if (!pHandle) - { - // the first time try to decode the pixmap - pHandle = createPixmapFromPng (pContext); - if (!pHandle) - return; - } - - CFrame* frame = pContext->pFrame; - - if (pMask == 0) - { - // get image from the pixmap - XImage* image = XGetImage (display, (Drawable)pHandle, - 0, 0, width, height, AllPlanes, ZPixmap); - assert (image); - - // create the bitmap mask - pMask = (void*) XCreatePixmap (display, (Drawable)frame->getWindow(), - width, height, 1); - assert (pMask); - - // create a associated GC - XGCValues values; - values.foreground = 1; - GC gc = XCreateGC (display, (Drawable)pMask, GCForeground, &values); - - // clear the mask - XFillRectangle (display, (Drawable)pMask, gc, 0, 0, width, height); - - // get the transparent color index - int color = pContext->getIndexColor (transparentCColor); - - // inverse the color - values.foreground = 0; - XChangeGC (display, gc, GCForeground, &values); - - // compute the mask - XPoint *points = new XPoint [height * width]; - int x, y, nbPoints = 0; - switch (image->depth) - { - case 8: - for (y = 0; y < height; y++) - { - char* src = image->data + (y * image->bytes_per_line); - - for (x = 0; x < width; x++) - { - if (src[x] == color) - { - points[nbPoints].x = x; - points[nbPoints].y = y; - nbPoints++; - } - } - } - break; - - case 24: { - int bytesPerPixel = image->bits_per_pixel >> 3; - char *lp = image->data; - for (y = 0; y < height; y++) - { - char* cp = lp; - for (x = 0; x < width; x++) - { - if (*(int*)cp == color) - { - points[nbPoints].x = x; - points[nbPoints].y = y; - nbPoints++; - } - cp += bytesPerPixel; - } - lp += image->bytes_per_line; - } - } break; - - default : - break; - } - - XDrawPoints (display, (Drawable)pMask, gc, - points, nbPoints, CoordModeOrigin); - - // free - XFreeGC (display, gc); - delete []points; - - // delete - XDestroyImage (image); - } - - // set the new clipmask - XGCValues value; - value.clip_mask = (Pixmap)pMask; - value.clip_x_origin = (rect.left + pContext->offset.h) - offset.h; - value.clip_y_origin = (rect.top + pContext->offset.v) - offset.v; - - XChangeGC (display, - (GC) /*frame->getGC(),*/ pContext->pSystemContext, - GCClipMask | GCClipXOrigin | GCClipYOrigin, - &value); - - XCopyArea (display, - (Drawable) pHandle, - (Drawable) frame->getBackBuffer(), - (GC) frame->getGC(), - offset.h, - offset.v, - rect.width (), - rect.height (), - rect.left + pContext->offset.h, - rect.top + pContext->offset.v); - - // unset the clipmask - XSetClipMask (display, (GC)frame->getGC(), None); -} - -//----------------------------------------------------------------------------- -void CBitmap::drawAlphaBlend (CDrawContext *pContext, CRect &rect, const CPoint &offset, unsigned char alpha) -{ - std::cout << "CBitmap::drawAlphaBlend (not implemented!)" << std::endl; -} - -//----------------------------------------------------------------------------- -void CBitmap::setTransparentColor (const CColor color) -{ - transparentCColor = color; -} - -//----------------------------------------------------------------------------- -void CBitmap::setTransparencyMask (CDrawContext* pContext, const CPoint& offset) -{ - // todo: implement me! -} - - -//----------------------------------------------------------------------------- -bool CBitmap::openPng (const char* path) -{ - assert(path); - - FILE* fp = fopen(path, "rb"); - if (!fp) { - fprintf(stderr, "Unable to open file %s\n", path); - return false; - } - - png_byte header[8]; - fread(header, 1, 8, fp); - if (png_sig_cmp(header, 0, 8)) { - fprintf(stderr, "File not recognized as a PNG image"); - fclose(fp); - return false; - } - - pngRead = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL); - if (!pngRead) { - fprintf(stderr, "Unable to initialize libpng\n"); - fclose(fp); - return false; - } - - pngInfo = png_create_info_struct(pngRead); - if (!pngInfo) { - png_destroy_read_struct(&pngRead, NULL, NULL); - pngRead = NULL; - fclose(fp); - return false; - } - - png_init_io(pngRead, fp); - png_set_sig_bytes(pngRead, 8); - - png_read_info(pngRead, pngInfo); - - width = pngInfo->width; - height = pngInfo->height; - - pngFp = fp; - pngRead = pngRead; - pngPath = path; - - return true; -} - -//----------------------------------------------------------------------------- -bool CBitmap::closePng () -{ - png_destroy_read_struct(&pngRead, &pngInfo, NULL); - fclose(pngFp); - pngFp = NULL; - pngRead = NULL; - pngInfo = NULL; - return true; -} - -//----------------------------------------------------------------------------- -void* CBitmap::createPixmapFromPng (CDrawContext *pContext) -{ - if (!openPng(pngPath.c_str())) - return NULL; - - assert(width > 0 && height > 0); - - png_byte** rows = (png_byte**)malloc(height * sizeof(png_byte*)); - for (int i = 0; i < height; ++i) - rows[i] = (png_byte*)(malloc(pngInfo->width * sizeof(uint32_t))); - - png_read_image(pngRead, rows); - - CFrame* frame = pContext->pFrame; - - Pixmap p = XCreatePixmap(display, frame->getBackBuffer(), - pngInfo->width, pngInfo->height, 24); - - XGCValues values; - values.foreground = 0xFFFFFFFF; - - // Draw - GC gc = XCreateGC (display, p, GCForeground, &values); - for (unsigned y = 0; y < pngInfo->height; y++) { - for (unsigned x = 0; x < pngInfo->width; ++x) { - char r = rows[y][(x*3)]; - char g = rows[y][(x*3)+1]; - char b = rows[y][(x*3)+2]; - uint32_t color = (r << 16) + (g << 8) + b; - XSetForeground(display, gc, color); - XDrawPoint(display, p, gc, x, y); - } - } - XFreeGC (display, gc); - - closePng(); - - return (void*)p; -} - -//----------------------------------------------------------------------------- -// CDragContainer Implementation -//----------------------------------------------------------------------------- -CDragContainer::CDragContainer (void* platformDrag) -: platformDrag (platformDrag) -, nbItems (0) -, iterator (0) -, lastItem (0) -{ -} - -//----------------------------------------------------------------------------- -CDragContainer::~CDragContainer () -{ - if (lastItem) - { - free (lastItem); - lastItem = 0; - } -} - -//----------------------------------------------------------------------------- -long CDragContainer::getType (long idx) const -{ - // not implemented - return kUnknown; -} - -//----------------------------------------------------------------------------- -void* CDragContainer::first (long& size, long& type) -{ - iterator = 0; - return next (size, type); -} - -//----------------------------------------------------------------------------- -void* CDragContainer::next (long& size, long& type) -{ - if (lastItem) - { - free (lastItem); - lastItem = 0; - } - size = 0; - type = kUnknown; - - // not implemented - - return NULL; -} - -} // namespace VSTGUI - -//----------------------------------------------------------------------------- -// return a degre value between [0, 360 * 64[ -static long convertPoint2Angle (CPoint &pm, CPoint &pt) -{ - long angle; - if (pt.h == pm.h) - { - if (pt.v < pm.v) - angle = 5760; // 90 * 64 - else - angle = 17280; // 270 * 64 - } - else if (pt.v == pm.v) - { - if (pt.h < pm.h) - angle = 11520; // 180 * 64 - else - angle = 0; - } - else - { - // 3666.9299 = 180 * 64 / pi - angle = (long)(3666.9298 * atan ((double)(pm.v - pt.v) / (double)(pt.h - pm.h))); - - if (pt.v < pm.v) - { - if (pt.h < pm.h) - angle += 11520; // 180 * 64 - } - else - { - if (pt.h < pm.h) - angle += 11520; // 180 * 64 - else - angle += 23040; // 360 * 64 - } - } - return angle; -} - - - -#if !PLUGGUI -//----------------------------------------------------------------------------- -// CFileSelector Implementation -//----------------------------------------------------------------------------- -#define stringAnyType "Any Type (*.*)" -#define stringAllTypes "All Types: (" -#define stringSelect "Select" -#define stringCancel "Cancel" -#define stringLookIn "Look in" -#define kPathMax 1024 - -namespace VSTGUI { - -//----------------------------------------------------------------------------- -CFileSelector::CFileSelector (AudioEffectX* effect) -: effect (effect), vstFileSelect (0) -{} - -//----------------------------------------------------------------------------- -CFileSelector::~CFileSelector () -{ - if (vstFileSelect) - { - if (effect && effect->canHostDo ("closeFileSelector")) - effect->closeFileSelector (vstFileSelect); - else - { - if (vstFileSelect->reserved == 1 && vstFileSelect->returnPath) - { - delete []vstFileSelect->returnPath; - vstFileSelect->returnPath = 0; - vstFileSelect->sizeReturnPath = 0; - } - if (vstFileSelect->returnMultiplePaths) - { - for (long i = 0; i < vstFileSelect->nbReturnPath; i++) - { - delete []vstFileSelect->returnMultiplePaths[i]; - vstFileSelect->returnMultiplePaths[i] = 0; - } - delete[] vstFileSelect->returnMultiplePaths; - vstFileSelect->returnMultiplePaths = 0; - } - } - } -} - -//----------------------------------------------------------------------------- -long CFileSelector::run (VstFileSelect *vstFileSelect_) -{ - vstFileSelect = vstFileSelect_; - vstFileSelect->nbReturnPath = 0; - vstFileSelect->returnPath[0] = 0; - - if (effect - && effect->canHostDo ("openFileSelector") - && effect->canHostDo ("closeFileSelector")) - { - if (effect->openFileSelector (vstFileSelect)) - return vstFileSelect->nbReturnPath; - } - return 0; -} - -} // namespace VSTGUI - -//----------------------------------------------------------------------------- -#endif // !PLUGGUI -//----------------------------------------------------------------------------- - |