//-----------------------------------------------------------------------------
void D2DDrawContext::drawEllipse (const CRect &_rect, const CDrawStyle drawStyle)
{
if (renderTarget == 0)
return;
D2DApplyClip ac (this);
if (ac.isEmpty ())
return;
CRect rect (_rect);
if (currentState.drawMode.integralMode ())
pixelAllign (rect);
CPoint center (rect.getTopLeft ());
center.offset (rect.getWidth () / 2., rect.getHeight () / 2.);
D2D1_ELLIPSE ellipse;
ellipse.point = makeD2DPoint (center);
ellipse.radiusX = (FLOAT)(rect.getWidth () / 2.);
ellipse.radiusY = (FLOAT)(rect.getHeight () / 2.);
if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked)
{
renderTarget->FillEllipse (ellipse, fillBrush);
}
if (drawStyle == kDrawStroked || drawStyle == kDrawFilledAndStroked)
{
renderTarget->DrawEllipse (ellipse, strokeBrush, (FLOAT)currentState.frameWidth, strokeStyle);
}
}
//-----------------------------------------------------------------------------
void CScrollView::makeRectVisible (const CRect& rect)
{
CRect r (rect);
const CPoint& scrollOffset = sc->getScrollOffset ();
CPoint newOffset (scrollOffset);
CRect vs;
sc->getViewSize (vs);
if (!(style & kDontDrawFrame))
{
vs.left--; //vs.top--;
vs.right++; //vs.bottom++;
}
CRect cs (containerSize);
cs.offset (-cs.left, -cs.top);
cs.setWidth (vs.getWidth ());
cs.setHeight (vs.getHeight ());
if (r.top >= cs.top && r.bottom <= cs.bottom && r.left >= cs.left && r.right <= cs.right)
return;
if (r.top < cs.top)
{
newOffset.y -= (cs.top - r.top);
}
else if (r.bottom > cs.bottom)
{
newOffset.y += (r.bottom - cs.bottom);
}
if (r.left < cs.left)
{
newOffset.x -= (cs.left + r.left);
}
else if (r.right > cs.right && r.left != cs.left)
{
newOffset.x += (cs.right - r.right);
}
if (vsb && newOffset.y != scrollOffset.y)
{
if (containerSize.getHeight () == vs.getHeight ())
vsb->setValue (0.f);
else
vsb->setValue ((float)(newOffset.y - vs.top) / (float)(containerSize.getHeight () - vs.getHeight ()));
vsb->bounceValue ();
vsb->onVisualChange ();
vsb->invalid ();
valueChanged (vsb);
}
if (hsb && newOffset.x != scrollOffset.x)
{
if (containerSize.getWidth () == vs.getWidth ())
hsb->setValue (0.f);
else
hsb->setValue (-(float)(newOffset.x - vs.left) / (float)(containerSize.getWidth () - vs.getWidth ()));
hsb->bounceValue ();
hsb->onVisualChange ();
hsb->invalid ();
valueChanged (hsb);
}
}
// -----------------------------------------------------------------------------
bool AEffGUIEditor::beforeSizeChange (const CRect& newSize, const CRect& oldSize)
{
AudioEffectX* eX = (AudioEffectX*)effect;
if (eX && eX->canHostDo ((char*)"sizeWindow"))
{
if (eX->sizeWindow ((VstInt32)newSize.getWidth (), (VstInt32)newSize.getHeight ()))
{
return true;
}
return false;
}
#if WINDOWS
// old hack to size the window of the host. Very ugly stuff ...
if (getFrame () == 0)
return true;
RECT rctTempWnd, rctParentWnd;
HWND hTempWnd;
long iFrame = (2 * GetSystemMetrics (SM_CYFIXEDFRAME));
long diffWidth = 0;
long diffHeight = 0;
hTempWnd = (HWND)getFrame ()->getPlatformFrame ()->getPlatformRepresentation ();
while ((diffWidth != iFrame) && (hTempWnd != NULL)) // look for FrameWindow
{
HWND hTempParentWnd = GetParent (hTempWnd);
TCHAR buffer[1024];
GetClassName (hTempParentWnd, buffer, 1024);
if (!hTempParentWnd || !VSTGUI_STRCMP (buffer, TEXT("MDIClient")))
break;
GetWindowRect (hTempWnd, &rctTempWnd);
GetWindowRect (hTempParentWnd, &rctParentWnd);
SetWindowPos (hTempWnd, HWND_TOP, 0, 0, (int)newSize.getWidth () + diffWidth, (int)newSize.getHeight () + diffHeight, SWP_NOMOVE);
diffWidth += (rctParentWnd.right - rctParentWnd.left) - (rctTempWnd.right - rctTempWnd.left);
diffHeight += (rctParentWnd.bottom - rctParentWnd.top) - (rctTempWnd.bottom - rctTempWnd.top);
if ((diffWidth > 80) || (diffHeight > 80)) // parent belongs to host
return true;
if (diffWidth < 0)
diffWidth = 0;
if (diffHeight < 0)
diffHeight = 0;
hTempWnd = hTempParentWnd;
}
if (hTempWnd)
SetWindowPos (hTempWnd, HWND_TOP, 0, 0, (int)newSize.getWidth () + diffWidth, (int)newSize.getHeight () + diffHeight, SWP_NOMOVE);
#endif
return true;
}
//--------------------------------------------------------------------------------
void CRowColumnView::layoutViewsEqualSize ()
{
CPoint maxSize;
getMaxChildViewSize (maxSize);
if (style == kRowStyle)
maxSize.x = getViewSize ().getWidth () - (margin.right + margin.left);
else
maxSize.y = getViewSize ().getHeight () - (margin.top + margin.bottom);
CPoint location = margin.getTopLeft ();
ViewIterator it (this);
while (*it)
{
CView* view = *it;
CRect viewSize = view->getViewSize ();
viewSize.originize ();
viewSize.offset (location.x, location.y);
switch (layoutStyle)
{
case kStretchEqualy:
{
viewSize.setWidth (maxSize.x);
viewSize.setHeight (maxSize.y);
break;
}
case kCenterEqualy:
{
CCoord diffX = (maxSize.x - viewSize.getWidth ()) / 2.;
CCoord diffY = (maxSize.y - viewSize.getHeight ()) / 2.;
viewSize.offset (diffX, diffY);
break;
}
case kRightBottomEqualy:
{
CCoord diffX = maxSize.x - viewSize.getWidth ();
CCoord diffY = maxSize.y - viewSize.getHeight ();
viewSize.offset (diffX, diffY);
break;
}
default:
break;
}
resizeSubView (view, viewSize);
if (style == kRowStyle)
{
location.y += spacing;
location.y += viewSize.getHeight ();
}
else
{
location.x += spacing;
location.x += viewSize.getWidth ();
}
it++;
}
}
//--------------------------------------------------------------------------------
void CRowColumnView::getMaxChildViewSize (CPoint& maxSize)
{
ViewIterator it (this);
while (*it)
{
CView* view = *it;
CRect viewSize = view->getViewSize ();
if (viewSize.getWidth () > maxSize.x)
maxSize.x = viewSize.getWidth ();
if (viewSize.getHeight () > maxSize.y)
maxSize.y = viewSize.getHeight ();
it++;
}
}
//-----------------------------------------------------------------------------
void CScrollView::setContainerSize (const CRect& cs, bool keepVisibleArea)
{
CRect oldSize (containerSize);
containerSize = cs;
if (sc)
{
sc->setContainerSize (cs);
}
if (style & kAutoHideScrollbars)
recalculateSubViews ();
if (vsb)
{
CRect oldScrollSize = vsb->getScrollSize (oldScrollSize);
float oldValue = vsb->getValue ();
vsb->setScrollSize (cs);
if (cs.getHeight () <= getViewSize ().getHeight ())
vsb->setValue (0);
else if (sc && keepVisibleArea && oldScrollSize.getHeight () != cs.getHeight ())
{
CRect vSize = sc->getViewSize (vSize);
float newValue = (float)(oldValue * ((float)(oldScrollSize.getHeight () - vSize.getHeight ()) / ((float)cs.getHeight () - vSize.getHeight ())));
if (newValue > 1.f)
newValue = 1.f;
else if (newValue < 0.f)
newValue = 0.f;
vsb->setValue (newValue);
}
valueChanged (vsb);
}
if (hsb)
{
CRect oldScrollSize = hsb->getScrollSize (oldScrollSize);
float oldValue = hsb->getValue ();
hsb->setScrollSize (cs);
if (cs.getWidth () <= getViewSize ().getWidth ())
hsb->setValue (0);
else if (sc && keepVisibleArea && oldScrollSize.getWidth () != cs.getWidth ())
{
CRect vSize = sc->getViewSize (vSize);
float newValue = (float)(oldValue * ((float)(oldScrollSize.getWidth () - vSize.getWidth ()) / ((float)cs.getWidth () - vSize.getWidth ())));
if (newValue > 1.f)
newValue = 1.f;
else if (newValue < 0.f)
newValue = 0.f;
hsb->setValue (newValue);
}
valueChanged (hsb);
}
}
void valueChanged (CControl* pControl)
{
if (pControl->getValue ())
{
switch (pControl->getTag ())
{
case 0:
{
CView* view = desc->createView ("ModalView", this);
if (view)
{
CFrame* frame = pControl->getFrame ();
CPoint center = frame->getViewSize ().getCenter ();
CRect viewSize = view->getViewSize ();
viewSize.offset (center.x - viewSize.getWidth () / 2, center.y - viewSize.getHeight () / 2);
view->setViewSize (viewSize);
view->setMouseableArea (viewSize);
frame->setModalView (view);
view->setAlphaValue (0.f);
view->addAnimation ("AlphaAnimation", new Animation::AlphaValueAnimation (1.f), new Animation::PowerTimingFunction (240, 2));
pControl->setValue (0);
view->forget ();
}
break;
}
case 1:
{
CView* modalView = pControl->getFrame ()->getModalView ();
modalView->addAnimation ("AlphaAnimation", new RemoveModalViewAnimation (0.f), new Animation::PowerTimingFunction (240, 0.5));
pControl->setMouseEnabled (false);
break;
}
}
}
}
//----------------------------------------------------------------------------------------------------
void UISearchTextField::drawClearMark (CDrawContext* context) const
{
if (getText ().empty ())
return;
SharedPointer<CGraphicsPath> path = owned (context->createGraphicsPath ());
if (path == 0)
return;
CRect r = getClearMarkRect ();
CColor color (fontColor);
color.alpha /= 2;
context->setFillColor (color);
context->setDrawMode (kAntiAliasing);
context->drawEllipse (r, kDrawFilled);
double h,s,v;
color.toHSV (h, s, v);
v = 1. - v;
color.fromHSV (h, s, v);
context->setFrameColor (color);
context->setLineWidth (2.);
r.inset (r.getWidth () / (M_PI * 2.) + 1, r.getHeight () / (M_PI * 2.) + 1);
path->beginSubpath (r.getTopLeft ());
path->addLine (r.getBottomRight ());
path->beginSubpath (r.getBottomLeft ());
path->addLine (r.getTopRight ());
context->setDrawMode (kAntiAliasing|kNonIntegralMode);
context->drawGraphicsPath (path, CDrawContext::kPathStroked);
}
//-----------------------------------------------------------------------------
void CGDrawContext::drawArc (const CRect &rect, const float _startAngle, const float _endAngle, const CDrawStyle drawStyle) // in degree
{
CGContextRef context = beginCGContext (true, getDrawMode ().integralMode ());
if (context)
{
CGPathDrawingMode m;
switch (drawStyle)
{
case kDrawFilled :
m = kCGPathFill;
break;
case kDrawFilledAndStroked :
m = kCGPathFillStroke;
break;
default :
m = kCGPathStroke;
break;
}
applyLineStyle (context);
CGContextBeginPath (context);
CGDrawContextInternal::addOvalToPath (context, CPoint (rect.left + rect.getWidth () / 2., rect.top + rect.getHeight () / 2.), static_cast<CGFloat> (rect.getWidth () / 2.), static_cast<CGFloat> (rect.getHeight () / 2.), _startAngle, _endAngle);
CGContextDrawPath (context, m);
releaseCGContext (context);
}
}
//------------------------------------------------------------------------
void CDrawContext::drawString (IPlatformString* string, const CRect& _rect, const CHoriTxtAlign hAlign, bool antialias)
{
if (!string || currentState.font == 0)
return;
IFontPainter* painter = currentState.font->getFontPainter ();
if (painter == 0)
return;
CRect rect (_rect);
double capHeight = -1;
IPlatformFont* platformFont = currentState.font->getPlatformFont ();
if (platformFont)
capHeight = platformFont->getCapHeight ();
if (capHeight > 0.)
rect.bottom -= (rect.getHeight () / 2. - capHeight / 2.);
else
rect.bottom -= (rect.getHeight () / 2. - currentState.font->getSize () / 2.) + 1.;
if (hAlign != kLeftText)
{
CCoord stringWidth = painter->getStringWidth (this, string, antialias);
if (hAlign == kRightText)
rect.left = rect.right - stringWidth;
else
rect.left = rect.left + (rect.getWidth () / 2.) - (stringWidth / 2.);
}
painter->drawString (this, string, CPoint (rect.left, rect.bottom), antialias);
}
//-----------------------------------------------------------------------------
bool Win32Frame::setSize (const CRect& newSize)
{
if (deviceContext)
{
deviceContext->forget ();
deviceContext = 0;
}
if (backBuffer)
{
backBuffer->forget ();
backBuffer = createOffscreenContext (newSize.getWidth (), newSize.getHeight ());
}
// TODO for VST2: we only set the size of the window we own. In VST2 this was not the case, we also resized the parent window. This must be done upstream now.
SetWindowPos (windowHandle, HWND_TOP, (int)newSize.left, (int)newSize.top, (int)newSize.getWidth (), (int)newSize.getHeight (), SWP_NOMOVE|SWP_NOCOPYBITS|SWP_NOREDRAW|SWP_DEFERERASE);
invalidRect (newSize);
return true;
}
//------------------------------------------------------------------------
void CTextLabel::setViewSize (const CRect& rect, bool invalid)
{
CRect current (getViewSize ());
CParamDisplay::setViewSize (rect, invalid);
if (textTruncateMode != kTruncateNone && current.getWidth () != getWidth ())
{
calculateTruncatedText ();
}
}
//-----------------------------------------------------------------------------
void CScrollView::valueChanged (CControl *pControl)
{
if (sc)
{
float value = pControl->getValue ();
int32_t tag = pControl->getTag ();
CPoint offset;
CRect vsize = sc->getViewSize (vsize);
CRect csize = sc->getContainerSize ();
sc->getScrollOffset (offset);
switch (tag)
{
case kHSBTag:
{
if (csize.getWidth () > vsize.getWidth ())
{
offset.x = (int32_t) (csize.left - (csize.getWidth () - vsize.getWidth ()) * value);
sc->setScrollOffset (offset, false);
}
else if (offset.x < 0)
{
offset.x = 0;
sc->setScrollOffset (offset, false);
}
break;
}
case kVSBTag:
{
if (csize.getHeight () > vsize.getHeight ())
{
offset.y = (int32_t) (csize.top + (csize.getHeight () - vsize.getHeight ()) * value);
sc->setScrollOffset (offset, false);
}
else if (offset.y > 0)
{
offset.y = 0;
sc->setScrollOffset (offset, false);
}
break;
}
}
}
}
//------------------------------------------------------------------------
void CSlider::setViewSize (const CRect& rect, bool invalid)
{
CControl::setViewSize (rect, invalid);
if (style & kHorizontal)
{
minPos = rect.left - getViewSize ().left;
rangeHandle = rect.getWidth () - (widthOfSlider + offsetHandle.x * 2);
}
else
{
minPos = rect.top - getViewSize ().top;
rangeHandle = rect.getHeight () - (heightOfSlider + offsetHandle.y * 2);
}
widthControl = rect.getWidth ();
heightControl = rect.getHeight ();
setOffsetHandle (offsetHandle);
}
//-----------------------------------------------------------------------------
void CShadowViewContainer::setViewSize (const CRect& rect, bool invalid)
{
if (getViewSize () != rect)
{
bool diffSize = (getWidth () != rect.getWidth () || getHeight () != rect.getHeight ());
CViewContainer::setViewSize (rect, invalid);
if (diffSize)
invalidateShadow ();
}
}
//--------------------------------------------------------------------------------
bool CRowColumnView::sizeToFit ()
{
if (children.size () > 0)
{
CRect viewSize = getViewSize ();
CPoint maxSize;
ViewIterator it (this);
if (style == kRowStyle)
{
while (*it)
{
CRect size = (*it)->getViewSize ();
if (size.getWidth () > maxSize.x)
maxSize.x = size.getWidth ();
maxSize.y += size.getHeight () + spacing;
it++;
}
}
else
{
while (*it)
{
CRect size = (*it)->getViewSize ();
maxSize.x += size.getWidth () + spacing;
if (size.bottom > maxSize.y)
maxSize.y = size.getHeight ();
it++;
}
}
viewSize.setWidth (maxSize.x + margin.left + margin.right);
viewSize.setHeight (maxSize.y + margin.top + margin.bottom);
if (viewSize != getViewSize ())
{
invalid ();
CViewContainer::setViewSize (viewSize);
CViewContainer::setMouseableArea (viewSize);
invalid ();
}
return true;
}
return false;
}
cSplashScreenVersion::cSplashScreenVersion(const CRect &size, CControlListener *listener, long tag,
CBitmap *splash, CRect &wsize) :
CControl(wsize, listener, tag) {
m_visible = false;
CRect tsize = wsize;
char vstring[MAX_VSTRING_SIZE];
tsize.top = wsize.bottom - DEF_VERSION_HEIGHT;
m_version = new CTextLabel(tsize);
m_version->setFontColor(kWhiteCColor);
m_version->setFrameColor(kBlackCColor);
m_version->setBackColor(kBlackCColor);
// This class expects the following preprocessor definitions to be defined in defaults.h
// DEF_PRODUCT - product name
// MAJ_VERSION - major version
// MIN_VERSION - minor version
// REL_BRANCH - can be either 'r' (release), 'b' (beta), or 'a' (alpha)
switch(REL_BRANCH) {
case 'a':
snprintf(vstring, MAX_VSTRING_SIZE, "%s-v%d.0a%d - alpha", DEF_PRODUCT, MAJ_VERSION, MIN_VERSION);
break;
case 'b':
snprintf(vstring, MAX_VSTRING_SIZE, "%s-v%d.0b%d - beta", DEF_PRODUCT, MAJ_VERSION, MIN_VERSION);
break;
case 'r':
default:
snprintf(vstring, MAX_VSTRING_SIZE, "%s-v%d.%d - Copyright 2006 Teragon Audio", DEF_PRODUCT, MAJ_VERSION, MIN_VERSION);
break;
}
m_version->setText(vstring);
m_click_area = size;
m_splash = splash;
if(m_splash) {
m_splash_area((wsize.getWidth() / 2) - (m_splash->getWidth() / 2),
(wsize.getHeight() / 2) - (m_splash->getHeight() / 2),
(wsize.getWidth() / 2) + (m_splash->getWidth() / 2),
(wsize.getHeight() / 2) + (m_splash->getHeight() / 2));
}
}
//-----------------------------------------------------------------------------
void CDrawContext::fillRectWithBitmap (CBitmap* bitmap, const CRect& srcRect, const CRect& dstRect, float alpha)
{
if (srcRect.isEmpty () || dstRect.isEmpty ())
return;
CRect bitmapPartRect;
CCoord left;
CCoord top;
CPoint sourceOffset (srcRect.left, srcRect.top);
CRect currentClip = getClipRect (currentClip);
for (top = dstRect.top; top < dstRect.bottom; top += srcRect.getHeight ())
{
bitmapPartRect.top = top;
bitmapPartRect.bottom = top + srcRect.getHeight ();
if (bitmapPartRect.bottom > dstRect.bottom)
bitmapPartRect.bottom = dstRect.bottom;
// The following should never be true, I guess
if (bitmapPartRect.getHeight () > srcRect.getHeight ())
bitmapPartRect.setHeight (srcRect.getHeight ());
for (left = dstRect.left; left < dstRect.right; left += srcRect.getWidth ())
{
bitmapPartRect.left = left;
bitmapPartRect.right = left + srcRect.getWidth ();
if (bitmapPartRect.right > dstRect.right)
bitmapPartRect.right = dstRect.right;
// The following should never be true, I guess
if (bitmapPartRect.getWidth () > srcRect.getWidth ())
bitmapPartRect.setWidth (srcRect.getWidth ());
if (currentClip.rectOverlap (bitmapPartRect))
drawBitmap (bitmap, bitmapPartRect, sourceOffset, alpha);
}
}
}
//-----------------------------------------------------------------------------
void D2DDrawContext::drawEllipse (const CRect &_rect, const CDrawStyle drawStyle)
{
if (renderTarget)
{
CRect rect (_rect);
rect.offset (currentState.offset.x, currentState.offset.y);
rect.normalize ();
D2DApplyClip clip (this);
CPoint center (rect.getTopLeft ());
center.offset (rect.getWidth () / 2., rect.getHeight () / 2.);
D2D1_ELLIPSE ellipse;
ellipse.point = makeD2DPoint (center);
ellipse.radiusX = (FLOAT)(rect.getWidth () / 2.);
ellipse.radiusY = (FLOAT)(rect.getHeight () / 2.);
if (drawStyle == kDrawFilled || drawStyle == kDrawFilledAndStroked)
{
renderTarget->FillEllipse (ellipse, fillBrush);
}
if (drawStyle == kDrawStroked || drawStyle == kDrawFilledAndStroked)
{
renderTarget->DrawEllipse (ellipse, strokeBrush, (FLOAT)currentState.frameWidth, strokeStyle);
}
}
}
//-----------------------------------------------------------------------------
bool CScrollContainer::isDirty () const
{
if (CView::isDirty ())
return true;
FOREACHSUBVIEW
if (pV->isDirty () && pV->isVisible ())
{
CRect r = pV->getVisibleViewSize ();
if (r.getWidth () > 0 && r.getHeight () > 0)
return true;
else
pV->setDirty (false);
}
ENDFOREACHSUBVIEW
return false;
}
void draw (CDrawContext* context)
{
CGraphicsPath* path = context->createGraphicsPath ();
if (path)
{
CRect r (getViewSize ());
r.inset (5, 5);
path->beginSubpath (CPoint (r.left + r.getWidth () / 2, r.top));
path->addLine (CPoint (r.left, r.bottom));
path->addLine (CPoint (r.right, r.bottom));
path->closeSubpath ();
setupLineStyle (context);
context->drawGraphicsPath (path, CDrawContext::kPathStroked);
path->forget ();
}
setDirty (false);
}
//-----------------------------------------------------------------------------
void CGDrawContext::drawCGImageRef (CGContextRef context, CGImageRef image, CGLayerRef layer, double bitmapScaleFactor, const CRect& inRect, const CPoint& inOffset, float alpha, CBitmap* bitmap)
{
CRect rect (inRect);
CPoint offset (inOffset);
CGContextSetAlpha (context, (CGFloat)alpha*currentState.globalAlpha);
CGRect dest;
dest.origin.x = static_cast<CGFloat> (rect.left - offset.x);
dest.origin.y = static_cast<CGFloat> (-(rect.top) - (bitmap->getHeight () - offset.y));
dest.size.width = static_cast<CGFloat> (bitmap->getWidth ());
dest.size.height = static_cast<CGFloat> (bitmap->getHeight ());
CGRect clipRect;
clipRect.origin.x = static_cast<CGFloat> (rect.left);
clipRect.origin.y = static_cast<CGFloat> (-(rect.top) - rect.getHeight ());
clipRect.size.width = static_cast<CGFloat> (rect.getWidth ());
clipRect.size.height = static_cast<CGFloat> (rect.getHeight ());
if (bitmapScaleFactor != 1.)
{
CGContextConcatCTM (context, CGAffineTransformMakeScale (static_cast<CGFloat> (1./bitmapScaleFactor), static_cast<CGFloat> (1./bitmapScaleFactor)));
CGAffineTransform transform = CGAffineTransformMakeScale (static_cast<CGFloat> (bitmapScaleFactor), static_cast<CGFloat> (bitmapScaleFactor));
clipRect.origin = CGPointApplyAffineTransform (clipRect.origin, transform);
clipRect.size = CGSizeApplyAffineTransform (clipRect.size, transform);
dest.origin = CGPointApplyAffineTransform (dest.origin, transform);
dest.size = CGSizeApplyAffineTransform (dest.size, transform);
}
dest = pixelAlligned (dest);
clipRect = pixelAlligned (clipRect);
CGContextClipToRect (context, clipRect);
if (layer)
{
CGContextDrawLayerInRect (context, dest, layer);
}
else
{
CGContextDrawImage (context, dest, image);
}
}
//-----------------------------------------------------------------------------
bool CScrollContainer::attached (CView* parent)
{
bool result = CViewContainer::attached (parent);
if (getNbViews () == 1)
{
CView* view = getView (0);
if (view)
{
CRect r (view->getViewSize ());
CRect newContainerSize (containerSize);
newContainerSize.setWidth (r.getWidth ());
newContainerSize.setHeight (r.getHeight ());
if (newContainerSize != containerSize)
{
CScrollView* scrollView = (CScrollView*)getParentView ();
scrollView->setContainerSize (newContainerSize);
}
}
}
return result;
}
//-----------------------------------------------------------------------------
CMessageResult CScrollContainer::notify (CBaseObject* sender, IdStringPtr message)
{
if (message == kMsgViewSizeChanged && !inScrolling)
{
uint32_t numSubViews = getNbViews ();
CView* view = static_cast<CView*> (sender);
if (numSubViews == 1 && view && isChild (view))
{
CRect r (view->getViewSize ());
CRect newContainerSize (containerSize);
newContainerSize.setWidth (r.getWidth ());
newContainerSize.setHeight (r.getHeight ());
if (newContainerSize != containerSize)
{
CScrollView* scrollView = (CScrollView*)getParentView ();
scrollView->setContainerSize (newContainerSize);
}
}
}
return getParentView () ? getParentView ()->notify (sender, message) : kMessageUnknown;
}
void CUIDisplayWorld::OnFrameMove(double fTime, float fElapsedTime)
{
if(IsVisible() == true)
{
CWorld::getInstance().frameMoveRole(Matrix::UNIT, fTime, fElapsedTime);
// ----
CWorld::getInstance().frameMove(Matrix::UNIT, fTime, fElapsedTime);
// ----
CRect<int> rcViewport = getViewport();
// ----
CGameCamera::getInstance().setProjParams(PI / 3, rcViewport.getWidth(), rcViewport.getHeight(), 0.1f, CWorld::getInstance().getFog().fEnd);
// ----
// Vec3D vPos = CPlayerMe::getInstance().getPos();
// vPos.y+=CPlayerMe::getInstance().getRoleHeight()*0.6f;
// CGameCamera::getInstance().setTargetPos(vPos);
// ----
CGameCamera::getInstance().FrameMove(fElapsedTime);
// ----
CUIDisplay::OnFrameMove(fTime, fElapsedTime);
}
}
//-----------------------------------------------------------------------------
void CFrame::drawRect (CDrawContext* pContext, const CRect& updateRect)
{
if (updateRect.getWidth () <= 0 || updateRect.getHeight () <= 0 || pContext == 0)
return;
if (pContext)
pContext->remember ();
CRect oldClip;
pContext->getClipRect (oldClip);
CRect newClip (updateRect);
newClip.bound (oldClip);
pContext->setClipRect (newClip);
// draw the background and the children
CViewContainer::drawRect (pContext, updateRect);
pContext->setClipRect (oldClip);
pContext->forget ();
}
//-----------------------------------------------------------------------------
void CDataBrowser::valueChanged (CControl *pControl)
{
CPoint origOffset = getScrollOffset ();
CScrollView::valueChanged (pControl);
CPoint offset = getScrollOffset ();
if (origOffset != offset)
{
switch (pControl->getTag ())
{
case kHSBTag:
{
if (dbHeader)
{
CRect viewSize = dbHeader->getViewSize (viewSize);
CCoord width = viewSize.getWidth ();
viewSize.left = offset.x;
viewSize.setWidth (width);
dbHeader->setViewSize (viewSize);
dbHeader->setMouseableArea (viewSize);
dbHeader->invalid ();
}
break;
}
}
if (isAttached () && (mouseDownView == dbView || mouseDownView == 0))
{
CPoint where;
getFrame ()->getCurrentMouseLocation (where);
if (getFrame ()->getViewAt (where, true) == dbView)
{
int32_t row = -1;
int32_t column = -1;
dbView->frameToLocal (where);
dbView->getCell (where, row, column);
db->dbOnMouseMoved (where, getFrame ()->getCurrentMouseButtons (), row, column, this);
}
}
}
}
//-----------------------------------------------------------------------------
void CDrawContext::drawString (UTF8StringPtr _string, const CRect& _rect, const CHoriTxtAlign hAlign, bool antialias)
{
if (!_string || currentState.font == 0)
return;
IFontPainter* painter = currentState.font->getFontPainter ();
if (painter == 0)
return;
const CString& string = getDrawString (_string);
CRect rect (_rect);
double capHeight = -1;
IPlatformFont* platformFont = currentState.font->getPlatformFont ();
if (platformFont)
capHeight = platformFont->getCapHeight ();
if (capHeight > 0.)
rect.bottom -= (rect.height ()/2 - capHeight / 2);
else
rect.bottom -= (rect.height ()/2 - currentState.font->getSize () / 2) + 1;
if (hAlign != kLeftText)
{
CCoord stringWidth = painter->getStringWidth (this, string, antialias);
if (hAlign == kRightText)
rect.left = rect.right - stringWidth;
else
rect.left = (CCoord)(rect.left + (rect.getWidth () / 2.f) - (stringWidth / 2.f));
}
CRect oldClip;
getClipRect (oldClip);
CRect newClip (_rect);
newClip.bound (oldClip);
setClipRect (newClip);
painter->drawString (this, string, CPoint (rect.left, rect.bottom), antialias);
setClipRect (oldClip);
clearDrawString ();
}
//-----------------------------------------------------------------------------
Win32Frame::Win32Frame (IPlatformFrameCallback* frame, const CRect& size, HWND parent)
: IPlatformFrame (frame)
, windowHandle (0)
, parentWindow (parent)
, tooltipWindow (0)
, backBuffer (0)
, deviceContext (0)
, inPaint (false)
, mouseInside (false)
, updateRegionList (0)
, updateRegionListSize (0)
{
initWindowClass ();
DWORD style = isParentLayered (parent) ? WS_EX_TRANSPARENT : 0;
#if !DEBUG_DRAWING
if (getD2DFactory ()) // workaround for Direct2D hotfix (KB2028560)
{
// when WS_EX_COMPOSITED is set drawing does not work correctly. This seems like a bug in Direct2D wich happens with this hotfix
}
else if (getSystemVersion ().dwMajorVersion >= 6) // Vista and above
style |= WS_EX_COMPOSITED;
else
backBuffer = createOffscreenContext (size.getWidth (), size.getHeight ());
#endif
windowHandle = CreateWindowEx (style, gClassName, TEXT("Window"),
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
0, 0, (int)size.width (), (int)size.height (),
parentWindow, NULL, GetInstance (), NULL);
if (windowHandle)
{
SetWindowLongPtr (windowHandle, GWLP_USERDATA, (__int3264)(LONG_PTR)this);
RegisterDragDrop (windowHandle, new CDropTarget (this));
}
}
//-------------------------------------------------
// DebugHelpers
//-------------------------------------------------
//
void TraceRect( const CRect& r, const string s )
{
TRACE( "%s : left=%d top=%d right=%d bottom=%d width=%d height=%d\n", s.c_str(), r.left, r.top, r.right, r.bottom, r.getWidth(), r.getHeight() );
}
