void CNFORenderer::RenderBackgrounds(size_t a_rowStart, size_t a_rowEnd, double a_yBase, cairo_t* cr) const { cairo_save(cr); if(GetBackColor().A > 0) { cairo_set_source_rgba(cr, S_COLOR_T_CAIRO_A(GetBackColor())); cairo_paint(cr); } if(m_nfo->HasColorMap()) { double dbw = static_cast<double>(GetBlockWidth()); double dbh = static_cast<double>(GetBlockHeight()); uint32_t l_defaultColor = GetBackColor().AsWord(); for(size_t row = (a_rowStart == -1 ? 0 : a_rowStart); row <= a_rowEnd; row++) { std::vector<size_t> l_columns; std::vector<uint32_t> l_colors; if(!m_nfo->GetColorMap()->GetLineBackgrounds(row, l_defaultColor, m_gridData->GetCols(), l_columns, l_colors)) continue; _ASSERT(l_colors.size() == l_columns.size()); _ASSERT(l_columns.size() > 0); size_t col = 0; for(size_t section = 0; section < l_colors.size(); section++) { _ASSERT(l_columns[section] > 0); _ASSERT(l_columns[section] <= m_gridData->GetCols()); size_t col_to = col + l_columns[section]; _ASSERT(col_to > col); if(l_colors[section] != l_defaultColor) { double x_from = col * dbw, x_to = col_to * dbw; cairo_set_source_rgb(cr, S_COLOR_T_CAIRO(S_COLOR_T(l_colors[section]))); cairo_rectangle(cr, GetPadding() + x_from, a_yBase + GetPadding() + dbh * row, x_to - x_from, dbh); cairo_fill(cr); } col = col_to; } } } cairo_restore(cr); }
JXTreeListWidget::JXTreeListWidget ( JTreeList* treeList, JXScrollbarSet* scrollbarSet, JXContainer* enclosure, const HSizingOption hSizing, const VSizingOption vSizing, const JCoordinate x, const JCoordinate y, const JCoordinate w, const JCoordinate h ) : JXStyleTable(scrollbarSet, enclosure, hSizing,vSizing, x,y, w,h), itsToggleOpenColIndex(0), itsNodeColIndex(0), itsElasticColIndex(0) { itsTreeList = treeList; ListenTo(itsTreeList); itsMinColWidths = new JArray<JSize>; assert( itsMinColWidths != NULL ); itsReselectNodeList = new JPtrArray<JTreeNode>(JPtrArrayT::kForgetAll); assert( itsReselectNodeList != NULL ); ListenTo(itsTreeList->GetTree()); itsIndentWidth = kDefaultIndent; itsDrawSelectionFlag = kJTrue; itsAdjustToTreeTask = NULL; itsToggleDragIndex = 0; itsDNDTargetIndex = 0; itsMaxOpenDepth = kDefaultMaxOpenDepth; itsSavedScrollSetup = NULL; SetRowBorderInfo(0, GetBackColor()); SetColBorderInfo(0, GetBackColor()); ShouldActLike1DList(); NeedsAdjustToTree(); AppendRows(itsTreeList->GetElementCount()); AppendCols(2, kToggleColWidth); // second width adjusts automatically itsToggleOpenColIndex = 1; itsNodeColIndex = 2; itsElasticColIndex = itsNodeColIndex; ListenTo(this); }
CMLineIndexTable::CMLineIndexTable ( JOrderedSetT::CompareResult (*bpCcompareFn)(CMBreakpoint *const &, CMBreakpoint *const &), CMSourceDirector* dir, CMSourceText* text, JXScrollbarSet* scrollbarSet, JXContainer* enclosure, const HSizingOption hSizing, const VSizingOption vSizing, const JCoordinate x, const JCoordinate y, const JCoordinate w, const JCoordinate h ) : JXTable(1, 1, NULL, enclosure, hSizing, vSizing, x, y, w, h), itsDirector(dir), itsText(text), itsVScrollbar(scrollbarSet->GetVScrollbar()), itsCurrentLineIndex(0), itsLineMenu(NULL), itsDeselectTask(NULL) { itsLink = CMGetLink(); ListenTo(itsLink); itsBPList = jnew JPtrArray<CMBreakpoint>(JPtrArrayT::kForgetAll); assert(itsBPList != NULL); itsBPList->SetCompareFunction(bpCcompareFn); itsBPList->SetSortOrder(JOrderedSetT::kSortAscending); WantInput(kJFalse); SetBackColor(CMGetPrefsManager()->GetColor(CMPrefsManager::kBackColorIndex)); SetFocusColor(GetBackColor()); SetRowBorderInfo(0, GetBackColor()); SetColBorderInfo(0, GetBackColor()); SetDrawOrder(kDrawByCol); AppendCols(3); CMAdjustLineTableToTextTask* task = jnew CMAdjustLineTableToTextTask(this); assert( task != NULL ); task->Go(); ListenTo(itsText); ListenTo(itsVScrollbar); ListenTo(itsLink->GetBreakpointManager()); }
void WndProperty::on_paint(Canvas &canvas) { /* background and selector */ if (edit.has_focus()) { canvas.clear(GetBackColor().highlight()); PaintSelector(canvas, get_client_rect()); } else canvas.clear(GetBackColor()); SIZE tsize; POINT org; WindowControl::on_paint(canvas); canvas.set_text_color(GetForeColor()); canvas.background_transparent(); canvas.select(*GetFont()); tsize = canvas.text_size(mCaption); if (mCaptionWidth == 0) { org.x = mEditPos.x; org.y = mEditPos.y - tsize.cy; } else { org.x = mCaptionWidth - mBitmapSize - (tsize.cx + 1); org.y = (get_size().cy - tsize.cy) / 2; } if (org.x < 1) org.x = 1; canvas.text(org.x, org.y, mCaption); // can't but dlgComboPicker here b/c it calls paint when combopicker closes too // so it calls dlgCombopicker on the click/focus handlers for the wndproperty & label if (!mDialogStyle && edit.has_focus() && !edit.is_read_only()) { canvas.stretch(mHitRectDown.left, mHitRectDown.top, mBitmapSize, mBitmapSize, hBmpLeft32, mDownDown ? 32 : 0, 0, 32, 32); canvas.stretch(mHitRectUp.left, mHitRectUp.top, mBitmapSize, mBitmapSize, hBmpRight32, mUpDown ? 32 : 0, 0, 32, 32); } }
void ShowTxt(void) { switch (gCurrWin) { case kLicenseID: if(gControls->lw->licTxt) { RGBColor backColorOld; Rect textRect; // get back color GetBackColor(&backColorOld); // set to white BackColor(whiteColor); // erase rect and update textRect = (**(gControls->lw->licTxt)).viewRect; EraseRect(&textRect); TEUpdate(&textRect, gControls->lw->licTxt); // restore back color RGBBackColor(&backColorOld); } break; default: break; } }
void CheckBox::DrawChildren(const DrawingContext *dc, float sx, float sy) const { float bh = dc->GetFrameHeight(_boxTexture, GetFrame()); float bw = dc->GetFrameWidth(_boxTexture, GetFrame()); float th = dc->GetFrameHeight(_fontTexture, 0); FRECT box = {sx, sy + (GetHeight() - bh) / 2, sx + bw, sy + (GetHeight() - bh) / 2 + bh}; dc->DrawSprite(&box, _boxTexture, GetBackColor(), GetFrame()); // grep 'enum State' SpriteColor colors[] = { SpriteColor(0xffffffff), // Normal SpriteColor(0xffffffff), // Hottrack SpriteColor(0xffffffff), // Pushed SpriteColor(0xffffffff), // Disabled }; if( _drawShadow && stateDisabled != GetState() ) { dc->DrawBitmapText(sx + bw + 1, sy + (GetHeight() - th) / 2 + 1, _fontTexture, 0xff000000, GetText()); } dc->DrawBitmapText(sx + bw, sy + (GetHeight() - th) / 2, _fontTexture, colors[GetState()], GetText()); __super::DrawChildren(dc, sx, sy); }
void _draw_screen_shape_at_x_y( shape_descriptor shape, short x, short y) { PixMapHandle pixmap; RGBColor old_fore, old_back; Rect destination; /* Avoid unwanted coloring.. */ GetForeColor(&old_fore); GetBackColor(&old_back); RGBForeColor(&rgb_black); RGBBackColor(&rgb_white); /* Draw the panels... */ pixmap= get_shape_pixmap(shape, FALSE); /* Offset to zero base, and add in x, y */ destination= (*pixmap)->bounds; OffsetRect(&destination, x-destination.left, y-destination.top); /* Slam the puppy... */ assert(destination_graphics_port); CopyBits((BitMapPtr) *pixmap, &destination_graphics_port->portBits, //&screen_window->portBits, &(*pixmap)->bounds, &destination, srcCopy, (RgnHandle) nil); /* Restore the colors.. */ RGBForeColor(&old_fore); RGBBackColor(&old_back); }
void cPict::draw(){ RGBColor store_color; Rect rect = frame; GrafPtr cur_port; GetPort(&cur_port); SetPortWindowPort(parent->win); if(!visible){ // Erase it InsetRect(&rect, -3, -3); tileImage(rect,bg_gworld,bg[parent->bg]); return; } if(picNum < 0) { // Just fill with black GetForeColor(&store_color); ForeColor(blackColor); PaintRect(&rect); RGBForeColor(&store_color); return; } GetBackColor(&store_color); BackColor(whiteColor); drawPict()[picType](picNum,rect); if(drawFramed) drawFrame(2,0); SetPort(cur_port); }
void UIAnimation::SetActivated(bool activate) { mActivate = activate; mEnd = false; mCurTime = 0.f; mCurPos = Vec2::ZERO; auto targetUI = mTargetUI.lock(); if (targetUI) { if (!mActivate) { targetUI->ClearAnimationResult(); if (!mKeyBackColor.empty()) { auto backColor = StringMathConverter::ToString(mInitialBackColor); targetUI->SetProperty(UIProperty::BACK_COLOR, backColor.c_str()); } } else if (mActivate) { if (!mKeyScale.empty()) { mCurScale = mKeyScale.begin()->second; targetUI->SetAnimScale(mCurScale); } if (!mKeyBackColor.empty()) { mInitialBackColor = targetUI->GetBackColor(); } } } }
void PanelControl::on_paint(Canvas &canvas) { canvas.clear(GetBackColor()); ContainerControl::on_paint(canvas); }
WndForm::WndForm(SingleWindow &_main_window, const TCHAR *Caption, int X, int Y, int Width, int Height, const WindowStyle style): main_window(_main_window), mModalResult(0), mColorTitle(Color::YELLOW), mhTitleFont(&Fonts::MapBold), mOnTimerNotify(NULL), mOnKeyDownNotify(NULL) { set(main_window, X, Y, Width, Height, add_border(style)); // Create ClientWindow SetBackColor(Color(0xDA, 0xDB, 0xAB)); WindowStyle client_style; client_style.control_parent(); client_area.set(*this, mClientRect.left, mClientRect.top, mClientRect.right - mClientRect.left, mClientRect.bottom - mClientRect.top, client_style); client_area.SetBackColor(GetBackColor()); cbTimerID = set_timer(1001, 500); SetCaption(Caption); #if !defined(ENABLE_SDL) && !defined(NDEBUG) ::SetWindowText(hWnd, mCaption); #endif }
void UpdateAdditionsWin(void) { Rect r; Cell c; int i; GrafPtr oldPort; GetPort(&oldPort); SetPort(gWPtr); MoveTo( gControls->aw->compListBox.left, gControls->aw->compListBox.top - kInterWidgetPad + 1); HLock(gControls->cfg->selAddMsg); DrawString( CToPascal(*gControls->cfg->selAddMsg)); HUnlock(gControls->cfg->selAddMsg); #if 0 RGBColor backColorOld; Rect adjustedRect, *clRect = &gControls->aw->compListBox; SetRect(&adjustedRect, clRect->left, clRect->top+1, clRect->right, clRect->bottom-1); GetBackColor(&backColorOld); BackColor(whiteColor); EraseRect(&adjustedRect); RGBBackColor(&backColorOld); #endif LUpdate( (*gControls->aw->compList)->port->visRgn, gControls->aw->compList); SetRect(&r, gControls->aw->compListBox.left, gControls->aw->compListBox.top, gControls->aw->compListBox.right + 1, gControls->aw->compListBox.bottom); FrameRect(&r); SetPt(&c, 0, 0); if (LGetSelect(true, &c, gControls->aw->compList)) { HLock((Handle)gControls->aw->compDescTxt); SetRect(&r, (*gControls->aw->compDescTxt)->viewRect.left, (*gControls->aw->compDescTxt)->viewRect.top, (*gControls->aw->compDescTxt)->viewRect.right, (*gControls->aw->compDescTxt)->viewRect.bottom); HUnlock((Handle)gControls->aw->compDescTxt); TEUpdate(&r, gControls->aw->compDescTxt); } DrawDiskSpaceMsgs( gControls->opt->vRefNum ); for (i = 0; i < numRows; i++) { if (gControls->cfg->comp[rowToComp[i]].highlighted) { AddInitRowHighlight(i); break; } } SetPort(oldPort); }
void CRButtonCtrl::DoPropExchange(CPropExchange* pPX) { m_ResourceNumber&=0x00ffffff; m_ResourceNumber+=m_alignment<<24; ExchangeVersion(pPX, MAKELONG(_wVerMinor, _wVerMajor)); COleControl::DoPropExchange(pPX); PX_Bool(pPX, _T("MovesParent"), m_bMovesParent, FALSE); PX_Long(pPX, _T("FontNum"), m_FontNum, 0); PX_Bool(pPX, _T("CloseButton"), m_bCloseButton, FALSE); PX_Bool(pPX, _T("TickButton"), m_bTickButton, FALSE); PX_Bool(pPX, _T("ShowShadow"), m_bShowShadow, FALSE); PX_Color(pPX, _T("ShadowColor"), m_ShadowColor, FALSE); PX_String(pPX, _T("String"), m_string, _T("")); PX_Long(pPX, _T("ResourceNumber"), m_ResourceNumber, 0); PX_Long(pPX, _T("NormalFileNum"), m_NormalFileNum, 0); PX_Long(pPX, _T("PressedFileNum"), m_PressedFileNum, 7); PX_String(pPX, _T("NormalFileNumString"), m_NormalFileNumString, _T("")); PX_String(pPX, _T("PressedFileNumString"), m_PressedFileNumString, _T("")); if (pPX->GetVersion()&0x1) { PX_String(pPX, _T("HintString"), m_hintString, _T("")); PX_String(pPX, _T("HintStringID"), m_hintStringID, _T("")); PX_Long(pPX, _T("HintResourceNumber"), m_hintResourceNumber, 0); } else { } if (pPX->GetVersion()&0x2) { } else { } m_alignment=m_ResourceNumber>>24; //DeadCode MS 04May100 UByteP(0xB0000)[160*5]='0'+m_alignment; m_ResourceNumber&=0x00ffffff; if (pPX->IsLoading()) { if (GetBackColor()==0) SetBackColor(GetForeColor()); if (m_bCloseButton || m_bTickButton) //JIM 21/05/99 m_bHelpButton=TRUE; // remove this if it becomes a persistent property else m_bHelpButton=FALSE; } if (m_PressedFileNum==7) m_PressedFileNumString=""; }
void OnDraw(CDC* pdc, const CRect& rcBounds, const CRect& /*rcInvalid*/) { CPen pen(PS_SOLID, 0, TranslateColor(GetForeColor())); CBrush brush(TranslateColor(GetBackColor())); CPen* pPenSave = pdc->SelectObject(&pen); CBrush* pBrushSave = pdc->SelectObject(&brush); pdc->Rectangle(rcBounds); pdc->SelectObject(pPenSave); pdc->SelectObject(pBrushSave); }
void SaveQDDrawingState( QDDrawingState *ioDrawingState, const Boolean inSaveTextState ) { GWorldPtr tempWorld; GDHandle tempDevice; Assert( ioDrawingState != nil ); // Get the current GWorld, so I can access it's fields. GetGWorld( &tempWorld, &tempDevice ); // Get the background state. GetBackColor( &ioDrawingState->backColor ); /*#if !( defined( TARGET_API_MAC_CARBON ) && ( TARGET_API_MAC_CARBON == 1 ) ) if ( tempWorld->bkPixPat == nil ) ioDrawingState->backPixPatH = nil; else #endif ioDrawingState->backPixPatH = NewPixPat( ); if ( ioDrawingState->backPixPatH != nil ) GetPortBackPixPat( tempWorld, ioDrawingState->backPixPatH ); */ // Get the pen/foreground state. GetForeColor( &ioDrawingState->foreColor ); /*#if !( defined( TARGET_API_MAC_CARBON ) && ( TARGET_API_MAC_CARBON == 1 ) ) if ( tempWorld->pnPixPat == nil ) ioDrawingState->penPixPatH = nil; else #endif ioDrawingState->penPixPatH = NewPixPat( ); if ( ioDrawingState->penPixPatH != nil ) GetPortPenPixPat( tempWorld, ioDrawingState->penPixPatH ); */ GetPenState( &ioDrawingState->penState ); // Optionally save the text font, face, size and mode. ioDrawingState->haveTextState = inSaveTextState; if ( inSaveTextState ) { ioDrawingState->textStyle.tsFont = GetPortTextFont( tempWorld ); ioDrawingState->textStyle.tsFace = GetPortTextFace( tempWorld ); ioDrawingState->textStyle.tsSize = GetPortTextSize( tempWorld ); ioDrawingState->textMode = GetPortTextMode( tempWorld ); } #if ALIST_USEAPPEARANCEMGR && TARGET_RT_MAC_CFM // If we're running under CFM and have Appearance Mgr 1.1 or later, use the ThemeDrawingState routines. if ( local_AppearanceMgrVersion( ) > 0x0110 ) ioDrawingState->haveThemeState = ( GetThemeDrawingState( &ioDrawingState->themeState ) == noErr ); else { ioDrawingState->haveThemeState = false; ioDrawingState->themeState = nil; } #endif }
void CXTPSyntaxEditTipWnd::OnNcPaint() { CXTPWindowRect rc(this); rc.OffsetRect(-rc.TopLeft()); CWindowDC dc(this); dc.SetBkColor(GetBackColor()); dc.SetTextColor(GetTextColor()); dc.FillSolidRect(&rc, dc.GetBkColor()); dc.DrawFocusRect(&rc); }
static pascal void drawProc(ControlRef inControl, SInt16 inPart) { #pragma unused(inControl, inPart) int i; RGBColor saveForeColor; RGBColor saveBackColor; PenState savePenState; GetForeColor(&saveForeColor); GetBackColor(&saveBackColor); GetPenState(&savePenState); RGBForeColor(&rgbBlack); RGBBackColor(&rgbWhite); PenNormal(); for (i = 0; i < sNumMonitors; i++) { RGBForeColor(&rgbGray); PaintRect(&sMonitors[i].scaledRect); if (sMonitors[i].isMain) { Rect r = sMonitors[i].scaledRect; InsetRect(&r, 1, 1); r.bottom = r.top + 6; RGBForeColor(&rgbWhite); PaintRect(&r); RGBForeColor(&rgbBlack); PenSize(1,1); MoveTo(r.left, r.bottom); LineTo(r.right, r.bottom); } if (sMonitors[i].device == sSelectedDevice) { PenSize(3,3); RGBForeColor(&rgbBlack); FrameRect(&sMonitors[i].scaledRect); } else { PenSize(1,1); RGBForeColor(&rgbBlack); FrameRect(&sMonitors[i].scaledRect); } } // restore the original pen state and colors RGBForeColor(&saveForeColor); RGBBackColor(&saveBackColor); SetPenState(&savePenState); }
void _draw_screen_shape_centered( shape_descriptor shape, screen_rectangle *rectangle, short flags) { PixMapHandle pixmap; RGBColor old_fore, old_back; Rect destination, source; short left_offset, top_offset; return; /* Avoid unwanted coloring.. */ GetForeColor(&old_fore); GetBackColor(&old_back); RGBForeColor(&rgb_black); RGBBackColor(&rgb_white); /* Draw the panels... */ pixmap= get_shape_pixmap(shape, FALSE); /* Offset to zero base, and add in x, y */ destination= source= (*pixmap)->bounds; if(flags & _center_horizontal) { left_offset= (RECTANGLE_WIDTH(rectangle)-RECTANGLE_WIDTH(&source))/2; } else { left_offset= 0; } if(flags & _center_vertical) { top_offset= (RECTANGLE_HEIGHT(rectangle)-RECTANGLE_HEIGHT(&source))/2; } else if (flags & _bottom_justified) { top_offset= RECTANGLE_HEIGHT(rectangle)-RECTANGLE_HEIGHT(&destination); } else { top_offset= 0; } OffsetRect(&destination, rectangle->left+left_offset, rectangle->top+top_offset); /* Slam the puppy... */ assert(destination_graphics_port); CopyBits((BitMapPtr) *pixmap, &destination_graphics_port->portBits, // &screen_window->portBits, &source, &destination, srcCopy, (RgnHandle) nil); /* Restore the colors.. */ RGBForeColor(&old_fore); RGBBackColor(&old_back); }
void WndOwnerDrawFrame::on_paint(Canvas &canvas) { canvas.clear(GetBackBrush()); if (mOnPaintCallback == NULL) return; canvas.select(*GetFont()); canvas.set_text_color(GetForeColor()); canvas.set_background_color(GetBackColor()); canvas.background_transparent(); mOnPaintCallback(this, canvas); }
/* If source==NULL, source= the shapes bounding rectangle */ void _draw_screen_shape( shape_descriptor shape_id, screen_rectangle *destination, screen_rectangle *source) { PixMapHandle pixmap; RGBColor old_fore, old_back; Rect actual_source; /* Avoid unwanted coloring.. */ GetForeColor(&old_fore); GetBackColor(&old_back); RGBForeColor(&rgb_black); RGBBackColor(&rgb_white); /* Draw the panels... */ pixmap= get_shape_pixmap(shape_id, FALSE); if(!source) { actual_source= (*pixmap)->bounds; #ifdef DEBUG { short dest_width, source_width; short dest_height, source_height; dest_width= destination->right-destination->left; source_width= (*pixmap)->bounds.right-(*pixmap)->bounds.left; dest_height= destination->bottom-destination->top; source_height= (*pixmap)->bounds.bottom-(*pixmap)->bounds.top; if(source_height != dest_height || source_width != dest_width) { dprintf("Changing size of %d Original: %d %d New: %d %d", shape_id, source_width, source_height, dest_width, dest_height); } } #endif } else { actual_source= *((Rect *) source); } assert(destination_graphics_port); CopyBits((BitMapPtr) *pixmap, &destination_graphics_port->portBits, &actual_source, (Rect *) destination, srcCopy, (RgnHandle) nil); /* Restore the colors.. */ RGBForeColor(&old_fore); RGBBackColor(&old_back); }
void CTesthelpCtrl::OnDraw(CDC* pdc, const CRect& rcBounds, const CRect& /*rcInvalid*/) { // Drawing code, mostly plagiarized from the Circ MFC sample. // The only thing done here is setting the border and drawing text // specified by our name properties in the control's client area. if(!GetBorderStyle()) //Control will always have a border. SetBorderStyle(TRUE); // Set up variables to use for drawing text background. // Use our current BackColor for the background color. CBrush* pOldBrush; CBrush bkBrush(TranslateColor(GetBackColor())); CPen* pOldPen; CRect rc = rcBounds; CFont* pOldFont; // Set up background mode and text color. Use the // current ForeColor for the text color. pdc->SetTextColor(TranslateColor(GetForeColor())); pdc->SetBkMode(TRANSPARENT); // Fill our window with the current BackColor pdc->FillRect(rcBounds, &bkBrush); // Save off the existing brush and pen so they // can be restored when we're done. pOldBrush = pdc->SelectObject(&bkBrush); pOldPen = (CPen*)pdc->SelectStockObject(BLACK_PEN); // Save off the current font so we can restore it and // select our current stock font into this DC pOldFont = SelectStockFont(pdc); // Draw the text on our window pdc->ExtTextOut(rc.left+10, rc.top +2, ETO_CLIPPED, rc, m_szName1, m_szName1.GetLength(), NULL); pdc->ExtTextOut(rc.left+10, rc.top +22, ETO_CLIPPED, rc, m_szName2, m_szName2.GetLength(), NULL); pdc->ExtTextOut(rc.left+10, rc.top +42, ETO_CLIPPED, rc, m_szName3, m_szName3.GetLength(), NULL); // Restore our DC to it's original state. pdc->SelectObject(pOldFont); pdc->SelectObject(pOldPen); pdc->SelectObject(pOldBrush); }
BOOL CXTPSyntaxEditTipWnd::DrawTip(CDC* pDC, CRect rClient) { ASSERT_VALID(this); CString csItemText; m_pListBox->GetText(m_iIndex, csItemText); CXTPFontDC fontDC(pDC, m_pListBox->GetFont(), GetTextColor()); pDC->SetBkColor(GetBackColor()); pDC->FillSolidRect(rClient, pDC->GetBkColor()); pDC->SetBkMode(TRANSPARENT); pDC->DrawText(csItemText, rClient, DT_VCENTER | DT_CENTER |DT_SINGLELINE | DT_NOPREFIX | DT_EXPANDTABS); return TRUE; }
void _scroll_window( short dy, short rectangle_id, short background_color_index) { Rect *destination= _get_interface_rect(rectangle_id); RgnHandle updateRgn; RGBColor old_color, new_color; GetBackColor(&old_color); _get_interface_color(background_color_index, &new_color); RGBBackColor(&new_color); updateRgn= NewRgn(); ScrollRect(destination, 0, dy, updateRgn); DisposeRgn(updateRgn); RGBBackColor(&old_color); }
void CLesson18Ctrl::OnDraw( CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid) { if (!pdc) return; // TODO: 用您自己的绘图代码替换下面的代码。 //pdc->FillRect(rcBounds, CBrush::FromHandle((HBRUSH)GetStockObject(WHITE_BRUSH))); //pdc->Ellipse(rcBounds); CBrush brush(TranslateColor(GetBackColor())); pdc->FillRect(rcBounds,&brush); pdc->SetTextColor(TranslateColor(GetForeColor())); pdc->SetBkMode(TRANSPARENT); CTime time=CTime::GetCurrentTime(); if(0==time.GetSecond()){ NewMinute(); } CString str=time.Format(_T("%H:%M:%S")); pdc->TextOutW(0,0,str); }
static void MacErasePolygon (SHORT_POINT *points, INT n) { int i; PolyHandle myPoly; RGBColor ForeColor, BackColor; if (n<3) return; GetForeColor(&ForeColor); GetBackColor(&BackColor); myPoly = OpenPoly(); MoveTo (points[0].x, points[0].y); for (i=1; i<n; i++) LineTo (points[i].x, points[i].y); LineTo (points[0].x, points[0].y); ClosePoly(); ErasePoly(myPoly); RGBForeColor(&BackColor); FramePoly(myPoly); KillPoly(myPoly); RGBForeColor(&ForeColor); }
void CCircCtrl::OnDraw( CDC* pdc, const CRect& rcBounds, const CRect&) { CBrush* pOldBrush; CBrush bkBrush(TranslateColor(GetBackColor())); CPen* pOldPen; CRect rc = rcBounds; CFont* pOldFont; TEXTMETRIC tm; const CString& strCaption = InternalGetText(); // Set the ForeColor property color and transparent background mode into the device context pdc->SetTextColor(TranslateColor(GetForeColor())); pdc->SetBkMode(TRANSPARENT); // Paint the background using the BackColor property pdc->FillRect(rcBounds, &bkBrush); // Draw the ellipse using the BackColor property and a black pen GetDrawRect(&rc); pOldBrush = pdc->SelectObject(&bkBrush); pOldPen = (CPen*)pdc->SelectStockObject(BLACK_PEN); pdc->Ellipse(rc); // Draw the caption and note using the stock Font and ForeColor properties pOldFont = SelectStockFont(pdc); GetStockTextMetrics(&tm); pdc->SetTextAlign(TA_CENTER | TA_TOP); pdc->ExtTextOut((rc.left + rc.right) / 2, (rc.top + rc.bottom - tm.tmHeight) / 2, ETO_CLIPPED, rc, strCaption, strCaption.GetLength(), NULL); pdc->SetTextAlign(TA_LEFT | TA_TOP); pdc->ExtTextOut(rcBounds.left, rcBounds.top, ETO_CLIPPED, rcBounds, m_note, m_note.GetLength(), NULL); pdc->SelectObject(pOldFont); pdc->SelectObject(pOldPen); pdc->SelectObject(pOldBrush); }
void AxImage::OnDraw( CDC* pdc, const CRect& rcBounds, const CRect& rcInvalid) { // Paint the background using the BackColor property CBrush bkBrush(TranslateColor(GetBackColor())); pdc->FillRect(rcBounds, &bkBrush); if (image && image->IsValid()){ if (m_stretch){ image->Draw(pdc->GetSafeHdc(),0,0,rcBounds.Width(),rcBounds.Height()); } else { image->Draw(pdc->GetSafeHdc()); } } if (m_border){ RECT r={rcBounds.left,rcBounds.top,rcBounds.right,rcBounds.bottom}; pdc->DrawEdge(&r,EDGE_SUNKEN,BF_RECT); } // DoSuperclassPaint(pdc, rcBounds); }
/**************************************************************** PopInvert() inverts the given popup. ****************************************************************/ void PopInvert(DialogPtr theDialog, short itemNum) { GrafPtr savePort; short itemType; Handle itemHandle; Rect itemBox; //SysEnvRec theWorld; RGBColor SaveBack, DefaultBack, DefaultFore, saveHilite; GetPortGrafPtr(&savePort); SetPortDialogPort(theDialog); GetDialogItem(theDialog, itemNum, &itemType, &itemHandle, &itemBox); // SysEnvirons(curSysEnvVers,&theWorld); //if (!theWorld.hasColorQD) { if (ColorQDAvailable()) { InvertRect( &itemBox ); return; } GetBackColor(&SaveBack); LMGetHiliteRGB(&saveHilite); DefaultMenuColors(&DefaultFore, &DefaultBack); RGBBackColor(&DefaultBack); HiliteColor(&DefaultFore); LMSetHiliteMode(LMGetHiliteMode() & 0x7F); // clear 0th bit = pHiliteBit InvertRect( &itemBox ); HiliteColor(&saveHilite); RGBBackColor(&SaveBack); SetPortGrafPort(savePort); }
void XCopyArea( Display* display, /* Display. */ Drawable src, /* Source drawable. */ Drawable dest, /* Destination drawable. */ GC gc, /* GC to use. */ int src_x, /* X & Y, width & height */ int src_y, /* define the source rectangle */ unsigned int width, /* the will be copied. */ unsigned int height, int dest_x, /* Dest X & Y on dest rect. */ int dest_y) { Rect srcRect, destRect; BitMapPtr srcBit, destBit; MacDrawable *srcDraw = (MacDrawable *) src; MacDrawable *destDraw = (MacDrawable *) dest; GWorldPtr srcPort, destPort; CGrafPtr saveWorld; GDHandle saveDevice; short tmode; RGBColor origForeColor, origBackColor, whiteColor, blackColor; destPort = TkMacGetDrawablePort(dest); srcPort = TkMacGetDrawablePort(src); display->request++; GetGWorld(&saveWorld, &saveDevice); SetGWorld(destPort, NULL); GetForeColor(&origForeColor); GetBackColor(&origBackColor); whiteColor.red = 0; whiteColor.blue = 0; whiteColor.green = 0; RGBForeColor(&whiteColor); blackColor.red = 0xFFFF; blackColor.blue = 0xFFFF; blackColor.green = 0xFFFF; RGBBackColor(&blackColor); TkMacSetUpClippingRgn(dest); /* * We will change the clip rgn in this routine, so we need to * be able to restore it when we exit. */ if (tmpRgn2 == NULL) { tmpRgn2 = NewRgn(); } GetClip(tmpRgn2); if (((TkpClipMask*)gc->clip_mask)->type == TKP_CLIP_REGION) { RgnHandle clipRgn = (RgnHandle) ((TkpClipMask*)gc->clip_mask)->value.region; int xOffset, yOffset; if (tmpRgn == NULL) { tmpRgn = NewRgn(); } xOffset = destDraw->xOff + gc->clip_x_origin; yOffset = destDraw->yOff + gc->clip_y_origin; OffsetRgn(clipRgn, xOffset, yOffset); GetClip(tmpRgn); SectRgn(tmpRgn, clipRgn, tmpRgn); SetClip(tmpRgn); OffsetRgn(clipRgn, -xOffset, -yOffset); } srcBit = &((GrafPtr) srcPort)->portBits; destBit = &((GrafPtr) destPort)->portBits; SetRect(&srcRect, (short) (srcDraw->xOff + src_x), (short) (srcDraw->yOff + src_y), (short) (srcDraw->xOff + src_x + width), (short) (srcDraw->yOff + src_y + height)); SetRect(&destRect, (short) (destDraw->xOff + dest_x), (short) (destDraw->yOff + dest_y), (short) (destDraw->xOff + dest_x + width), (short) (destDraw->yOff + dest_y + height)); tmode = srcCopy; CopyBits(srcBit, destBit, &srcRect, &destRect, tmode, NULL); RGBForeColor(&origForeColor); RGBBackColor(&origBackColor); SetClip(tmpRgn2); SetGWorld(saveWorld, saveDevice); }
void CNFORenderer::RenderStripe(size_t a_stripe) const { cairo_surface_t * const l_surface = GetStripeSurface(a_stripe); _ASSERT(l_surface != NULL); if((!m_hasBlocks || m_classic) && GetBackColor().A > 0) { cairo_t* cr = cairo_create(l_surface); cairo_set_source_rgba(cr, S_COLOR_T_CAIRO_A(GetBackColor())); cairo_paint(cr); cairo_destroy(cr); } // hacke-di-hack (RenderClassic is adding GetPadding() for historical reasons, so we have to subtract it beforehand. // it's also operating on the full NFO image's coordinates, so we have to subtract those too): double l_baseY = (a_stripe == 0 ? 0 : -GetPadding() - (double)a_stripe * m_stripeHeight) + GetStripeHeightExtraTop(a_stripe); size_t l_rowStart = (m_numStripes > 1 ? a_stripe * m_linesPerStripe - GetStripeExtraLinesTop(a_stripe) : (size_t)-1), l_rowEnd = a_stripe * m_linesPerStripe + m_linesPerStripe + GetStripeExtraLinesBottom(a_stripe); if(m_classic) { RenderClassic(GetTextColor(), NULL, GetHyperLinkColor(), false, l_rowStart, 0, l_rowEnd, m_nfo->GetGridWidth() - 1, l_surface, 0, l_baseY); } else { if(m_hasBlocks && GetEnableGaussShadow() && ((m_partial & NRP_RENDER_BLOCKS) != 0 || (m_partial & NRP_RENDER_GAUSS_BLOCKS) != 0)) { if((m_partial & NRP_RENDER_GAUSS_SHADOW) != 0) { shared_ptr<CCairoBoxBlur> p_blur(new CCairoBoxBlur( (int)GetWidth(), GetStripeHeightPhysical(a_stripe), (int)GetGaussBlurRadius(), ms_useGPU && !m_forceGPUOff)); p_blur->SetAllowFallback(m_allowCPUFallback); cairo_t* cr = cairo_create(l_surface); RenderBackgrounds(l_rowStart, l_rowEnd, l_baseY, cr); // shadow effect: if(!m_cancelRenderingImmediately) { RenderStripeBlocks(a_stripe, false, true, p_blur->GetContext()); // important when running in CPU fallback mode only: cairo_set_source_rgba(cr, S_COLOR_T_CAIRO_A(GetGaussColor())); if(!p_blur->Paint(cr) && p_blur->IsFallbackAllowed()) { // retry once. RenderStripeBlocks(a_stripe, false, true, p_blur->GetContext()); // important when running in CPU fallback mode only: cairo_set_source_rgba(cr, S_COLOR_T_CAIRO_A(GetGaussColor())); p_blur->Paint(cr); } } cairo_destroy(cr); } if((m_partial & NRP_RENDER_GAUSS_BLOCKS) != 0 && (m_partial & NRP_RENDER_GAUSS_SHADOW) == 0 && !m_cancelRenderingImmediately) { // render blocks in gaussian color RenderStripeBlocks(a_stripe, false, true); } else if((m_partial & NRP_RENDER_BLOCKS) != 0 && !m_cancelRenderingImmediately) { // normal mode RenderStripeBlocks(a_stripe, false, false); } } else if(m_hasBlocks && (m_partial & NRP_RENDER_BLOCKS) != 0 && !m_cancelRenderingImmediately) { RenderStripeBlocks(a_stripe, true, false); } if((m_partial & NRP_RENDER_TEXT) != 0 && !m_cancelRenderingImmediately) { RenderText(GetTextColor(), NULL, GetHyperLinkColor(), l_rowStart, 0, l_rowEnd, m_nfo->GetGridWidth() - 1, l_surface, 0, l_baseY); } } }