BOOL CBCGPTagManager::ParseColor (const CString& strItem, CBCGPColor& value) { CBCGPTagManager tm (strItem); CStringArray sa; CString strA, strR, strG, strB; tm.ExcludeTag (s_A, strA); strA.TrimLeft (); strA.TrimRight (); tm.ExcludeTag (s_R, strR); strR.TrimLeft (); strR.TrimRight (); tm.ExcludeTag (s_G, strG); strG.TrimLeft (); strG.TrimRight (); tm.ExcludeTag (s_B, strB); strB.TrimLeft (); strB.TrimRight (); if (strR.IsEmpty () || strG.IsEmpty () || strB.IsEmpty ()) { if (!ParseString (strItem, _T(","), sa, TRUE, FALSE)) { strR = tm.GetBuffer (); strR.TrimLeft (); strR.TrimRight (); sa.Add (strR); } } else { sa.Add (strR); sa.Add (strG); sa.Add (strB); if (!strA.IsEmpty ()) { sa.Add (strA); } } if (sa.GetSize () > 0) { const int count = (int) sa.GetSize (); if (count >= 3) { value.r = bcg_clamp((double)_ttol(sa[0]) / 255.0, 0.0, 1.0); value.g = bcg_clamp((double)_ttol(sa[1]) / 255.0, 0.0, 1.0); value.b = bcg_clamp((double)_ttol(sa[2]) / 255.0, 0.0, 1.0); value.a = count == 4 ? bcg_clamp((double)_ttol(sa[3]) / 255.0, 0.0, 1.0) : 1.0; return TRUE; } } return FALSE; }
BOOL CBCGPTagManager::ParseTextFormat (const CString& strItem, CBCGPTextFormat& value) { CBCGPTagManager tm (strItem); CString family; tm.ReadString (s_TextFormatFamily, family); if (family.IsEmpty ()) { return FALSE; } double size = 0.0; tm.ReadDouble (s_TextFormatSize, size); if (size == 0.0) { return FALSE; } int nValue = 0; tm.ReadInt (s_TextFormatWeight, nValue); long weight = (long)bcg_clamp(nValue, FW_THIN, FW_HEAVY); nValue = (int)CBCGPTextFormat::BCGP_FONT_STYLE_NORMAL; tm.ReadInt (s_TextFormatStyle, nValue); CBCGPTextFormat::BCGP_FONT_STYLE style = (CBCGPTextFormat::BCGP_FONT_STYLE) bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_FONT_STYLE_NORMAL, (int)CBCGPTextFormat::BCGP_FONT_STYLE_ITALIC); CString locale; tm.ReadString (s_TextFormatLocale, locale); CBCGPTextFormat format(family, (float)size, weight, style, locale); nValue = (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING; tm.ReadInt (s_TextFormatAlignHorz, nValue); format.SetTextAlignment ((CBCGPTextFormat::BCGP_TEXT_ALIGNMENT) bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_CENTER)); nValue = (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING; tm.ReadInt (s_TextFormatAlignVert, nValue); format.SetTextVerticalAlignment ((CBCGPTextFormat::BCGP_TEXT_ALIGNMENT) bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_CENTER)); BOOL bValue = FALSE; tm.ReadBool (s_TextFormatWordWrap, bValue); format.SetWordWrap (bValue); bValue = FALSE; tm.ReadBool (s_TextFormatClipping, bValue); format.SetClipText (bValue); double dValue = 0.0; tm.ReadDouble (s_TextFormatAngle, dValue); format.SetDrawingAngle (dValue); value = format; return TRUE; }
void bcg_setLineLength (const CBCGPPoint& pt1, CBCGPPoint& pt2, double dNewLength) { double dLen = bcg_distance (pt1, pt2); double cosT = (dLen > DBL_EPSILON) ? bcg_clamp ((pt2.x - pt1.x) / dLen, -1.0, 1.0) : 1.0; double sinT = (dLen > DBL_EPSILON) ? bcg_clamp ((pt2.y - pt1.y) / dLen, -1.0, 1.0) : 0.0; pt2.x = pt1.x + dNewLength * cosT; pt2.y = pt1.y + dNewLength * sinT; }
CString CBCGPTagManager::WriteBrush (const CString& strTag, const CBCGPBrush& value) { CString strValue; WriteTag (strValue, WriteInt (s_BrushType, value.GetGradientType(), CBCGPBrush::BCGP_NO_GRADIENT)); if (value.GetGradientType() == CBCGPBrush::BCGP_NO_GRADIENT) { WriteTag (strValue, WriteColor (s_BrushColor, value.GetColor())); } else { CString strColors; WriteTag (strColors, WriteColor (s_BrushColor, value.GetColor())); WriteTag (strColors, WriteColor (s_BrushColor, value.GetGradientColor())); WriteItem (strValue, s_BrushColors, strColors); } WriteTag (strValue, WriteInt (s_Opacity, bcg_clamp(bcg_round(value.GetOpacity() * 255.0), 0, 255), 255)); CString str; WriteItem (str, strTag, strValue); return str; }
CBCGPColorTableFunction::CBCGPColorTableFunction(int size) : m_Colors(NULL) { m_Size = bcg_clamp (size, 0, 256); ASSERT(m_Size > 1); m_R.SetInput (0, m_Size - 1, 1); m_G.SetInput (0, m_Size - 1, 1); m_B.SetInput (0, m_Size - 1, 1); }
BOOL CBCGPTagManager::ParseBrush (const CString& strItem, CBCGPBrush& value) { CBCGPTagManager tm (strItem); int type = CBCGPBrush::BCGP_NO_GRADIENT; tm.ReadInt(s_BrushType, type); type = bcg_clamp(type, CBCGPBrush::BCGP_NO_GRADIENT, CBCGPBrush::BCGP_GRADIENT_RADIAL_BOTTOM_RIGHT); int opacity = 255; tm.ReadInt (s_Opacity, opacity); if (type == CBCGPBrush::BCGP_NO_GRADIENT) { CBCGPColor clr; tm.ReadColor (s_BrushColor, clr); value.SetColor (clr, bcg_clamp((double)opacity / 255.0, 0.0, 1.0)); } else { CString strColors; if (tm.ExcludeTag (s_BrushColors, strColors)) { CBCGPTagManager tmColors(strColors); CBCGPColor clr1; tmColors.ReadColor (s_BrushColor, clr1); CBCGPColor clr2; tmColors.ReadColor (s_BrushColor, clr2); value.SetColors (clr1, clr2, (CBCGPBrush::BCGP_GRADIENT_TYPE)type, bcg_clamp((double)opacity / 255.0, 0.0, 1.0)); } } return TRUE; }
void CBCGPTransferFunction::Calculate(CArray<double, double>& output) const { output.RemoveAll(); int size = (int)m_Points.GetSize(); if (size == 0) { return; } int count = (int)fabs((m_InputValueMax - m_InputValueMin) / m_InputValueStep) + 1; if (count == 1) { return; } output.SetSize(count); XPoint pt(m_Points[0]); if (m_InputValueMin < pt.m_Point) { for (int i = 0; i <= GetIndex(pt.m_Point); i++) { output[i] = pt.m_Value; } } if (size > 1) { pt = m_Points[size - 1]; } if (pt.m_Point < m_InputValueMax) { for (int i = GetIndex(pt.m_Point); i < count; i++) { output[i] = pt.m_Value; } } // linear size = (int)m_Points.GetSize (); if (size < 2) { return; } for(long k = size - 1; k >= 1; k--) { CArray<double, double> points; XPoint pt1(m_Points[k - 1]); XPoint pt2(m_Points[k]); int index1 = GetIndex(pt1.m_Point); int index2 = GetIndex(pt2.m_Point); double dY = (pt2.m_Value - pt1.m_Value) / (double)(index2 - index1); double value = pt1.m_Value; for(int i = index1; i <= index2; i++) { points.Add(bcg_clamp(value, m_OutputValueMin, m_OutputValueMax)); value += dY; } if(points.GetSize() <= 2) { continue; } int kInsert = index1; for(int kk = 0; kk <= points.GetSize() - 1; kk++) { output[kInsert++] = points[kk]; } } }
CString CBCGPTagManager::WriteColor (const CString& strTag, const CBCGPColor& value) { CString strValue; COLORREF clr = value; if (value.a == 1.0) { strValue.Format (_T("%d, %d, %d"), GetRValue (clr), GetGValue (clr), GetBValue (clr)); } else { strValue.Format (_T("%d, %d, %d, %d"), GetRValue (clr), GetGValue (clr), GetBValue (clr), bcg_clamp(bcg_round(value.a * 255.0), 0, 255)); } return WriteString (strTag, strValue); }
//******************************************************************************* void CBCGPLinearGaugeImpl::CreatePointerPoints(CBCGPPointsArray& arPoints, int nPointerIndex, BOOL bShadow) { if (m_rect.IsRectEmpty()) { return; } CBCGPLinearGaugePointer* pData = DYNAMIC_DOWNCAST(CBCGPLinearGaugePointer, m_arData[nPointerIndex]); if (pData == NULL) { ASSERT(FALSE); return; } CBCGPGaugeScaleObject* pScale = GetScale(pData->GetScale()); if (pScale == NULL) { ASSERT(FALSE); return; } const double scaleRatio = GetScaleRatioMid(); double dblValue = pData->m_nAnimTimerID != 0 ? pData->m_dblAnimatedValue : pData->m_dblValue; double dblSizeMax = max(pScale->m_dblMajorTickMarkSize, 2. * pScale->m_dblMinorTickMarkSize) * scaleRatio; double dblSize = dblSizeMax; if (dblSize == 0) { dblSize = 8. * scaleRatio; } double dblSizePerc = bcg_clamp(pData->m_dblSize, 0.0, 1.0); if (dblSizePerc != 0.0) { dblSize = max(dblSize * dblSizePerc, 2.0); } CBCGPPoint point; if (!ValueToPoint(dblValue, point, pData->GetScale())) { return; } double offset = max(pScale->m_dblMajorTickMarkSize, pScale->m_dblMinorTickMarkSize) * scaleRatio; offset = max(offset, m_dblMaxRangeSize); double x = point.x; double y = point.y; if (dblSize < dblSizeMax && pData->GetPosition() != CBCGPLinearGaugePointer::BCGP_GAUGE_POSITION_NEAR) { double dblSizeDelta = dblSizeMax - dblSize; if (pData->GetPosition() == CBCGPLinearGaugePointer::BCGP_GAUGE_POSITION_CENTER) { dblSizeDelta /= 2.0; } if (m_bIsVertical) { x += dblSizeDelta; } else { y += dblSizeDelta; } } if (bShadow) { x += 2. * m_sizeScaleRatio.cx; y += 2. * m_sizeScaleRatio.cy; } const double delta = pData->m_dblWidth == 0 ? dblSize / 2 : (pData->m_dblWidth * scaleRatio) / 2; switch (pData->GetStyle()) { case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_TRIANGLE: if (m_bIsVertical) { arPoints.Add(CBCGPPoint(x, y - delta)); arPoints.Add(CBCGPPoint(x, y + delta)); arPoints.Add(CBCGPPoint(x + dblSize, y)); } else { arPoints.Add(CBCGPPoint(x + delta, y)); arPoints.Add(CBCGPPoint(x - delta, y)); arPoints.Add(CBCGPPoint(x, y + dblSize)); } break; case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_TRIANGLE_INV: if (m_bIsVertical) { arPoints.Add(CBCGPPoint(x + dblSize, y - delta)); arPoints.Add(CBCGPPoint(x + dblSize, y + delta)); arPoints.Add(CBCGPPoint(x, y)); } else { arPoints.Add(CBCGPPoint(x + delta, y + dblSize)); arPoints.Add(CBCGPPoint(x - delta, y + dblSize)); arPoints.Add(CBCGPPoint(x, y)); } break; case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_RECT: case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_CIRCLE: if (m_bIsVertical) { arPoints.Add(CBCGPPoint(x, y + delta)); arPoints.Add(CBCGPPoint(x, y - delta)); arPoints.Add(CBCGPPoint(x + dblSize, y - delta)); arPoints.Add(CBCGPPoint(x + dblSize, y + delta)); } else { arPoints.Add(CBCGPPoint(x + delta, y + dblSize)); arPoints.Add(CBCGPPoint(x - delta, y + dblSize)); arPoints.Add(CBCGPPoint(x - delta, y)); arPoints.Add(CBCGPPoint(x + delta, y)); } break; case CBCGPLinearGaugePointer::BCGP_GAUGE_NEEDLE_DIAMOND: if (m_bIsVertical) { arPoints.Add(CBCGPPoint(x + .5 * dblSize, y + delta)); arPoints.Add(CBCGPPoint(x, y)); arPoints.Add(CBCGPPoint(x + .5 * dblSize, y - delta)); arPoints.Add(CBCGPPoint(x + dblSize, y)); } else { arPoints.Add(CBCGPPoint(x, y + dblSize)); arPoints.Add(CBCGPPoint(x - delta, y + .5 * dblSize)); arPoints.Add(CBCGPPoint(x, y)); arPoints.Add(CBCGPPoint(x + delta, y + .5 * dblSize)); } } }
//*********************************************************************************************************** void CBCGPBaseVisualCtrl::OnDrawLayeredPopup() { CRect rect; GetClientRect (rect); if (rect.Width () == 0 || rect.Height () == 0) { return; } CPoint point (0, 0); CSize size (rect.Size ()); LPBYTE pBits = NULL; HBITMAP hBitmap = CBCGPDrawManager::CreateBitmap_32 (size, (void**)&pBits); if (hBitmap == NULL) { return; } CBitmap bitmap; bitmap.Attach (hBitmap); CClientDC clientDC(this); CDC dc; dc.CreateCompatibleDC (&clientDC); CBitmap* pBitmapOld = (CBitmap*)dc.SelectObject (&bitmap); if (m_pGM == NULL) { CBCGPGraphicsManagerParams params; params.bAlphaModePremultiplied = TRUE; m_pGM = CBCGPGraphicsManager::CreateInstance(CBCGPGraphicsManager::BCGP_GRAPHICS_MANAGER_DEFAULT, TRUE, ¶ms); if (m_pGM == NULL) { return; } m_pGM->EnableTransparentGradient(); } SetRect(rect); m_pGM->BindDC(&dc, rect); if (!m_pGM->BeginDraw()) { return; } OnDraw(m_pGM, rect); SetDirty(FALSE); m_pGM->EndDraw(); m_pGM->BindDC(NULL); BLENDFUNCTION bf; bf.BlendOp = AC_SRC_OVER; bf.BlendFlags = 0; bf.SourceConstantAlpha = (BYTE)bcg_clamp(m_nPopupAlpha, 0, 255); bf.AlphaFormat = LWA_COLORKEY; #ifndef _BCGSUITE_ globalData.UpdateLayeredWindow (GetSafeHwnd (), NULL, 0, &size, dc.GetSafeHdc (), &point, 0, &bf, 0x02); #else UpdateLayeredWindow (NULL, 0, &size, &dc, &point, 0, &bf, 0x02); #endif dc.SelectObject (pBitmapOld); }
//*********************************************************************************************************** BOOL CBCGPBaseVisualCtrl::DoPrint(CDC* pDCIn, CPrintInfo* pInfo) { CObject* pBaseVisual = GetVisualBaseObject(); if (pBaseVisual == NULL) { return FALSE; } CBCGPBaseVisualObject* pVisualObject = DYNAMIC_DOWNCAST(CBCGPBaseVisualObject, pBaseVisual); CBCGPVisualContainer* pVisualContainer = DYNAMIC_DOWNCAST(CBCGPVisualContainer, pBaseVisual); if (pVisualObject == NULL && pVisualContainer == NULL) { return FALSE; } CBCGPGraphicsManager* pGM = GetGraphicsManager(); if (pGM == NULL) { return FALSE; } ASSERT_VALID(pGM); CDC* pDC = pDCIn; CPrintDialog* pPrintDlg = NULL; if (pDC == NULL) { pPrintDlg = new CPrintDialog(FALSE); if (pPrintDlg->DoModal() == IDCANCEL) { delete pPrintDlg; return FALSE; } pDC = CDC::FromHandle(pPrintDlg->GetPrinterDC()); pDC->m_bPrinting = TRUE; CString strTitle; strTitle.LoadString(AFX_IDS_APP_TITLE); DOCINFO di; ZeroMemory(&di, sizeof (DOCINFO)); di.cbSize = sizeof (DOCINFO); di.lpszDocName = strTitle; if (!pDC->StartDoc(&di)) { pDC->AbortDoc(); delete pPrintDlg; return FALSE; } pInfo = new CPrintInfo(); pInfo->m_rectDraw.SetRect(0,0, pDC->GetDeviceCaps(HORZRES), pDC->GetDeviceCaps(VERTRES)); } CSize size(pInfo->m_rectDraw.Size()); CBCGPRect rect(CBCGPPoint(), size); CBCGPRect rectControl(pVisualObject != NULL ? pVisualObject->GetRect() : pVisualContainer->GetRect()); CBCGPSize sizeScaleRatio((double)size.cx / rectControl.Width(), (double)size.cy / rectControl.Height()); double dAspect = min(sizeScaleRatio.cx, sizeScaleRatio.cy); sizeScaleRatio.cx = sizeScaleRatio.cy = dAspect; size.cx = bcg_clamp((int)(rectControl.Width() * dAspect), 0, size.cx); size.cy = bcg_clamp((int)(rectControl.Height() * dAspect), 0, size.cy); rect.SetSize(size); CDC dcPrint; CBitmap bmpPrint; CBitmap* pBmpPrintOld = NULL; CDC* pDCOut = NULL; CBrush brWhite(RGB(255, 255, 255)); if (DYNAMIC_DOWNCAST(CBCGPGraphicsManagerGDI, pGM) != NULL) { dcPrint.CreateCompatibleDC(NULL); bmpPrint.Attach(CBCGPDrawManager::CreateBitmap_32(size, NULL)); pBmpPrintOld = dcPrint.SelectObject (&bmpPrint); ASSERT(pBmpPrintOld != NULL); pDCOut = &dcPrint; } else { pGM->SetPrintInfo(pInfo); pDCOut = pDC; } pDCOut->FillRect((CRect)rect, &brWhite); pGM->BindDC(pDCOut); if (pGM->IsBindDCFailed()) { pDCOut->FillRect((CRect)rect, &brWhite); pDCOut->TextOut(0, 0, _T("Out of memory")); } else { pGM->BeginDraw(); CBCGPSize sizeScaleRatioOld; if (pVisualObject != NULL) { sizeScaleRatioOld = pVisualObject->GetScaleRatio(); pVisualObject->SetScaleRatio(sizeScaleRatio); pVisualObject->SetRect(rect); } else { sizeScaleRatioOld = pVisualContainer->GetScaleRatio(); pVisualContainer->SetScaleRatio(sizeScaleRatio); pVisualContainer->SetRect(rect); } pGM->Clear(); if (pVisualObject != NULL) { pVisualObject->OnDraw (pGM, rect); } else { pVisualContainer->OnDraw (pGM, rect); } pGM->EndDraw(); pGM->BindDC(NULL); if (pVisualObject != NULL) { pVisualObject->SetScaleRatio(sizeScaleRatioOld); } else { pVisualContainer->SetScaleRatio(sizeScaleRatioOld); } if (dcPrint.GetSafeHdc() != NULL) { CBCGPDrawManager::FillAlpha (rect, (HBITMAP)bmpPrint.GetSafeHandle (), 255); } } if (pVisualObject != NULL) { pVisualObject->SetRect(rectControl); pVisualObject->SetDirty (); } else { pVisualContainer->SetRect(rectControl); pVisualContainer->SetDirty (); } if (dcPrint.GetSafeHdc() != NULL) { BITMAP bmp = {0}; bmpPrint.GetBitmap (&bmp); CRect rectOut(pInfo->m_rectDraw.TopLeft (), CSize(bmp.bmWidth, bmp.bmHeight)); int mode = pDC->SetStretchBltMode(HALFTONE); pDC->BitBlt (rectOut.left, rectOut.top, rectOut.Width(), rectOut.Height(), &dcPrint, 0, 0, SRCCOPY); pDC->SetStretchBltMode(mode); dcPrint.SelectObject(pBmpPrintOld); } else { pGM->SetPrintInfo(NULL); } if (pPrintDlg != NULL) { pDC->EndDoc(); delete pPrintDlg; delete pInfo; } return TRUE; }
//******************************************************************************* void CBCGPKnob::CreatePointerPoints(double dblRadius, CBCGPPointsArray& arPoints, int nPointerIndex, BOOL bShadow) { if (m_rect.IsRectEmpty()) { return; } CBCGPRect rect = m_rect; CBCGPKnobPointer* pData = DYNAMIC_DOWNCAST(CBCGPKnobPointer, m_arData[nPointerIndex]); if (pData == NULL) { ASSERT(FALSE); return; } CBCGPCircularGaugeScale* pScale = GetScale(pData->GetScale()); if (pScale == NULL) { ASSERT(FALSE); return; } const double scaleRatio = GetScaleRatioMid(); double dblValue = pData->IsAnimated() ? pData->GetAnimatedValue() : pData->GetValue(); double dblOffset = bcg_clamp(pData->GetOffsetFromCenter(), 0.0, 1.0); if (dblOffset == 0.0) { dblOffset = dblRadius * .5; } else { dblOffset = dblRadius * bcg_clamp(dblOffset, 0.5, 1.0); } double dblAngle = bcg_deg2rad(pScale->GetStartAngle()) - bcg_deg2rad(pScale->GetStartAngle() - pScale->GetFinishAngle()) * (dblValue - pScale->GetStart()) / (pScale->GetFinish() - pScale->GetStart()); dblAngle = bcg_normalize_rad (dblAngle); if (bShadow) { rect.OffsetRect(2 * m_sizeScaleRatio.cx, 2 * m_sizeScaleRatio.cy); } CBCGPPoint center((rect.left + rect.right) / 2.0, (rect.top + rect.bottom) / 2.0); const double angleCos = cos(dblAngle); const double angleSin = sin(dblAngle); double dblWidth = bcg_clamp(pData->GetWidth(), 0.0, dblRadius / 10.0); const double dblPointerAngle = dblAngle - M_PI_2; switch (pData->GetStyle()) { case CBCGPKnobPointer::BCGP_KNOB_POINTER_HANDLE: { dblRadius -= .2 * scaleRatio; double dblExtend = (dblRadius * .9); double dblSize = dblRadius + dblExtend; center.x -= angleCos * dblExtend; center.y += angleSin * dblExtend; if (dblWidth == 0.0) { dblWidth = dblRadius / 3.0; } dblWidth *= 0.5; if (dblWidth < 1.0) { arPoints.Add(center); arPoints.Add(CBCGPPoint( center.x + angleCos * dblSize, center.y - angleSin * dblSize)); } else { double dblArrowLen = max(2.0 * dblWidth, 10.0 * scaleRatio); dblSize -= dblArrowLen; const double dx = cos(dblPointerAngle) * dblWidth; const double dy = -sin(dblPointerAngle) * dblWidth; arPoints.Add(CBCGPPoint(center.x + dx, center.y + dy)); arPoints.Add(CBCGPPoint(center.x - dx, center.y - dy)); const CBCGPPoint pt1( center.x + angleCos * dblSize - dx, center.y - angleSin * dblSize - dy); const CBCGPPoint pt2( center.x + angleCos * dblSize + dx, center.y - angleSin * dblSize + dy); arPoints.Add(pt1); arPoints.Add(CBCGPPoint( center.x + angleCos * (dblSize + dblArrowLen), center.y - angleSin * (dblSize + dblArrowLen))); arPoints.Add(pt2); } } break; case CBCGPKnobPointer::BCGP_KNOB_POINTER_LINE: { if (bShadow) { return; } if (dblWidth == 0.0) { dblWidth = 2. * scaleRatio; } const double dx = cos(dblPointerAngle) * dblWidth; const double dy = -sin(dblPointerAngle) * dblWidth; arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset - dx, center.y - angleSin * dblOffset - dy)); arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset + dx, center.y - angleSin * dblOffset + dy)); dblOffset = dblRadius - 4. * scaleRatio; arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset + dx, center.y - angleSin * dblOffset + dy)); arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset - dx, center.y - angleSin * dblOffset - dy)); } break; case CBCGPKnobPointer::BCGP_KNOB_POINTER_CIRCLE: { if (bShadow) { return; } if (dblWidth == 0.0) { dblWidth = max(2. * scaleRatio, dblRadius / 8); } dblOffset = dblRadius - 6. * scaleRatio - dblWidth; arPoints.Add(CBCGPPoint(center.x + angleCos * dblOffset, center.y - angleSin * dblOffset)); arPoints.Add(CBCGPPoint(dblWidth, dblWidth)); } break; } }