void Account::EditProfile() { clrscr(); DrawBorder(25,8,59,16,0); gotoxy(24,11); cout<<"Please enter your first name : "; cin>>FName; cin.ignore(); gotoxy(24,12); cout<<"Please enter your last name : "; cin>>LName; cin.ignore(); clrscr(); DrawBorder(25,8,59,16,0); gotoxy(24,11); cout<<"ID : "; cin>>ID; gotoxy(24,12); cout<<"Username : "******"Enter new Password : "; cin>>Password; cin.ignore(); }
//-----------Splash screens------------// void SplashScreen (int ScreenType, char *FName) { switch (ScreenType) { case 1 : clrscr(); DrawBorder(26,3,53,7,1); gotoxy(31,5); textcolor(12); cprintf("Welcome "); textcolor(7); cout<<FName; break; case 2 : clrscr(); DrawBorder(16,7,63,16,1); gotoxy(19,10); textcolor(12); cprintf("Thank you for using Intellisoft Job Portal"); gotoxy(24,12); textcolor(7); cprintf("Developed by Aniruddha Mysore"); gotoxy(26,13); cprintf("Class 12-B | Roll No. 23"); getch(); exit(0); } }
/* * DrawGridBorder: Draw the border around the current room area. */ void DrawGridBorder(void) { if (state == STATE_GAME && (GameGetState() == GAME_PLAY || GameGetState() == GAME_SELECT)) if (GetFocus() == hMain) DrawBorder(&view, HIGHLIGHT_INDEX, &drawborderexcludeView); else //DrawBorder(view, border_index, &drawborderexcludeView); DrawBorder(&view, BORDER_INDEX, &drawborderexcludeView); }
void MinerGob::Draw(DibBitmap *pbm, int xViewOrigin, int yViewOrigin, int nLayer) { #ifdef DRAW_OCCUPIED_TILE_INDICATOR { WRect wrcT; GetTilePaddedWRect(&wrcT); Rect rcT; rcT.FromWorldRect(&wrcT); rcT.Offset(-xViewOrigin, -yViewOrigin); DrawBorder(pbm, &rcT, 1, GetColor(kiclrWhite)); } #endif if (m_fHidden) return; MobileUnitGob::Draw(pbm, xViewOrigin, yViewOrigin, nLayer); if (m_st == kstMinerSuck && nLayer == knLayerDepthSorted) { SetAnimationStrip(&m_aniVacuum, m_ani.GetStrip()); m_aniVacuum.Draw(pbm, PcFromUwc(m_wx) - xViewOrigin, PcFromUwc(m_wy) - yViewOrigin); } else if (nLayer == knLayerSelection && (m_ff & kfGobSelected)) { Rect rcT; rcT.FromWorldRect(&m_pmuntc->wrcUIBounds); rcT.Offset(PcFromUwc(m_wx) - xViewOrigin, PcFromUwc(m_wy) - yViewOrigin); DrawFullnessIndicator(pbm, &rcT, m_nGalaxiteAmount / knGalaxiteValue / 2, knMinerGalaxiteMax / knGalaxiteValue / 2); } }
/* * InventoryBoxResize: Resize the inventory box when the main window is resized * to (xsize, ysize). view is the current grid area view. */ void InventoryBoxResize(int xsize, int ysize, AREA *view) { int old_cols = cols; int old_rows = rows; int yMiniMap, iHeightAvailableForMapAndStats, iHeightMiniMap; /* Turn off highlight */ DrawBorder(&inventory_area, inventory_bg_index, NULL); inventory_area.x = view->x + view->cx + LEFT_BORDER + 3 * HIGHLIGHT_THICKNESS; inventory_area.cx = min(xsize - inventory_area.x - 3 * HIGHLIGHT_THICKNESS - EDGETREAT_WIDTH, INVENTORY_MAX_WIDTH); // inventory_area.y = 2 * TOP_BORDER + USERAREA_HEIGHT + GROUPBUTTONS_HEIGHT + EDGETREAT_HEIGHT; // inventory_area.cy = view->y + view->cy - inventory_area.y; yMiniMap = 2 * TOP_BORDER + USERAREA_HEIGHT + EDGETREAT_HEIGHT + MAPTREAT_HEIGHT; iHeightAvailableForMapAndStats = ysize - yMiniMap - 2 * HIGHLIGHT_THICKNESS - EDGETREAT_HEIGHT; iHeightMiniMap = (int)( iHeightAvailableForMapAndStats * PROPORTION_MINIMAP ) - HIGHLIGHT_THICKNESS - MAPTREAT_HEIGHT; iHeightMiniMap = min( iHeightMiniMap, MINIMAP_MAX_HEIGHT ); inventory_area.y = yMiniMap + iHeightMiniMap + 3 * HIGHLIGHT_THICKNESS + MAPTREAT_HEIGHT + GROUPBUTTONS_HEIGHT + MAP_STATS_GAP_HEIGHT + 1; inventory_area.cy = ysize - EDGETREAT_HEIGHT - HIGHLIGHT_THICKNESS - inventory_area.y - STATS_BOTTOM_GAP_HEIGHT; InventoryComputeRowsCols(); // If inventory gets bigger, go back to top if (cols > old_cols || rows > old_rows) { top_row = 0; SetScrollPos(hwndInvScroll, SB_CTL, 0, TRUE); } InventoryDisplayScrollbar(); }
/** Handle an expose event. */ char HandleExpose(const XExposeEvent *event) { ClientNode *np; np = FindClientByParent(event->window); if(np) { if(event->count == 0) { DrawBorder(np); } return 1; } else { np = FindClientByWindow(event->window); if(np) { if(np->state.status & STAT_WMDIALOG) { /* Dialog expose events are handled elsewhere. */ return 0; } else { /* Ignore other expose events for client windows. */ return 1; } } return event->count ? 1 : 0; } }
void CSMFGroundDrawer::Draw(const DrawPass::e& drawPass) { // must be here because water renderers also call us if (!globalRendering->drawGround) return; // if entire map is under voidwater, no need to draw *ground* if (readMap->HasOnlyVoidWater()) return; glDisable(GL_BLEND); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); if (drawDeferred) { // do the deferred pass first, will allow us to re-use // its output at some future point and eventually draw // the entire map deferred DrawDeferredPass(drawPass, mapRendering->voidGround || (mapRendering->voidWater && drawPass != DrawPass::WaterReflection)); } if (drawForward) { DrawForwardPass(drawPass, mapRendering->voidGround || (mapRendering->voidWater && drawPass != DrawPass::WaterReflection)); } glDisable(GL_CULL_FACE); if (drawPass != DrawPass::Normal) return; if (drawWaterPlane) DrawWaterPlane(false); if (drawMapEdges) DrawBorder(drawPass); }
static void _XmFastExpose(Widget widg) { register int i; register Widget child; XmGrabShellWidget gs = (XmGrabShellWidget)widg; _XmProcessLock(); (*(XtClass(widg)->core_class.expose)) (widg, NULL, NULL); _XmProcessUnlock(); /* Process each windowed child */ for (i = 0; i < gs->composite.num_children; i++) { child = gs->composite.children[i]; if (XtIsWidget(child) && XtIsManaged(child)) { _XmProcessLock(); (*(XtClass(child)->core_class.expose)) (child, NULL, NULL); _XmProcessUnlock(); } } XFlush(XtDisplay(widg)); DrawBorder(widg); }
static void BorderElementDraw( void *clientData, void *elementRecord, Tk_Window tkwin, Drawable d, Ttk_Box b, unsigned int state) { BorderElement *bd = elementRecord; Tk_3DBorder border = Tk_Get3DBorderFromObj(tkwin, bd->borderObj); XColor *borderColor = Tk_GetColorFromObj(tkwin, bd->borderColorObj); int borderWidth = 2; int relief = TK_RELIEF_FLAT; int defaultState = TTK_BUTTON_DEFAULT_DISABLED; /* * Get option values. */ Tcl_GetIntFromObj(NULL, bd->borderWidthObj, &borderWidth); Tk_GetReliefFromObj(NULL, bd->reliefObj, &relief); Ttk_GetButtonDefaultStateFromObj(NULL, bd->defaultStateObj, &defaultState); if (defaultState == TTK_BUTTON_DEFAULT_ACTIVE) { GC gc = Tk_GCForColor(borderColor, d); XDrawRectangle(Tk_Display(tkwin), d, gc, b.x, b.y, b.width-1, b.height-1); } if (defaultState != TTK_BUTTON_DEFAULT_DISABLED) { /* Space for default ring: */ b = Ttk_PadBox(b, Ttk_UniformPadding(1)); } DrawBorder(tkwin, d, border, borderColor, b, borderWidth, relief); }
void CXFA_FFCheckButton::RenderWidget(CFX_Graphics* pGS, CFX_Matrix* pMatrix, uint32_t dwStatus) { if (!IsMatchVisibleStatus(dwStatus)) { return; } CFX_Matrix mtRotate; GetRotateMatrix(mtRotate); if (pMatrix) { mtRotate.Concat(*pMatrix); } CXFA_FFWidget::RenderWidget(pGS, &mtRotate, dwStatus); CXFA_Border borderUI = m_pDataAcc->GetUIBorder(); DrawBorder(pGS, borderUI, m_rtUI, &mtRotate, m_pDataAcc->GetCheckButtonShape() == XFA_ATTRIBUTEENUM_Round ? XFA_DRAWBOX_ForceRound : 0); RenderCaption(pGS, &mtRotate); DrawHighlight(pGS, &mtRotate, dwStatus, m_pDataAcc->GetCheckButtonShape() == XFA_ATTRIBUTEENUM_Round); CFX_Matrix mt; mt.Set(1, 0, 0, 1, m_rtCheckBox.left, m_rtCheckBox.top); mt.Concat(mtRotate); GetApp()->GetWidgetMgrDelegate()->OnDrawWidget(m_pNormalWidget->GetWidget(), pGS, &mt); }
void TankGob::Draw(DibBitmap *pbm, int xViewOrigin, int yViewOrigin, int nLayer) { if (nLayer == knLayerDepthSorted) { #ifdef DRAW_OCCUPIED_TILE_INDICATOR { WRect wrcT; GetTilePaddedWRect(&wrcT); Rect rcT; rcT.FromWorldRect(&wrcT); rcT.Offset(-xViewOrigin, -yViewOrigin); DrawBorder(pbm, &rcT, 1, GetColor(kiclrWhite)); } #endif Side side = m_pplr->GetSide(); if (m_ff & kfGobDrawFlashed) side = (Side)-1; // Draw base int x = PcFromUwc(m_wx) - xViewOrigin; int y = PcFromUwc(m_wy) - yViewOrigin; m_ani.Draw(pbm, x, y, side); // Draw turret // The turret is aligned with the base's special point Point ptBaseSpecial; m_ani.GetSpecialPoint(&ptBaseSpecial); m_aniTurret.Draw(pbm, x + ptBaseSpecial.x, y + ptBaseSpecial.y, side); } else { MobileUnitGob::Draw(pbm, xViewOrigin, yViewOrigin, nLayer); } }
void CChart::PrintChart(CDC *pDC,int x , int y) { int xPixel ; int yPixel ; int oldmapmode ; CDC *dc = GetDC(); xPixel = pDC->GetDeviceCaps(LOGPIXELSX); yPixel = pDC->GetDeviceCaps(LOGPIXELSY); //Calculate ratio to be zoomed. xPixel = xPixel /dc->GetDeviceCaps(LOGPIXELSX); yPixel = yPixel /dc->GetDeviceCaps(LOGPIXELSY); ReleaseDC(dc); oldmapmode = pDC->SetMapMode(MM_ANISOTROPIC); pDC->SetViewportExt(xPixel,yPixel); pDC->SetViewportOrg(x,y); DrawBorder(pDC); pDC->DrawEdge(m_ctlRect,BDR_SUNKENINNER|BDR_SUNKENOUTER, BF_RECT); DrawChartTitle(pDC); if ( bLogScale ) DrawLogGrid(pDC); DrawGrid(pDC); DrawAxis(pDC) ; DrawGridLabel(pDC); Plot(pDC) ; pDC->SetMapMode(oldmapmode); }
void InputConfigDialog::UpdateBitmaps(wxTimerEvent& WXUNUSED(event)) { wxFont small_font(6, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD); const wxColour font_color{0xB8B8B8}; g_controller_interface.UpdateInput(); GamepadPage* const current_page = static_cast<GamepadPage*>(m_pad_notebook->GetPage(m_pad_notebook->GetSelection())); wxMemoryDC dc; auto lock = ControllerEmu::GetStateLock(); for (ControlGroupBox* g : current_page->control_groups) { // Only if this control group has a bitmap if (!g->static_bitmap) continue; wxBitmap bitmap(g->static_bitmap->GetBitmap()); // NOTE: Selecting the bitmap inherits the bitmap's ScaleFactor onto the DC as well. dc.SelectObjectAsSource(bitmap); dc.SetBackground(*wxWHITE_BRUSH); dc.Clear(); #ifdef __WXGTK20__ int dc_height = 0; dc.SetFont(small_font); dc.GetTextExtent(g->control_group->name, nullptr, &dc_height); #endif std::unique_ptr<wxGraphicsContext> gc{wxGraphicsContext::Create(dc)}; gc->DisableOffset(); gc->SetFont(small_font, font_color); #ifdef __WXGTK20__ double gc_height = 0; gc->GetTextExtent(g->control_group->name, nullptr, &gc_height); // On GTK2, wx creates a new empty Cairo/Pango context for the graphics context instead // of reusing the wxMemoryDC one, this causes it to forget the screen DPI so fonts stop // scaling, we need to scale it manually instead. if (std::ceil(gc_height) < dc_height) { wxFont fixed_font(small_font); fixed_font.SetPointSize(static_cast<int>(fixed_font.GetPointSize() * g->m_scale)); gc->SetFont(fixed_font, font_color); } #endif DrawControlGroupBox(gc.get(), g); DrawBorder(gc.get(), g->m_scale); // label for sticks and stuff if (g->HasBitmapHeading()) gc->DrawText(StrToWxStr(g->control_group->name).Upper(), 4 * g->m_scale, 2 * g->m_scale); gc.reset(); dc.SelectObject(wxNullBitmap); g->static_bitmap->SetBitmap(bitmap); } }
/** Handle an expose event. */ int HandleExpose(const XExposeEvent *event) { ClientNode *np; np = FindClientByWindow(event->window); if(np) { if(event->window == np->parent) { DrawBorder(np, event); return 1; } else if(event->window == np->window && np->state.status & STAT_WMDIALOG) { /* Dialog expose events are handled elsewhere. */ return 0; } else { /* Ignore other expose events. */ return 1; } } else { return event->count ? 1 : 0; } }
void MenuBar::DrawItem(GC &gc, int n) { if (n<0 || n>=list.count()) return; UiCondList ucl; if (n == select && InFocus()) ucl.Set(uiCurrentItem, true); int color_text = UiGetColor(uiColor, uiItem, &ucl, 0x0); int color_bg = UiGetColor(uiBackground, uiItem, &ucl, 0xFFFFFF); gc.Set(GetFont()); crect itemRect = ItemRect(n); gc.SetFillColor(color_bg); if (n == select && InFocus()) gc.FillRect(itemRect); if (n == select) { DrawBorder(gc, itemRect, UiGetColor(uiCurrentItemFrame, uiItem, &ucl, 0xFFFFFF)); } gc.SetTextColor( color_text ); const unicode_t *text = list[n].text.ptr(); cpoint tsize = gc.GetTextExtents(text); int x = itemRect.left + (itemRect.Width()-tsize.x)/2; int y = itemRect.top + (itemRect.Height()-tsize.y)/2; #ifdef _WIN32 gc.TextOut(x,y,text); #else gc.TextOutF(x,y,text); #endif }
/* * InactiveWindow - display a window as inactive */ void InactiveWindow( window_id wn ) { wind *w; vi_color c; if( wn == NO_WINDOW ) { return; } w = Windows[wn]; if( w == NULL ) { return; } if( !w->has_border ) { return; } /* * change the border color */ c = w->border_color1; w->border_color1 = EditVars.InactiveWindowColor; DrawBorder( wn ); w->border_color1 = c; } /* InactiveWindow */
void BorderFrame::FramePaint(Draw& draw, const Rect& r) { Size sz = r.GetSize(); int n = (int)(intptr_t)*border; if(sz.cx >= 2 * n && sz.cy >= 2 * n) DrawBorder(draw, r.left, r.top, r.Width(), r.Height(), border); }
/*************************************************** OnDraw - overloaded CUGCellType::OnDraw Draws the push button in its current state, pressed or unpressed. The drawing of text is performed using the CUGCellType's DrawText function, therefore it has all of the same text capabilities as the default celltype. **See CUGCellType::OnDraw for more details about this function Params dc - device context to draw the cell with rect - rectangle to draw the cell in col - column that is being drawn row - row that is being drawn cell - cell that is being drawn selected- TRUE if the cell is selected, otherwise FALSE current - TRUE if the cell is the current cell, otherwise FALSE Return none ****************************************************/ void CUGButtonType::OnDraw(CDC *dc,RECT *rect,int col,long row, CUGCell *cell,int selected,int current) { if (!m_drawThemesSet) m_useThemes = cell->UseThemes(); UGXPThemeState state = UGXPThemes::GetState(selected>0, current>0); if (m_btnDown && current) { state = ThemeStatePressed; } RECT rectout; if (m_useThemes && UGXPThemes::DrawBackground(NULL, *dc, XPCellTypeButton, state, rect, NULL)) { UGXPThemes::DrawEdge(NULL, *dc, XPCellTypeButton, state, rect, 0, 0, &rectout); cell->SetXPStyle(XPCellTypeButton); DrawText(dc,rect,rect->right - rectout.right ,col,row,cell,selected,current); } else { //draw the button if(m_btnDown && current) { cell->SetBorder(UG_BDR_RECESSED); DrawBorder(dc,rect,&rectout,cell); } else { cell->SetBorder(UG_BDR_RAISED); DrawBorder(dc,rect,&rectout,cell); } //draw the text in using the default drawing routine DrawText(dc,&rectout,0,col,row,cell,selected,current); } if(cell->IsPropertySet(UGCELL_CELLTYPEEX_SET) && current) { if(cell->GetCellTypeEx()&UGCT_BUTTONNOFOCUS) { m_ctrl->TempDisableFocusRect(); } } }
void Graphics::Draw(Automaton &a) { glPushMatrix(); glTranslatef(dx,dy,0.0); DrawWithMap(a); DrawBorder(); glPopMatrix(); }
void Graphics::Draw() { glPushMatrix(); glTranslatef(dx,dy,0.0); DrawGrid(); DrawBorder(); glPopMatrix(); }
void wxStdRenderer::DrawTextBorder(wxDC& dc, wxBorder border, const wxRect& rect, int flags, wxRect *rectIn) { DrawBorder(dc, border, rect, flags, rectIn); }
void CMeasuredGrid::Draw(Display::IDisplayPtr pDisplay) { IMapGrid::Draw(pDisplay); DrawBorder(pDisplay); DrawGrid(pDisplay); DrawTick(pDisplay); DrawLabel(pDisplay); }
FWL_ERR CFWL_CheckBoxImp::DrawWidget(CFX_Graphics* pGraphics, const CFX_Matrix* pMatrix) { if (!pGraphics) return FWL_ERR_Indefinite; if (!m_pProperties->m_pThemeProvider) return FWL_ERR_Indefinite; IFWL_ThemeProvider* pTheme = m_pProperties->m_pThemeProvider; if (HasBorder()) { DrawBorder(pGraphics, FWL_PART_CKB_Border, m_pProperties->m_pThemeProvider, pMatrix); } if (HasEdge()) { DrawEdge(pGraphics, FWL_PART_CKB_Edge, pTheme, pMatrix); } int32_t dwStates = GetPartStates(); { CFWL_ThemeBackground param; param.m_pWidget = m_pInterface; param.m_iPart = FWL_PART_CKB_Background; param.m_dwStates = dwStates; param.m_pGraphics = pGraphics; if (pMatrix) { param.m_matrix.Concat(*pMatrix); } param.m_rtPart = m_rtClient; if (m_pProperties->m_dwStates & FWL_WGTSTATE_Focused) { param.m_pData = &m_rtFocus; } pTheme->DrawBackground(¶m); param.m_iPart = FWL_PART_CKB_CheckBox; param.m_rtPart = m_rtBox; pTheme->DrawBackground(¶m); } if (!m_pProperties->m_pDataProvider) return FWL_ERR_Indefinite; { CFX_WideString wsCaption; m_pProperties->m_pDataProvider->GetCaption(m_pInterface, wsCaption); int32_t iLen = wsCaption.GetLength(); if (iLen <= 0) return FWL_ERR_Indefinite; CFWL_ThemeText textParam; textParam.m_pWidget = m_pInterface; textParam.m_iPart = FWL_PART_CKB_Caption; textParam.m_dwStates = dwStates; textParam.m_pGraphics = pGraphics; if (pMatrix) { textParam.m_matrix.Concat(*pMatrix); } textParam.m_rtPart = m_rtCaption; textParam.m_wsText = wsCaption; textParam.m_dwTTOStyles = m_dwTTOStyles; textParam.m_iTTOAlign = m_iTTOAlign; pTheme->DrawText(&textParam); } return FWL_ERR_Succeeded; }
void wxStdRenderer::DrawStatusField(wxDC& dc, const wxRect& rect, const wxString& label, int flags, int style) { wxRect rectIn; if ( style == wxSB_RAISED ) DrawBorder(dc, wxBORDER_RAISED, rect, flags, &rectIn); else if ( style != wxSB_FLAT ) DrawBorder(dc, wxBORDER_STATIC, rect, flags, &rectIn); rectIn.Deflate(GetStatusBarFieldMargins()); wxDCClipper clipper(dc, rectIn); DrawLabel(dc, label, rectIn, flags, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL); }
/*! Comment : //******************************************************************/ void CCSTMCombo::OnPaint() { CPaintDC dc(this); // device context for painting DefWindowProc( WM_PAINT, (WPARAM)dc.GetSafeHdc(), (LPARAM)0 ); DrawBorder(&dc); }
static VOID DrawProgressBar( IN PPROGRESSBAR Bar) { COORD coPos; DWORD Written; PROGRESSBAR BarBorder = *Bar; CHAR TextBuffer[256]; /* Draw the progress bar "border" border */ if (Bar->DoubleEdge) { BarBorder.Top -= 5; BarBorder.Bottom += 2; BarBorder.Right += 5; BarBorder.Left -= 5; DrawThickBorder(&BarBorder); } /* Draw the progress bar border */ DrawBorder(Bar); /* Display the description text */ if (Bar->DescriptionText) CONSOLE_SetTextXY(Bar->TextTop, Bar->TextRight, Bar->DescriptionText); /* Always update and display the progress */ if (Bar->UpdateProgressProc && Bar->UpdateProgressProc(Bar, TRUE, TextBuffer, ARRAYSIZE(TextBuffer))) { coPos.X = Bar->Left + (Bar->Width - strlen(TextBuffer) + 1) / 2; coPos.Y = Bar->Top; WriteConsoleOutputCharacterA(StdOutput, TextBuffer, strlen(TextBuffer), coPos, &Written); } /* Draw the empty bar */ coPos.X = Bar->Left + 1; for (coPos.Y = Bar->Top + 2; coPos.Y <= Bar->Bottom - 1; coPos.Y++) { FillConsoleOutputAttribute(StdOutput, Bar->ProgressColour, Bar->Width - 2, coPos, &Written); FillConsoleOutputCharacterA(StdOutput, ' ', Bar->Width - 2, coPos, &Written); } }
/** draws high score */ void APlatformerHUD::DrawHighscore() { const FText Highscore = LOCTEXT("Highscore", "High score"); const float SizeX = Canvas->ClipX * 0.4f; const float SizeY = 1000 * UIScale; const float DrawX = (Canvas->ClipX - SizeX) / 2.0f; const float DrawY = (Canvas->ClipY - SizeY) / 2.0f; DrawBorder(DrawX, DrawY, SizeX, SizeY, 1.0f, BlueBorder); const float TextScale = 1.4f; const float TextMargin = 0.03f; float StrSizeX, StrSizeY; Canvas->StrLen(HUDFont, Highscore.ToString(), StrSizeX, StrSizeY); StrSizeX = StrSizeX * TextScale * UIScale; StrSizeY = StrSizeY * TextScale * UIScale; FCanvasTextItem TextItem( FVector2D( (Canvas->ClipX - StrSizeX) / 2.0f, DrawY + SizeY * TextMargin ), Highscore, HUDFont, FLinearColor::White ); TextItem.Scale = FVector2D( TextScale * UIScale, TextScale * UIScale ); TextItem.EnableShadow( FLinearColor::Transparent ); Canvas->DrawItem( TextItem ); const float BorderSize = BlueBorder.LeftBorder->Resource->GetSizeX() * UIScale; FCanvasTileItem TileItem(FVector2D( DrawX + BorderSize, DrawY + SizeY * TextMargin + StrSizeY ), BlueBorder.TopBorder->Resource, FVector2D( SizeX - 2* BorderSize, BlueBorder.TopBorder->Resource->GetSizeY() * UIScale ), FVector2D(0,0),FVector2D((SizeX - 2* BorderSize) / BlueBorder.TopBorder->Resource->GetSizeX() * UIScale,1), FLinearColor::White); TileItem.BlendMode = SE_BLEND_Translucent; Canvas->DrawItem(TileItem); const float StartY = DrawY + SizeY * TextMargin*3 + StrSizeY * TextScale * UIScale; const float ColWidths[] = {70*UIScale, 340*UIScale, 200*UIScale}; const float TotalWidth = ColWidths[0]+ColWidths[1]+ColWidths[2]; for (int32 i=0; i < 10; i++ ) { FText Texts[] = { FText::Format(FText::FromString("{0}."), FText::AsNumber(i+1)), FText::FromString(UPlatformerBlueprintLibrary::DescribeTime(HighscoreTimes[i], false)), FText::FromString(HighscoreNames[i]) }; float Offset = 0; for (uint8 column=0; column < 3; column++) { TextItem.Text = Texts[column]; Canvas->StrLen(HUDFont, TextItem.Text.ToString(), StrSizeX, StrSizeY); StrSizeX = StrSizeX * TextScale * UIScale; StrSizeY = StrSizeY * TextScale * UIScale; TextItem.Position = FVector2D((Canvas->ClipX - TotalWidth) / 2.0f + Offset + ColWidths[column] - StrSizeX, StartY + i * StrSizeY); Canvas->DrawItem( TextItem ); Offset += ColWidths[column]; } } }
/** Set the active client. */ void FocusClient(ClientNode *np) { if(np->state.status & STAT_HIDDEN) { return; } if(!(np->state.status & (STAT_CANFOCUS | STAT_TAKEFOCUS))) { return; } if(activeClient != np || !(np->state.status & STAT_ACTIVE)) { if(activeClient) { activeClient->state.status &= ~STAT_ACTIVE; if(!(activeClient->state.status & STAT_OPACITY)) { SetOpacity(activeClient, settings.inactiveClientOpacity, 0); } DrawBorder(activeClient); } np->state.status |= STAT_ACTIVE; activeClient = np; if(!(np->state.status & STAT_OPACITY)) { SetOpacity(np, settings.activeClientOpacity, 0); } DrawBorder(np); RequirePagerUpdate(); RequireTaskUpdate(); } if(np->state.status & STAT_MAPPED) { UpdateClientColormap(np); SetWindowAtom(rootWindow, ATOM_NET_ACTIVE_WINDOW, np->window); if(np->state.status & STAT_CANFOCUS) { JXSetInputFocus(display, np->window, RevertToParent, eventTime); } if(np->state.status & STAT_TAKEFOCUS) { SendClientMessage(np->window, ATOM_WM_PROTOCOLS, ATOM_WM_TAKE_FOCUS); } } else { JXSetInputFocus(display, rootWindow, RevertToParent, eventTime); } }
void CDreamSkinWindow::DrawItem(HDC hDC, SKINITEM *pItem, RECT rcItem, WCHAR *wstrTitle) { RECT rcClient = GetItemRectClient(pItem, rcItem); DrawBackground(hDC, rcItem, &pItem->skinBk); DrawBorder(hDC, &pItem->skinLBorder, &pItem->skinRBorder, &pItem->skinTBorder, &pItem->skinBBorder, rcItem); if (wstrTitle) DrawTitle(hDC, &pItem->skinTxt, rcClient, wstrTitle); }
void byoSnake::OnPaint(wxPaintEvent& event) { wxSize size = GetClientSize(); wxBitmap buffer(wxImage(size.GetWidth(),size.GetHeight())); wxBufferedPaintDC DC(this,buffer); DrawBorder(&DC); DrawSnake(&DC); DrawApple(&DC); DrawStats(&DC); }