C++ wxDC::DrawText方法代码示例

void HexEditLineBuffer::Draw( wxDC& dc, int x, int y, int fontX, int fontY, wxColour* foregrounds, wxColour* backgrounds )
{
    for ( char* ptr = m_Buffer; ptr < m_End; )
    {
        // Searching for continous block with same style
        wxString str;

        do
        {
            str += wxChar( ptr[ 0 ] );
            ptr += 2;
        }
        while ( ( ptr < m_End ) && ( ptr[1] == ptr[-1] ) );

        char style = ptr[-1];

        dc.SetBrush( backgrounds[ (int)style ] );
        dc.SetPen( backgrounds[ (int)style ] );

        dc.DrawRectangle( x, y, fontX * str.length(), fontY );

        dc.SetPen( foregrounds[ (int)style ] );
        dc.SetTextForeground( foregrounds[ (int)style ] );
        dc.SetTextBackground( backgrounds[ (int)style ] );

        dc.DrawText( str, x, y );
        x += fontX * str.length();
    }
}

/**
 * Render the event in the bitmap
 */
void CppCodeEvent::Render(wxDC & dc, int x, int y, unsigned int width, gd::EventsEditorItemsAreas & areas, gd::EventsEditorSelection & selection, const gd::Platform & platform)
{
#if !defined(GD_NO_WX_GUI)
    gd::EventsRenderingHelper * renderingHelper = gd::EventsRenderingHelper::Get();
    const int titleTextHeight = 20;

    //Draw header rectangle
    wxRect headerRect(x, y, width, GetRenderedHeight(width, platform));
    renderingHelper->DrawNiceRectangle(dc, headerRect);

    //Header
    dc.SetFont( renderingHelper->GetNiceFont().Bold()  );
    dc.SetTextForeground(wxColour(0,0,0));
    dc.DrawText( (displayedName.empty() ? _("C++ code") : _("C++ code:")) + displayedName, x + 4, y + 3 );

    if ( codeDisplayedInEditor )
    {
        dc.SetFont( renderingHelper->GetFont() );
        dc.SetBrush(renderingHelper->GetActionsRectangleFillBrush());
        dc.SetPen(renderingHelper->GetActionsRectangleOutlinePen());

        dc.DrawRectangle(wxRect(x + 4, y + 3 + titleTextHeight + 2, width-8, GetRenderedHeight(width, platform)-(3 + titleTextHeight + 5)));
        dc.DrawLabel( inlineCode, wxNullBitmap, wxRect(x + 4, y + 3 + titleTextHeight + 4, width-2, GetRenderedHeight(width, platform)));
    }
#endif
}

void wxStatusBarGeneric::DrawFieldText(wxDC& dc, int i)
{
    int leftMargin = 2;

    wxRect rect;
    GetFieldRect(i, rect);

    wxString text(GetStatusText(i));

    long x = 0, y = 0;

    dc.GetTextExtent(text, &x, &y);

    int xpos = rect.x + leftMargin;
    int ypos = (int) (((rect.height - y) / 2 ) + rect.y + 0.5) ;

#if defined( __WXGTK__ ) || defined(__WXMAC__)
    xpos++;
    ypos++;
#endif

    dc.SetClippingRegion(rect.x, rect.y, rect.width, rect.height);

    dc.DrawText(text, xpos, ypos);

    dc.DestroyClippingRegion();
}

void
wxBannerWindow::DrawBannerTextLine(wxDC& dc,
                                   const wxString& str,
                                   const wxPoint& pos)
{
    switch ( m_direction )
    {
        case wxTOP:
        case wxBOTTOM:
            // The simple case: we just draw the text normally.
            dc.DrawText(str, pos);
            break;

        case wxLEFT:
            // We draw the text vertically and start from the lower left
            // corner and not the upper left one as usual.
            dc.DrawRotatedText(str, pos.y, GetClientSize().y - pos.x, 90);
            break;

        case wxRIGHT:
            // We also draw the text vertically but now we start from the upper
            // right corner and draw it from top to bottom.
            dc.DrawRotatedText(str, GetClientSize().x - pos.y, pos.x, -90);
            break;

        case wxALL:
            wxFAIL_MSG( wxS("Unreachable") );
    }
}

void wxStatusBarMac::DrawFieldText(wxDC& dc, int i)
{
    int leftMargin = 2;
    int w, h ;
    GetSize( &w , &h ) ;
    wxRect rect;
    GetFieldRect(i, rect);
    
    if ( !MacIsReallyHilited()  )
    {
        dc.SetTextForeground( wxColour( 0x80 , 0x80 , 0x80 ) ) ;
    }
    
    wxString text(GetStatusText(i));
    
    long x, y;
    
    dc.GetTextExtent(text, &x, &y);
    
    int xpos = rect.x + leftMargin + 1 ;
    int ypos = 1 ;
    
    if ( MacGetTopLevelWindow()->MacGetMetalAppearance()  )
        ypos++ ;
        
    dc.SetClippingRegion(rect.x, 0, rect.width, h);
    
    dc.DrawText(text, xpos, ypos);
    
    dc.DestroyClippingRegion();
}

void oglDrawFormattedText(wxDC& dc, wxList *text_list,
                       double m_xpos, double m_ypos, double width, double height,
                       int formatMode)
{
  double xoffset, yoffset;
  if (formatMode & FORMAT_CENTRE_HORIZ)
    xoffset = m_xpos;
  else
    xoffset = (double)(m_xpos - (width / 2.0));

  if (formatMode & FORMAT_CENTRE_VERT)
    yoffset = m_ypos;
  else
    yoffset = (double)(m_ypos - (height / 2.0));

  dc.SetClippingRegion(
                    (long)(m_xpos - width/2.0), (long)(m_ypos - height/2.0),
                    (long)width+1, (long)height+1); // +1 to allow for rounding errors

  wxObjectList::compatibility_iterator current = text_list->GetFirst();
  while (current)
  {
    wxShapeTextLine *line = (wxShapeTextLine *)current->GetData();

    dc.DrawText(line->GetText(), WXROUND(xoffset + line->GetX()), WXROUND(yoffset + line->GetY()));
    current = current->GetNext();
  }

  dc.DestroyClippingRegion();
}

/**
 * Render the event in the bitmap
 */
void TimedEvent::Render(wxDC & dc, int x, int y, unsigned int width, gd::EventsEditorItemsAreas & areas, gd::EventsEditorSelection & selection, const gd::Platform & platform)
{
    gd::EventsRenderingHelper * renderingHelper = gd::EventsRenderingHelper::Get();
    int border = renderingHelper->instructionsListBorder;
    const int functionTextHeight = 20;

    //Draw header rectangle
    wxRect headerRect(x, y, width, functionTextHeight);
    renderingHelper->DrawNiceRectangle(dc, headerRect);

    //Name
    dc.SetFont( renderingHelper->GetNiceFont().Bold()  );
    dc.SetTextForeground(wxColour(0,0,0));
    std::string nameTxt;
    if ( !name.empty() ) nameTxt = _T(" (Nom : "+name + ")");
    dc.DrawText( _("Delayed execution after ")+timeout.GetPlainString()+_(" seconds.")+" "+nameTxt, x + 4, y + 3 );

    //Draw conditions rectangle
    wxRect rect(x, y+functionTextHeight, renderingHelper->GetConditionsColumnWidth()+border, GetRenderedHeight(width, platform)-functionTextHeight);
    renderingHelper->DrawNiceRectangle(dc, rect);

    //Draw actions and conditions
    renderingHelper->DrawConditionsList(conditions, dc,
                                        x+border,
                                        y+functionTextHeight+border,
                                        renderingHelper->GetConditionsColumnWidth()-border, this, areas, selection, platform);
    renderingHelper->DrawActionsList(actions, dc,
                                     x+renderingHelper->GetConditionsColumnWidth()+border,
                                     y+functionTextHeight+border,
                                     width-renderingHelper->GetConditionsColumnWidth()-border*2, this, areas, selection, platform);
}

void wxStatusBarMac::DrawFieldText(wxDC& dc, int i)
{
    int leftMargin = 2;

    wxRect rect;
    GetFieldRect(i, rect);

    if ( !IsWindowHilited( MAC_WXHWND( MacGetRootWindow() ) ) )
    {
        dc.SetTextForeground( wxColour( 0x80 , 0x80 , 0x80 ) ) ;
    }

    wxString text(GetStatusText(i));

    long x, y;

    dc.GetTextExtent(text, &x, &y);

    int xpos = rect.x + leftMargin + 1 ;
    int ypos = 1 ;

    dc.SetClippingRegion(rect.x, 0, rect.width, m_height);

    dc.DrawText(text, xpos, ypos);

    dc.DestroyClippingRegion();
}

void ScrubbingOverlay::Draw(OverlayPanel &, wxDC &dc)
{
   mLastScrubRect = mNextScrubRect;
   mLastScrubSpeedText = mNextScrubSpeedText;

   Scrubber &scrubber = GetScrubber();
   if (!scrubber.ShouldDrawScrubSpeed())
      return;

   static const wxFont labelFont(24, wxSWISS, wxNORMAL, wxNORMAL);
   dc.SetFont(labelFont);

   // These two colors were previously saturated red and green.  However
   // we have a rule to try to only use red for reserved purposes of
   //  (a) Recording
   //  (b) Error alerts
   // So they were changed to 'orange' and 'lime'.
   static const wxColour clrNoScroll(215, 162, 0), clrScroll(0, 204, 153);
   if (scrubber.IsScrollScrubbing())
      dc.SetTextForeground(clrScroll);
   else
      dc.SetTextForeground(clrNoScroll);

   dc.DrawText(mLastScrubSpeedText, mLastScrubRect.GetX(), mLastScrubRect.GetY());
}

void RectangleShape::draw(wxDC& dc)
{
	// The minimum size of the RectangleShape is the size of the title
	titleSize = dc.GetTextExtent(WXSTRING(title));
	if (size.x < (titleSize.x + 2 * spacing + 2 * borderWidth)) {
		size.x = titleSize.x + 2 * spacing + 2 * borderWidth;
	}
	if (size.y < (titleSize.y + 2 * spacing + 2 * borderWidth)) {
		size.y = titleSize.y + 2 * spacing + 2 * borderWidth;
	}
	// Draws a rectangle with the given top left corner, and with the given
	// size.
	dc.SetBrush(*wxWHITE_BRUSH);
	if (isSelected()) {
		dc.SetPen(wxPen(WXSTRING(getSelectionColour()), borderWidth, wxSOLID));
	} else {
		dc.SetPen(wxPen(WXSTRING(getNormalColour()), borderWidth, wxSOLID));
	}

	int x = centre.x - (size.x / 2);
	int y = centre.y - (size.y / 2);
	dc.DrawRectangle(x, y, size.x, size.y);

	dc.SetPen(wxPen(WXSTRING("BLACK"), borderWidth, wxSOLID));
	dc.DrawText(WXSTRING(title), centre.x - titleSize.x / 2, y + spacing + borderWidth);
}

void MyFrame::RenderRight(wxDC& dc)
{

	wxBitmap adrixright("/opt/extras.ubuntu.com/azpazeta/media/AdrixRight.png", wxBITMAP_TYPE_PNG);
#define adrixdown adrixright
	dc.DrawText("No se ha renderizado bien",wxPoint(-1,-1));
	//Dibujar fondo
	switch(city){
	case 0:{dc.DrawBitmap(adrixdown, wxPoint(adrx,adry),true);}
	case 1:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/1x1.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 2:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/INEM.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 3:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Centro1.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 4:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Centro2.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 5:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Centro3.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 6:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Hiper.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 7:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Golf.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 8:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/1x1.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 9:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/1x1.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}

	case 10:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/1x1.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	case 11:{ wxBitmap general("/opt/extras.ubuntu.com/azpazeta/media/Gorguez.png",wxBITMAP_TYPE_PNG);
		dc.DrawBitmap(general,wxPoint(-1,-1),true); dc.DrawBitmap(adrixdown,wxPoint(adrx,adry),true); break;}
	}
	
}

/*
 * Here we do the actual rendering. I put it in a separate
 * method so that it can work no matter what type of DC
 * (e.g. wxPaintDC or wxClientDC) is used.
 */
void BasicDrawPane::Render(wxDC&  dc)
{

     int width, height;
     this->GetSize(&width, &height);

     if ( m_bgColor.IsOk() ) 
     {
	  dc.SetBrush(wxBrush(m_bgColor));
	  dc.DrawRectangle(0, 0, width, height);
     }

     if ( m_textForeGround.IsOk() )
     {
	  dc.SetTextForeground( m_textForeGround );
     }

     if ( !m_text.IsEmpty() )
     {
	  dc.SetBackgroundMode(wxTRANSPARENT);
	  dc.SetFont( m_font );

	  /*
	   * ちょうど中央表示できるよう調整
	   */
	  const int cHeight = dc.GetCharHeight();
	  const int cWidth  = dc.GetCharWidth();
	  const int textLen = m_text.Len();
	  const int textHalfSize = textLen * cWidth / 2;
	  dc.DrawText( m_text, width / 2 - textHalfSize, height / 2 - cHeight / 2 );
     }
}

void ExplainShape::OnDraw(wxDC &dc)
{
	wxBitmap &bmp = GetBitmap();
	if (!bmp.Ok())
		return;

	// We do not draw the root shape
	if (m_rootShape)
		return;

	int x, y;
	x = WXROUND(m_xpos - bmp.GetWidth() / 2.0);
	y = WXROUND(m_ypos - GetHeight() / 2.0);

	dc.DrawBitmap(bmp, x, y, true);

	int w, h;
	dc.SetFont(GetCanvas()->GetFont());
	dc.GetTextExtent(label, &w, &h);

	x = WXROUND(m_xpos - w / 2.0);
	y += bmp.GetHeight() + BMP_BORDER;

	dc.DrawText(label, x, y);
}

void wxOwnerDrawnComboBox::OnDrawItem( wxDC& dc,
                                       const wxRect& rect,
                                       int item,
                                       int flags ) const
{
    if ( flags & wxODCB_PAINTING_CONTROL )
    {
        dc.DrawText( GetValue(),
                     rect.x + GetTextIndent(),
                     (rect.height-dc.GetCharHeight())/2 + rect.y );
    }
    else
    {
        dc.DrawText( GetVListBoxComboPopup()->GetString(item), rect.x + 2, rect.y );
    }
}

// draw text centered around x (though still at y down)
void DrawCenteredText(wxDC& dc, const wxString& text, const wxPoint& pt)
{
    wxCoord w, h;
    dc.GetTextExtent(text, &w, &h);
    w = std::max(0, pt.x - w/2);
    dc.DrawText(text, w, pt.y);
}