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);
}
}
}
