Пример #1
0
void BkgroundUI::drawPolyRegion(__in RECT &rc)
{
	CCustomPaintDC paintDC(m_hwnd, RGB(255, 0, 0), 2);
	HDC hPaintDC = paintDC.getDC();

	Ellipse(hPaintDC, rc.left, rc.top, rc.right, rc.bottom);
}
Пример #2
0
void thBarViewCtrl::OnPaint(wxPaintEvent &event)
{
    wxPaintDC paintDC(this);
    wxMemoryDC memDC;
    memDC.SelectObject(dbw.m_bmp);
    paintDC.Blit(0, 0, m_rcClient.width, m_rcClient.height, &memDC, 0, 0);
}
Пример #3
0
void CGdiTool::OnPaint()
{
	CPaintDC paintDC(mpParent);
	Gdiplus::Graphics graphics(paintDC.GetSafeHdc());
	CRect rc = paintDC.m_ps.rcPaint;
	graphics.Clear(Gdiplus::Color::Gray);
}
Пример #4
0
void BkgroundUI::drawRect(__in RECT &rc)
{
	CCustomPaintDC paintDC(m_hwnd, RGB(255, 0, 0), 2);
	HDC hPaintDC = paintDC.getDC();

	Rectangle(hPaintDC, rc.left + 1, rc.top + 1, rc.right, rc.bottom);
}
Пример #5
0
//
// EvPaint member function responds to WM_PAINT messages
//
void
TPlayWindow::EvPaint()
{
  TPaintDC paintDC(HWindow);
  paintDC.SetBkColor(RGB(196, 196, 196));

  // TMidi-Titel
  paintDC.TextOut(5, 5, MidiTitle);
  // ZeitSkala
  if ( MidiLength < 60000 )
    paintDC.TextOut(160, 20, "Seconds:", 8);
  else
    paintDC.TextOut(160, 20, "Minutes:", 8);
  paintDC.TextOut(50, 22, "0", 1);
  char buffer[10];
  if ( !MidiLength )
	 strcpy(buffer, "Unknown");
  if ( MidiLength < 60000 )
	 wsprintf(buffer, "%ld.%02ld", MidiLength/1000, (MidiLength%1000)/10);
  else
	 wsprintf(buffer, "%ld:%02ld.%02ld",
      MidiLength/60000,
      (MidiLength%60000)/1000,
      (MidiLength%1000)/10);
  paintDC.TextOut(315, 22, buffer, strlen(buffer));
}
Пример #6
0
void CMDIChild::OnPaint()
{
	CPaintDC paintDC(this);

	CRect rcClient = ::GetClientRect(this);

	CPen pen(PS_SOLID, 1, ::GetSysColor(COLOR_BTNSHADOW));
	CPen* pOldPen = paintDC.SelectObject(&pen);

	if (!m_bNavHidden)
	{
		paintDC.MoveTo(0, 0);
		paintDC.LineTo(m_rcSplitter.left, 0);
		paintDC.MoveTo(m_rcSplitter.right, 0);
		paintDC.LineTo(rcClient.right, 0);

		paintDC.MoveTo(m_rcSplitter.left, 0);
		paintDC.LineTo(m_rcSplitter.left, rcClient.bottom);
		paintDC.MoveTo(m_rcSplitter.right - 1, 0);
		paintDC.LineTo(m_rcSplitter.right - 1, rcClient.bottom);

		CRect rcSplitterBody = m_rcSplitter;
		rcSplitterBody.DeflateRect(1, 0, 1, 0);
		paintDC.FillSolidRect(rcSplitterBody, ::GetSysColor(COLOR_BTNFACE));
	}
	else
	{
		paintDC.MoveTo(0, 0);
		paintDC.LineTo(rcClient.right, 0);
	}

	paintDC.SelectObject(pOldPen);
}
Пример #7
0
void CMainFrame::OnPaint()
{
	CPaintDC paintDC(this);
	CDC memDC;
	memDC.CreateCompatibleDC(&paintDC);
	memDC.SelectObject(m_pBitmap);
	// paintDC.BitBlt(0,0,665,740,&memDC,0,0,SRCCOPY); //640,480&&&&&//932,711
	paintDC.BitBlt(0,0,1005,740,&memDC,0,0,SRCCOPY);
}
Пример #8
0
afx_msg void CMainWnd::OnPaint() {
	CPaintDC paintDC(this);
	CBitmap pic;
	pic.LoadBitmapW(IDB_BITMAP2);
	CDC dcTemp;
	dcTemp.CreateCompatibleDC(&paintDC);
	dcTemp.SelectObject(pic);
	GetDC()->BitBlt(0, 0, 100, 100, &dcTemp, 0, 0, SRCCOPY);

}
Пример #9
0
afx_msg void CMainWin::OnPaint() {
	CPaintDC paintDC(this);
	paintDC.TextOut(500, 50, TEXT("Лабораторная работа №2"));
	paintDC.TextOut(630, 220, "  RED");
	paintDC.TextOut(630, 290, "GREEN");
	paintDC.TextOut(630, 360, " BLUE");
	CRect elipse(300, 200, 500, 400);
	CBrush Paint;
	Paint.CreateSolidBrush(RGB(red, green, blue));
	paintDC.SelectObject(Paint);
	paintDC.Ellipse(elipse);
}
Пример #10
0
void AboutGameDialog::OnPaint()
{
  if (m_coverBitmap.GetBits() != NULL)
  {
    CPaintDC paintDC(this);

    CDC memDC;
    memDC.CreateCompatibleDC(&paintDC);
    CDibSection::SelectDibSection(memDC,&m_coverBitmap);

    paintDC.BitBlt(
      m_coverRect.left,m_coverRect.top,m_coverRect.Width(),m_coverRect.Height(),
      &memDC,0,0,SRCCOPY);
  }
  else
    Default();
}
Пример #11
0
void WinEDA_DrawPanel::OnPaint(wxPaintEvent & event)
/***************************************************/
{
wxPaintDC paintDC(this);
EDA_Rect tmp;
wxRect PaintClipBox;
wxPoint org;

	PrepareGraphicContext(&paintDC);
	tmp = m_ClipBox;

	org = m_ClipBox.GetOrigin();

	wxRegionIterator upd(GetUpdateRegion()); // get the update rect list

	while ( upd )
	{
		PaintClipBox = upd.GetRect();
		upd++;

		PaintClipBox.x += org.x;
		PaintClipBox.y += org.y;

#ifdef WX_ZOOM
		m_ClipBox.m_Pos.x = PaintClipBox.x * GetZoom();
		m_ClipBox.m_Pos.y = PaintClipBox.y * GetZoom();
		m_ClipBox.m_Size.x = PaintClipBox.m_Size.x * GetZoom();
		m_ClipBox.m_Size.y = PaintClipBox.m_Size.y * GetZoom();
		PaintClipBox = m_ClipBox;
#else
		m_ClipBox.SetX(PaintClipBox.GetX());
		m_ClipBox.SetY(PaintClipBox.GetY());
		m_ClipBox.SetWidth(PaintClipBox.GetWidth());
		m_ClipBox.SetHeight(PaintClipBox.GetHeight());
#endif

		wxDCClipper * dcclip = new wxDCClipper(paintDC, PaintClipBox);
		ReDraw(&paintDC, TRUE);
		delete dcclip;
	}

	m_ClipBox = tmp;
		
}
/**
 *	This is called when the control is repainted.
 */
/*afx_msg*/ void ChunkWatchControl::OnPaint()
{
	ScopedDogWatch dogWatchScope(s_chunkWatchPaint);

	// The extents of the control:
	CRect fullExtents;
	GetClientRect(fullExtents);

	// The drawing contexts:
	CPaintDC				paintDC(this);
	controls::MemDCScope	memDCScope(memDC_, paintDC, &fullExtents);

	memDC_.FillSolidRect(fullExtents, ::GetSysColor(COLOR_BTNFACE));

	// Calculate the drawing area:
	getDrawConstants();

	// Draw the details:
	if ((drawOptions_ & DRAW_PROJECTVIEW) != 0) drawProject   (memDC_);
	if ((drawOptions_ & DRAW_CHUNKS     ) != 0) drawChunks    (memDC_);
	if ((drawOptions_ & DRAW_UNLOADABLE ) != 0) drawUnloadable(memDC_);
	if ((drawOptions_ & DRAW_WORKING    ) != 0) drawWorking   (memDC_);
	if ((drawOptions_ & DRAW_GRID       ) != 0) drawGrid      (memDC_);
	if ((drawOptions_ & DRAW_USERPOS    ) != 0) drawArrow     (memDC_);
	if ((drawOptions_ & DRAW_FRUSTUM    ) != 0) drawFrustum   (memDC_);

	// Draw the outsides:
	memDC_.Draw3dRect
	(
		extents_, // around the tiles itself
		CLR_BORDER,
		CLR_BORDER
	);
	memDC_.Draw3dRect
	(
		fullExtents, 
		::GetSysColor(COLOR_3DHILIGHT),
		::GetSysColor(COLOR_3DSHADOW )
	);
}
Пример #13
0
/******************************************************************************
* CreateMyDC
*/
void CreateMyDC(CDC **dc, CBitmap **newBitmap, CBitmap **origBitmap, int bitCount)
{
   CPaintDC paintDC(activeView);

   // creat dc
   *dc = new CDC;
   (*dc)->CreateCompatibleDC(&paintDC);

   // Prepare DC
   (*dc)->SetMapMode(MM_ISOTROPIC);

   (*dc)->SetWindowOrg(0, 0);
   (*dc)->SetWindowExt(1, -1);

   (*dc)->SetViewportOrg(round(-doc->getSettings().getXmin() * scaleFactor), round(doc->getSettings().getYmax() * scaleFactor));
   (*dc)->SetViewportExt(1, 1);


   // create bitmap
   CreateMyBitmap(*dc, newBitmap, bitCount);

   // select bitmap into DC
   *origBitmap = (*dc)->SelectObject(*newBitmap);
}
Пример #14
0
void EffectAutoDuckPanel::OnPaint(wxPaintEvent & WXUNUSED(evt))
{
   int clientWidth, clientHeight;
   GetSize(&clientWidth, &clientHeight);

   if (!mBackgroundBitmap || mBackgroundBitmap->GetWidth() != clientWidth ||
       mBackgroundBitmap->GetHeight() != clientHeight)
   {
      if (mBackgroundBitmap)
         delete mBackgroundBitmap;
      mBackgroundBitmap = new wxBitmap(clientWidth, clientHeight);
   }

   wxMemoryDC dc;
   dc.SelectObject(*mBackgroundBitmap);

   dc.SetBrush(*wxWHITE_BRUSH);
   dc.SetPen(*wxBLACK_PEN);
   dc.DrawRectangle(0, 0, clientWidth, clientHeight);

   dc.SetFont(wxFont(10, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL,
                     wxFONTWEIGHT_NORMAL));
   dc.SetTextForeground(*wxBLACK);
   dc.SetTextBackground(*wxWHITE);

   double duckAmountDb = 0;
   double innerFadeDownLen = 0;
   double innerFadeUpLen = 0;
   double outerFadeDownLen = 0;
   double outerFadeUpLen = 0;
   mEffect->mDuckAmountDbBox->GetValue().ToDouble(&duckAmountDb);
   mEffect->mInnerFadeDownLenBox->GetValue().ToDouble(&innerFadeDownLen);
   mEffect->mInnerFadeUpLenBox->GetValue().ToDouble(&innerFadeUpLen);
   mEffect->mOuterFadeDownLenBox->GetValue().ToDouble(&outerFadeDownLen);
   mEffect->mOuterFadeUpLenBox->GetValue().ToDouble(&outerFadeUpLen);

   if (innerFadeDownLen < MIN_InnerFadeDownLen || innerFadeDownLen > MAX_InnerFadeDownLen ||
       innerFadeUpLen < MIN_InnerFadeUpLen     || innerFadeUpLen > MAX_InnerFadeUpLen     ||
       outerFadeDownLen < MIN_OuterFadeDownLen || outerFadeDownLen > MAX_OuterFadeDownLen ||
       outerFadeUpLen < MIN_OuterFadeUpLen     || outerFadeUpLen > MAX_OuterFadeUpLen     ||
       duckAmountDb < MIN_DuckAmountDb         || duckAmountDb > MAX_DuckAmountDb)
   {
      // values are out of range, no preview available
      wxString message = wxString::Format(_("Preview not available"));
      int textWidth = 0, textHeight = 0;
      dc.GetTextExtent(message, &textWidth, &textHeight);
      dc.DrawText(message, (clientWidth - textWidth) / 2,
                           (clientHeight - textHeight) / 2);

      ResetControlPoints();
   } else
   {
      // draw preview
      dc.SetBrush(*wxTRANSPARENT_BRUSH);
      dc.SetPen(wxPen(theTheme.Colour(clrGraphLines), 3, wxSOLID));

      wxPoint points[6];

      points[0].x = 10;
      points[0].y = DUCK_AMOUNT_START;

      points[1].x = FADE_DOWN_START - (int)(outerFadeDownLen * FADE_SCALE);
      points[1].y = DUCK_AMOUNT_START;

      points[2].x = FADE_DOWN_START + (int)(innerFadeDownLen * FADE_SCALE);
      points[2].y = DUCK_AMOUNT_START -
         (int)(duckAmountDb * DUCK_AMOUNT_SCALE);

      points[3].x = FADE_UP_START - (int)(innerFadeUpLen * FADE_SCALE);
      points[3].y = DUCK_AMOUNT_START -
         (int)(duckAmountDb * DUCK_AMOUNT_SCALE);

      points[4].x = FADE_UP_START + (int)(outerFadeUpLen * FADE_SCALE);
      points[4].y = DUCK_AMOUNT_START;

      points[5].x = clientWidth - 10;
      points[5].y = DUCK_AMOUNT_START;

      dc.DrawLines(6, points);

      dc.SetPen(wxPen(*wxBLACK, 1, wxDOT));

      AColor::Line(dc, FADE_DOWN_START, 10, FADE_DOWN_START, clientHeight - 10);
      AColor::Line(dc, FADE_UP_START, 10, FADE_UP_START, clientHeight - 10);

      dc.SetPen(AColor::envelopePen);
      dc.SetBrush(*wxWHITE_BRUSH);

      mControlPoints[outerFadeDown] = points[1];
      mControlPoints[innerFadeDown] = points[2];
      mControlPoints[innerFadeUp] = points[3];
      mControlPoints[outerFadeUp] = points[4];
      mControlPoints[duckAmount] = wxPoint(
         (points[2].x + points[3].x) / 2, points[2].y);

      for (int i = 0; i < AUTO_DUCK_PANEL_NUM_CONTROL_POINTS; i++)
      {
         EControlPoint cp = (EControlPoint)i;
         int digits;
         float value;

         if (cp == innerFadeDown)
         {
            value = innerFadeDownLen;
            digits = 2;
         }
         else if (cp == innerFadeUp)
         {
            value = innerFadeUpLen;
            digits = 2;
         }
         else if (cp == outerFadeDown)
         {
            value = outerFadeDownLen;
            digits = 2;
         } else if (cp == outerFadeUp)
         {
            value = outerFadeUpLen;
            digits = 2;
         }
         else
         {
            value = duckAmountDb;
            digits = 1;
         }

         wxString valueStr = Internat::ToDisplayString(value, digits);
         valueStr += wxT(" ");

         if (cp == duckAmount)
            /* i18n-hint: short form of 'decibels'.*/
            valueStr += _("dB");
         else
            /* i18n-hint: short form of 'seconds'.*/
            valueStr += _("s");

         int textWidth = 0, textHeight = 0;
         GetTextExtent(valueStr, &textWidth, &textHeight);

         int textPosX = mControlPoints[i].x - textWidth / 2;
         int textPosY = mControlPoints[i].y;

         if (cp == duckAmount || cp == outerFadeDown || cp == outerFadeUp)
            textPosY -= TEXT_DISTANCE + textHeight;
         else
            textPosY += TEXT_DISTANCE;

         dc.DrawText(valueStr, textPosX, textPosY);

         dc.DrawEllipse(mControlPoints[i].x - 3,
                        mControlPoints[i].y - 3, 6, 6);
      }
   }

   // copy background buffer to paint dc
   wxPaintDC paintDC(this);
   paintDC.Blit(0, 0, clientWidth, clientHeight, &dc, 0, 0);

   // clean up: necessary to free resources on Windows
   dc.SetPen(wxNullPen);
   dc.SetBrush(wxNullBrush);
   dc.SetFont(wxNullFont);
   dc.SelectObject(wxNullBitmap);
}
void CProgressCtrlEx::OnPaint()
{
	CPaintDC paintDC(this);

	int nMin = 0;
	int nMax = 0;

	GetRange(nMin, nMax);
	ASSERT(nMin <= nMax);

	int nPos = GetPos();
	ASSERT(nPos >= nMin && nPos <= nMax);

	DWORD dwStyle = GetStyle();

	BOOL bVertical = FALSE;
	if (dwStyle & PBS_VERTICAL)
	{
		bVertical = TRUE;
	}

	CDC dc;
	dc.CreateCompatibleDC(&paintDC);
	ASSERT(dc.GetSafeHdc());

	CRect rect;
	GetClientRect(&rect);

	CBitmap bmp;
	bmp.CreateCompatibleBitmap(&paintDC, rect.Width(), rect.Height());
	ASSERT(bmp.GetSafeHandle());

	CBitmap* pOldBitmap = (CBitmap*)dc.SelectObject(&bmp);

	CFont* pOldFont = NULL;
	CWnd* pParent = GetParent();
	ASSERT(pParent);

	CFont* pFont = pParent->GetFont();
	ASSERT(pFont);
	if (bVertical)
	{
		if (NULL == m_font.GetSafeHandle())
		{
			LOGFONT lf = { 0 };
			pFont->GetLogFont(&lf);
			lf.lfEscapement = 900;
			m_font.CreateFontIndirect(&lf);
		}
		ASSERT(m_font.GetSafeHandle());
		pOldFont = (CFont*)dc.SelectObject(&m_font);
	}
	else
	{
		pOldFont = (CFont*)dc.SelectObject(pFont);
	}

	double dPercent = (double)(nPos - nMin) / ((double)(nMax - nMin));

	dc.DrawEdge(rect, EDGE_SUNKEN, BF_RECT | BF_FLAT);

	CRect rc(rect);
	rc.DeflateRect(CSize(2, 2));
	dc.FillSolidRect(&rc, m_clrBarBkColor);

	CString strText(_T(""));
	GetWindowText(strText);

	if (m_bShowPercent)
	{
		strText.AppendFormat(_T("%d%% "), static_cast<int>((dPercent * 100.0) + 0.5));
	}

	dc.SetBkMode(TRANSPARENT);
	dc.SetTextColor(m_clrTextColor);

	CPoint pt(0, 0);
	CSize size = dc.GetOutputTextExtent(strText);

	if (!bVertical)
	{
		switch (m_AlignText)
		{
		case ALIGN_LEFT:
			pt.x = rc.left;
			break;

		case ALIGN_RIGHT:
			pt.x = rc.right - size.cx;
			break;

		case ALIGN_CENTER:
		default:
			pt.x = rc.left + (rc.Width() - size.cx) / 2;
			break;
		}
		pt.y = rc.top + (rc.Height() - size.cy) / 2;

		CRect rcPos(rc);

		rcPos.right = rcPos.left + (int)(dPercent * rcPos.Width());
		dc.FillSolidRect(rcPos, m_clrBarColor);

		dc.SetTextColor(m_clrTextColor);
		dc.ExtTextOut(pt.x, pt.y, ETO_OPAQUE, rcPos, strText, NULL);

		dc.SetTextColor(m_clrTextBkColor);
		dc.ExtTextOut(pt.x, pt.y, ETO_CLIPPED, &rcPos, strText, NULL);
	}
	else
	{
		switch (m_AlignText)
		{
		case ALIGN_LEFT:
			pt.y = rc.bottom;
			break;

		case ALIGN_RIGHT:
			pt.y = rc.top + size.cx;
			break;

		case ALIGN_CENTER:
		default:
			pt.y = rc.bottom - (rc.Height() - size.cx) / 2;
			break;
		}
		pt.x = rc.left + (rc.Width() - size.cy) / 2;

		CRect rcPos(rc);

		rcPos.top = rcPos.bottom - (int)(dPercent * rcPos.Height());
		dc.FillSolidRect(rcPos, m_clrBarColor);

		dc.SetTextColor(m_clrTextColor);
		dc.ExtTextOut(pt.x, pt.y, ETO_OPAQUE, rcPos, strText, NULL);

		dc.SetTextColor(m_clrTextBkColor);
		dc.ExtTextOut(pt.x, pt.y, ETO_CLIPPED, &rcPos, strText, NULL);
	}

	paintDC.BitBlt(rect.left, rect.top, rect.Width(), rect.Height(), &dc, 0, 0, SRCCOPY);

	dc.SelectObject(pOldFont);
	dc.SelectObject(pOldBitmap);
	bmp.DeleteObject();

	dc.DeleteDC();
}
Пример #16
0
void wxFlatButton::OnPaint(wxPaintEvent& event)
{
    wxUnusedVar(event);
    wxAutoBufferedPaintDC paintDC(this);
    wxGCDC gdc;
    GetGCDC(paintDC, gdc);

    wxRect clientRect = GetClientRect();
    // Draw the background
    gdc.SetPen(GetBarBgColour(m_theme));
    gdc.SetBrush(GetBarBgColour(m_theme));
    gdc.DrawRectangle(clientRect);

    switch(m_state) {
    case kStateHover: {
        if(!IsChecked()) {
            // Hover
            gdc.SetBrush(GetBgHoverColour());
            gdc.SetPen(m_penHoverOuterColour);
            gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);

            clientRect.Deflate(1);
            gdc.SetBrush(*wxTRANSPARENT_BRUSH);
            gdc.SetPen(m_penHoverColourInner);
            gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);

            // gdc.SetPen(m_penHoverColourInner);
            // gdc.DrawLine(clientRect.GetBottomLeft(), clientRect.GetTopLeft());
            // gdc.DrawLine(clientRect.GetTopLeft(), clientRect.GetTopRight());
            //
            // gdc.SetPen(m_penHoverOuterColour);
            // gdc.DrawLine(clientRect.GetTopRight(), clientRect.GetBottomRight());
            // gdc.DrawLine(clientRect.GetBottomRight(), clientRect.GetBottomLeft());
        }
        break;
    }
    case kStateNormal: {
        // do nothing
        gdc.SetBrush(GetBgColour());
        gdc.SetPen(GetPenNormalColour());
        gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);
        break;
    }
    case kStatePressed: {
        // Pressed
        gdc.SetBrush(GetBgPressedColour());
        gdc.SetPen(GetPenPressedColour());
        gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);

        // gdc.SetBrush(GetBgPressedColour());
        // gdc.DrawRectangle(clientRect);
        //
        // gdc.SetPen(m_penHoverOuterColour);
        // gdc.DrawLine(clientRect.GetBottomLeft(), clientRect.GetTopLeft());
        // gdc.DrawLine(clientRect.GetTopLeft(), clientRect.GetTopRight());
        //
        // gdc.SetPen(m_penHoverColourInner);
        // gdc.DrawLine(clientRect.GetTopRight(), clientRect.GetBottomRight());
        // gdc.DrawLine(clientRect.GetBottomRight(), clientRect.GetBottomLeft());
        break;
    }
    }

    // Draw text
    gdc.SetFont(GetTextFont());
    if(!IsEnabled()) {
        gdc.SetTextForeground(GetTextColourDisabled());
        gdc.DrawLabel(
            m_text, m_bmpDisabled, clientRect, wxALIGN_CENTER_VERTICAL | wxALIGN_CENTER_HORIZONTAL, m_accelIndex);
    } else {
        gdc.SetTextForeground(GetTextColour());
        gdc.DrawLabel(m_text, m_bmp, clientRect, wxALIGN_CENTER_VERTICAL | wxALIGN_CENTER_HORIZONTAL, m_accelIndex);
    }
}
Пример #17
0
void wxFlatButton::OnPaint(wxPaintEvent& event)
{
    wxUnusedVar(event);
    wxAutoBufferedPaintDC paintDC(this);
    PrepareDC(paintDC);

    wxGCDC gdc;
    GetGCDC(paintDC, gdc);

    wxRect clientRect = GetClientRect();
    // Draw the background
    gdc.SetPen(GetBarBgColour(m_theme));
    gdc.SetBrush(GetBarBgColour(m_theme));
    gdc.DrawRectangle(clientRect);

    switch(m_state) {
    case kStateHover: {
        // do nothing
        gdc.SetBrush(GetBgColour());
        gdc.SetPen(GetPenNormalColour());
        gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);
        break;
    }
    case kStateNormal: {
        break;
    }
    case kStatePressed: {
        // Pressed
        gdc.SetBrush(GetBgPressedColour());
        gdc.SetPen(GetPenPressedColour());
        gdc.DrawRoundedRectangle(clientRect, BTN_RADIUS);
        break;
    }
    }

    // Draw text
    gdc.SetFont(GetTextFont());
    wxColour textColour = IsEnabled() ? GetTextColour() : GetTextColourDisabled();
    wxBitmap bmp = IsEnabled() ? m_bmp : m_bmpDisabled;

    wxCoord textY;
    wxCoord bmpY;

    wxCoord totalLen = 0;
    const int spacer = 2;
    if(bmp.IsOk()) {
        // we got a bitmap
        totalLen += bmp.GetScaledWidth();
    }

    wxSize textSize;
    if(!m_text.IsEmpty()) {
        textSize = gdc.GetTextExtent(m_text);
        totalLen += spacer;
        totalLen += textSize.x;
    }

    wxCoord offset = (clientRect.GetWidth() - totalLen) / 2;
    bmpY = (clientRect.GetHeight() - bmp.GetScaledHeight()) / 2;
    textY = (clientRect.GetHeight() - textSize.y) / 2;
    if(bmp.IsOk()) {
        gdc.DrawBitmap(bmp, offset, bmpY);
        offset += bmp.GetScaledWidth();
        offset += spacer;
    }

    if(!m_text.IsEmpty()) {
        gdc.DrawText(m_text, offset, textY);
        offset += textSize.x;
        offset += spacer;
    }
}
Пример #18
0
void CMyToolBar::OnPaint()
{
	// Do nothing, but we still must create a paint DC in this handler,
	// otherwise Windows goes crazy.
	CPaintDC paintDC(this);
}