void COptionTreeColorPopUp::OnPaint() { // Declare variables CPaintDC dc(this); CRect rcClient; // Get client rect GetClientRect(rcClient); // Draw the Default Area text if (m_strDefaultText.GetLength()) { DrawCell(&dc, OT_COLOR_DEFAULTBOXVALUE); } // Draw color cells for (int i = 0; i < m_nNumColors; i++) { DrawCell(&dc, i); } // Draw custom text if (m_strCustomText.GetLength()) { DrawCell(&dc, OT_COLOR_CUSTOMBOXVALUE); } // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is sposed to do this, but for some reason isn't dc.DrawEdge(rcClient, EDGE_RAISED, BF_RECT); }
/******************************************************************************* Function Name : OnPaint Input(s) : - Output : - Functionality : Draws the color pallete, selection and user text. Member of : CColourPopup Author(s) : Raja N Date Created : 09/12/2004 Modifications : *******************************************************************************/ void CColourPopup::OnPaint() { CPaintDC dc(this); // device context for painting // Draw the Default Area text if (m_strDefaultText.GetLength() > 0) { DrawCell(&dc, DEFAULT_BOX_VALUE); } // Draw colour cells for (int i = 0; i < m_nNumColours; i++) { DrawCell(&dc, i); } // Draw custom text if (m_strCustomText.GetLength() > 0) { DrawCell(&dc, CUSTOM_BOX_VALUE); } // Draw raised window edge CRect rect; GetClientRect(rect); dc.DrawEdge(rect, EDGE_RAISED, BF_RECT); }
void CColourPopup::ChangeSelection(int nIndex) { CClientDC dc(this); // device context for drawing if (nIndex > m_nNumColours) nIndex = CUSTOM_BOX_VALUE; if ((m_nCurrentSel >= 0 && m_nCurrentSel < m_nNumColours) || m_nCurrentSel == CUSTOM_BOX_VALUE || m_nCurrentSel == DEFAULT_BOX_VALUE) { // Set Current selection as invalid and redraw old selection (this way // the old selection will be drawn unselected) int OldSel = m_nCurrentSel; m_nCurrentSel = INVALID_COLOUR; DrawCell(&dc, OldSel); } // Set the current selection as row/col and draw (it will be drawn selected) m_nCurrentSel = nIndex; DrawCell(&dc, m_nCurrentSel); // Store the current colour if (m_nCurrentSel == CUSTOM_BOX_VALUE) m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crInitialColour, 0); else if (m_nCurrentSel == DEFAULT_BOX_VALUE) { m_crColour = CLR_DEFAULT; m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) CLR_DEFAULT, 0); } else { m_crColour = GetColour(m_nCurrentSel); m_pParent->SendMessage(CPN_SELCHANGE, (WPARAM) m_crColour, 0); } }
void DrawCell( TMVA::PDEFoamCell *cell, TMVA::PDEFoam *foam, Double_t x, Double_t y, Double_t xscale, Double_t yscale ) { // recursively draw cell and it's daughters Float_t xsize = xscale*1.5; Float_t ysize = yscale/3; if (xsize > 0.15) xsize=0.1; //xscale/2; if (cell->GetDau0() != NULL) { TLine *a1 = new TLine(x-xscale/4, y-ysize, x-xscale, y-ysize*2); a1->SetLineWidth(2); a1->Draw(); DrawCell(cell->GetDau0(), foam, x-xscale, y-yscale, xscale/2, yscale); } if (cell->GetDau1() != NULL){ TLine *a1 = new TLine(x+xscale/4, y-ysize, x+xscale, y-ysize*2); a1->SetLineWidth(2); a1->Draw(); DrawCell(cell->GetDau1(), foam, x+xscale, y-yscale, xscale/2, yscale); } TPaveText *t = new TPaveText(x-xsize, y-ysize, x+xsize, y+ysize, "NDC"); t->SetBorderSize(1); t->SetFillStyle(1); // draw all cell elements t->AddText( Form("Intg=%.5f", cell->GetIntg()) ); t->AddText( Form("Var=%.5f", cell->GetDriv()) ); TVectorD *vec = (TVectorD*) cell->GetElement(); if (vec != NULL){ for (Int_t i = 0; i < vec->GetNrows(); ++i) { t->AddText( Form("E[%i]=%.5f", i, vec(i)) ); } } if (cell->GetStat() != 1) { // cell is inactive --> draw split point t->SetFillColor( TColor::GetColor("#BBBBBB") ); t->SetTextColor( TColor::GetColor("#000000") ); // cell position and size TMVA::PDEFoamVect cellPosi(foam->GetTotDim()), cellSize(foam->GetTotDim()); cell->GetHcub(cellPosi, cellSize); Int_t kBest = cell->GetBest(); // best division variable Double_t xBest = cell->GetXdiv(); // best division point t->AddText( Form("dim=%i", kBest) ); t->AddText( Form("cut=%.5g", foam->VarTransformInvers(kBest,cellPosi[kBest] + xBest*cellSize[kBest])) ); } else { t->SetFillColor( TColor::GetColor("#DD0033") ); t->SetTextColor( TColor::GetColor("#FFFFFF") ); } t->Draw(); return; }
short UpdateNewMove(void) { short from, dest, p; from = newmove.from; dest = newmove.dest; p = piece[dest]; piece[dest] = piece[from]; piece[from] = EMPTY; color[dest] = color[from]; color[from] = EMPTY; DrawCell(from, NORMAL); DrawCell(dest, NORMAL); return p == KING; }
short GetHumanMove(void) { static short x = 4, y = 5; short ch, from, t, i, selecting = 0; Gen(); /* for check legal move only */ while (1) { MoveTo (x, y); ch = (short)getch(); switch (ch) { case 13: case 32: /* Enter or Spacebar */ t = x + y*SIZE_X; if (!selecting) { if (color[t]==side) { selecting = 1; from = t; DrawCell(t, SELECT); } } else { if (t != from) DrawCell(from, NORMAL); if (color[t]==side) { from = t; DrawCell(t, SELECT); } else { newmove.from = from; newmove.dest = t; for (i=gen_begin[ply]; i<gen_end[ply]; i++) if (gen_dat[i].m.from==newmove.from && gen_dat[i].m.dest==newmove.dest) return 0; DrawCell(from, SELECT); } } break; case 27: return 1; /* ESC */ case 0xE0: ch = (short)getch(); switch (ch) { case 75: if (x) x--; else x = SIZE_X-1; break; /* LEFT */ case 77: if (x<SIZE_X-1) x++; else x = 0; break; /* RIGHT */ case 72: if (y) y--; else y = SIZE_Y-1; break; /* UP */ case 80: if (y<SIZE_Y-1) y++; else y = 0; break; /* DOWN */ } break; } /* switch */ } /* while */ }
void ProcessEvent(PSEvent* event) { switch(event->type) { /* If the view updates, build a new Graphics 2D Context */ case PSE_INSTANCE_DIDCHANGEVIEW: { struct PP_Rect rect; g_pView->GetRect(event->as_resource, &rect); UpdateContext(rect.size.width, rect.size.height); break; } case PSE_INSTANCE_HANDLEINPUT: { PP_InputEvent_Type type = g_pInputEvent->GetType(event->as_resource); PP_InputEvent_Modifier modifiers = g_pInputEvent->GetModifiers(event->as_resource); switch(type) { case PP_INPUTEVENT_TYPE_MOUSEDOWN: { struct PP_Point location = g_pMouseInput->GetPosition(event->as_resource); DrawCell(location.x, location.y); break; } case PP_INPUTEVENT_TYPE_MOUSEMOVE: { struct PP_Point location = g_pMouseInput->GetPosition(event->as_resource); /* If the button is down, draw */ if (modifiers & PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN) { DrawCell(location.x, location.y); } break; } case PP_INPUTEVENT_TYPE_KEYDOWN: { PP_Bool fullscreen = g_pFullscreen->IsFullscreen(PSGetInstanceId()); g_pFullscreen->SetFullscreen(PSGetInstanceId(), fullscreen ? PP_FALSE : PP_TRUE); break; } default: break; } /* case PSE_INSTANCE_HANDLEINPUT */ break; } default: break; } }
void CMainFrame::Die () { int r,c; CPoint* pCell; CPtrList* pTempList=new CPtrList; TransferList(&pTempList,&m_pDie); while(!pTempList->IsEmpty ()) { pCell=(CPoint*)pTempList->RemoveHead (); c=pCell->x; r=pCell->y; delete pCell; if ((m_world[r][c]==ALIVE)&&(m_nbrs[r][c]!=2)&&(m_nbrs[r][c]!=3)) { m_world[r][c]=DEAD; DrawCell(c,r,FALSE); CPoint* pCell=new CPoint(c,r); m_pDie->AddTail (pCell); } } delete pTempList; }
// draw all changed cells void LifeCanvas::DrawChanged() { wxClientDC dc(this); size_t ncells; LifeCell *cells; bool done = false; m_life->BeginFind(m_viewportX, m_viewportY, m_viewportX + m_viewportW, m_viewportY + m_viewportH, true); if (m_cellsize == 1) { dc.SetPen(*wxBLACK_PEN); } else { dc.SetPen(*wxTRANSPARENT_PEN); dc.SetBrush(*wxBLACK_BRUSH); } dc.SetLogicalFunction(wxINVERT); while (!done) { done = m_life->FindMore(&cells, &ncells); for (size_t m = 0; m < ncells; m++) DrawCell(cells[m].i, cells[m].j, dc); } }
void PlotCellTree( TString fin = "weights/TMVAClassification_PDEFoam.weights_foams.root", TString cv_long, bool useTMVAStyle=kTRUE ) { // Draw the PDEFoam cell tree cout << "read file: " << fin << endl; TFile *file = TFile::Open(fin); if (useTMVAStyle) TMVAGlob::SetTMVAStyle(); // find foams TListIter foamIter(gDirectory->GetListOfKeys()); TKey *foam_key = NULL; // the foam key TCanvas *canv = NULL; // the canvas while (foam_key = (TKey*) foamIter()) { TString name(foam_key->GetName()); TString class_name(foam_key->GetClassName()); if (!class_name.Contains("PDEFoam")) continue; cout << "PDEFoam found: " << class_name << " " << name << endl; // read the foam TMVA::PDEFoam *foam = (TMVA::PDEFoam*) foam_key->ReadObj(); canv = new TCanvas(Form("canvas_%s",name.Data()), Form("%s of %s",cv_long.Data(),name.Data()), 640, 480); // get cell tree depth const UInt_t depth = foam->GetRootCell()->GetTreeDepth(); const Double_t ystep = 1.0 / depth; DrawCell(foam->GetRootCell(), foam, 0.5, 1.-0.5*ystep, 0.25, ystep); } file->Close(); }
void DrawBoard(void) { int i; textcolor(7); textbackground(0); clrscr(); gotoxy(1,1); printf("\n"); printf(" +----+----+----+----+----+----+----+----+ 9\n"); printf(" | | | | \\ | / | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 8\n"); printf(" | | | | / | \\ | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 7\n"); printf(" | | | | | | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 6\n"); printf(" | | | | | | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 5\n"); printf(" | |\n"); printf(" +----+----+----+----+----+----+----+----+ 4\n"); printf(" | | | | | | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 3\n"); printf(" | | | | | | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 2\n"); printf(" | | | | \\ | / | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 1\n"); printf(" | | | | / | \\ | | | |\n"); printf(" +----+----+----+----+----+----+----+----+ 0\n"); printf(" A B C D E F G H I\n"); gotoxy(1,25); printf("Up, Down, Right, Left: cursor move Enter or Space: select ESC: escape"); gotoxy(48,1); printf("VERY SIMPLE CHINESE CHESS PROGRAM"); gotoxy(50,2); printf("(C) Pham Hong Nguyen. Ver %s", VERSION); for (i=0; i<BOARD_SIZE; i++) DrawCell(i, NORMAL); }
void SimpleList::OnPaint() { m_v_scroll_bar.Invalidate(FALSE); CPaintDC pdc(this); CDC* dc = (m_mem_dc_available)?(&m_mem_dc):(&pdc); int i; DWORD data; list<DWORD>::iterator c = m_data.begin(); for (i = 0; i < m_v_scroll_bar.GetFirstVisibleElement(); i++) if (c != m_data.end()) c ++; for (i = 0; i < m_num_visible_cells; i++) { if (c == m_data.end()) data = 0xFFFFFFFF; else { data = *c; c++; } DrawCell(dc, i, i + m_v_scroll_bar.GetFirstVisibleElement(), data, 0, i*m_cell_h); } if (m_mem_dc_available) pdc.BitBlt(0, 0, m_cell_w, m_total_h, &m_mem_dc, 0, 0, SRCCOPY); }
// draw a cell void LifeCanvas::DrawCell(wxInt32 i, wxInt32 j, bool alive) { wxClientDC dc(this); dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN); dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH); DrawCell(i, j, dc); }
void DrawSquare(HDC hdc, RECT rcClient, int ** field_array) { for (int i = 0; i < Rows; i++) { for (int j = 0; j < Columns; j++) { DrawCell(hdc, field_array[i][j], rcClient.top + i * 25, rcClient.left + j * 25); } } return; }
void CMainFrame::OnRandomCells () { srand ((unsigned)time(NULL)); for (UINT cell=0;cell<1000;++cell) { UINT col=rand() % NUMBEROFCOLS; UINT row=rand() % NUMBEROFROWS; m_world[row][col]=ALIVE; DrawCell(col,row,TRUE); } }
void __fastcall TIntMinerField::CustomDrawCellHandler(Cxgridcustomtableview::TcxCustomGridTableView* Sender, Cxgraphics::TcxCanvas* ACanvas, Cxgridcustomtableview::TcxGridTableDataCellViewInfo* AViewInfo, bool &ADone) { TCellStateRec CellRec; int ACol = AViewInfo->Item->Index; int ARow = AViewInfo->RecordViewInfo->Index; TRect DrawRect = AViewInfo->Bounds; int vType = VarType(AViewInfo->Value); if((vType == varEmpty) || (vType == varNull)) return; CellRec = *(PCellStateRec)(int)AViewInfo->Value; DrawCell(CellRec, ACol, ARow, DrawRect, ACanvas->Canvas); ADone = true; }
void CColourPopup::OnPaint() { CPaintDC dc(this); // device context for painting // Draw the Default Area text if (m_strDefaultText.GetLength()) DrawCell(&dc, DEFAULT_BOX_VALUE); // Draw colour cells for (int i = 0; i < m_nNumColours; i++) DrawCell(&dc, i); // Draw custom text if (m_strCustomText.GetLength()) DrawCell(&dc, CUSTOM_BOX_VALUE); // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is sposed to do this, // but for some reason isn't CRect rect; GetClientRect(rect); dc.DrawEdge(rect, EDGE_RAISED, BF_RECT); }
void COptionTreeColorPopUp::ChangeSelection(int nIndex) { CClientDC dc(this); if (nIndex > m_nNumColors) { nIndex = OT_COLOR_CUSTOMBOXVALUE; } if ((m_nCurrentSel >= 0 && m_nCurrentSel < m_nNumColors) || m_nCurrentSel == OT_COLOR_CUSTOMBOXVALUE || m_nCurrentSel == OT_COLOR_DEFAULTBOXVALUE) { // -- Set Current selection as invalid and redraw old selection (this way // the old selection will be drawn unselected) int OldSel = m_nCurrentSel; m_nCurrentSel = OT_COLOR_INVALIDCOLOR; DrawCell(&dc, OldSel); } // Set the current selection as row/col and draw (it will be drawn selected) m_nCurrentSel = nIndex; DrawCell(&dc, m_nCurrentSel); // Store the current color if (m_nCurrentSel == OT_COLOR_CUSTOMBOXVALUE) { m_wndParent->SendMessage(OT_COLOR_SELCHANGE, (WPARAM) m_crInitialColor, 0); } else if (m_nCurrentSel == OT_COLOR_DEFAULTBOXVALUE) { m_crColor = m_crDefault; m_wndParent->SendMessage(OT_COLOR_SELCHANGE, (WPARAM) m_crDefault, 0); } else { m_crColor = GetColor(m_nCurrentSel); m_wndParent->SendMessage(OT_COLOR_SELCHANGE, (WPARAM) m_crColor, 0); } }
/*---------------------------------------------------------------------------------------------- Change to a new cell, redrawing both old and new to indicate the change. ----------------------------------------------------------------------------------------------*/ void IconComboPopup::ChangeSelection(int ival) { Assert(0 <= ival && ival < m_cvals); if (ival == m_ivalHot) return; HDC hdc = ::GetDC(m_hwnd); // Draw the old selection (that we're about to change). if (m_ivalHot >= 0) DrawCell(hdc, m_ivalHot, false, m_prgfPressed[m_ivalHot]); // Set the current selection as row/col and draw as selected. m_ivalHot = ival; DrawCell(hdc, m_ivalHot, true, m_prgfPressed[m_ivalHot]); // Store the current Color *m_pival = m_ivalHot; ::SendMessage(m_hwndParent, WM_COMMAND, MAKEWPARAM(m_wid, CBN_SELCHANGE), (LPARAM)m_hwnd); int iSuccess; iSuccess = ::ReleaseDC(m_hwnd, hdc); Assert(iSuccess); }
/*---------------------------------------------------------------------------------------------- Draw the popup table ----------------------------------------------------------------------------------------------*/ void IconComboPopup::OnPaint() { PAINTSTRUCT ps; HDC hdc = ::BeginPaint(m_hwnd, &ps); // Get device context for painting. // Draw Color cells. for (int ival = 0; ival < m_cvals; ival++) DrawCell(hdc, ival, ival == m_ivalHot, m_prgfPressed[ival]); // Draw raised window edge (ex-window style WS_EX_WINDOWEDGE is supposed to do this, // but for some reason it doesn't. Rect rc; GetClientRect(rc); ::DrawEdge(hdc, &rc, EDGE_RAISED, BF_RECT); ::EndPaint(m_hwnd, &ps); }
void CMainFrame::OnLButtonDown(UINT nFlags, CPoint point) { if (m_curGeneration!=0) return; if(ClickInsideGrid(point)) { UINT gridCol=(point.x - HOROFFSET)/SQUARESIZE; UINT gridRow=(point.y - VEROFFSET)/SQUARESIZE; if(m_world[gridRow][gridCol]==DEAD) { m_world[gridRow][gridCol]=ALIVE; DrawCell(gridCol,gridRow,TRUE); } } }
void CIconSelector::OnPaint() { CPaintDC dc(this); // device context for painting CMemDC memDC(&dc); CRect rc, rcClip; int i, j; GetClientRect(rc); memDC.FillSolidRect(rc, ICONSEL_COLOR_BACK); for(i = 0; i < (int)m_nRowCount; i++) { for(j = 0; j < (int)m_nColCount; j++) { GetCellRect(i, j, rcClip); DrawCell((CDC *)&memDC, i, j, rcClip); } } DrawCellLine((CDC *)&memDC); }
void ProcessTouchEvent(PSEvent* event) { uint32_t count = g_pTouchInput->GetTouchCount(event->as_resource, PP_TOUCHLIST_TYPE_TOUCHES); uint32_t i, j; for (i = 0; i < count; i++) { struct PP_TouchPoint touch = g_pTouchInput->GetTouchByIndex( event->as_resource, PP_TOUCHLIST_TYPE_TOUCHES, i); int radius = (int)touch.radius.x; int x = (int)touch.position.x; int y = (int)touch.position.y; /* num = 1/100th the area of touch point */ int num = (int)(M_PI * radius * radius / 100.0f); for (j = 0; j < num; j++) { int dx = rand() % (radius * 2) - radius; int dy = rand() % (radius * 2) - radius; /* only plot random cells within the touch area */ if (dx * dx + dy * dy <= radius * radius) DrawCell(x + dx, y + dy); } } }
void BitmapExportPaletteControl::RenderPalette(DocRect *pPaletteSize, RenderRegion *pRender, INT32 controlHeight, DocRect* pClipRect) { INT32 nColours = m_Palette.GetNumberOfColours(); // See if the background needs rendering if (nColours < m_NumberOfColoursAtLastRedraw) RenderGrey(pPaletteSize, pRender); m_NumberOfColoursAtLastRedraw = nColours; pRender->SetLineColour(COLOUR_BLACK); DocRect cell; // Draw each cell in turn for (INT32 i = 0; i < nColours; ++i) { GetRectForCell(i, &cell, controlHeight); if (cell.IsIntersectedWith(*pClipRect)) { BYTE r, g, b; r = m_Palette.GetRed(i); g = m_Palette.GetGreen(i); b = m_Palette.GetBlue(i); DrawCell(&cell, DocColour(r, g, b), m_Palette.GetFlags(i), pRender, IsColourWebSafe(r, g, b), i == m_SelectedCell); } } // Draw the mouse over high light if (m_MouseOverCell != INVALID_COLOUR_VALUE) { GetRectForCell(m_MouseOverCell, &cell, controlHeight); pRender->SetFillColour(COLOUR_TRANS); pRender->SetLineColour(COLOUR_WHITE); pRender->DrawRect(&cell); } }
void GameDrawer::Draw() { boxRGBA(m_pSurface, m_pBoardMetrics->GetBoardLeft(), m_pBoardMetrics->GetBoardTop(), m_pBoardMetrics->GetBoardRight(), m_pBoardMetrics->GetBoardBottom(), GAME_BACKGROUND_R, GAME_BACKGROUND_G, GAME_BACKGROUND_B, 230); for(int nX=0; nX<=m_pBoardMetrics->GetWidth(); nX++) { vlineRGBA(m_pSurface, m_pBoardMetrics->GetLeftSpots() + nX*m_pBoardMetrics->GetPieceSize(), m_pBoardMetrics->GetTopSpots(), m_pBoardMetrics->GetBottomSpots(), 0, 0, 0, 255); } for(int nY=0; nY<=m_pBoardMetrics->GetHeight(); nY++) { hlineRGBA(m_pSurface, m_pBoardMetrics->GetLeftSpots(), m_pBoardMetrics->GetRightSpots(), m_pBoardMetrics->GetTopSpots() + nY*m_pBoardMetrics->GetPieceSize(), 0, 0, 0, 255); } for(int nX=0; nX<m_pBoardMetrics->GetWidth(); nX++) if( IsBinaryColDuplicate(m_Binary, nX) != BINARYLIB_ROW_UNIQUE ) { SDL_Rect rect; rect.w = m_pBoardMetrics->GetPieceSize(); rect.h = m_pBoardMetrics->GetBottomSpots() - m_pBoardMetrics->GetTopSpots(); rect.x = m_pBoardMetrics->GetXPos(nX); rect.y = m_pBoardMetrics->GetTopSpots(); SDL_FillRect(m_pSurface, &rect, SDL_MapRGB(m_pSurface->format, 255, 255, 0)); } for(int nY=0; nY<m_pBoardMetrics->GetHeight(); nY++) if( IsBinaryRowDuplicate(m_Binary, nY) != BINARYLIB_ROW_UNIQUE ) { SDL_Rect rect; rect.w = m_pBoardMetrics->GetRightSpots() - m_pBoardMetrics->GetLeftSpots(); rect.h = m_pBoardMetrics->GetPieceSize(); rect.x = m_pBoardMetrics->GetLeftSpots(); rect.y = m_pBoardMetrics->GetYPos(nY); SDL_FillRect(m_pSurface, &rect, SDL_MapRGB(m_pSurface->format, 255, 255, 0)); } for(int nX=0; nX<m_pBoardMetrics->GetWidth(); nX++) { for(int nY=0; nY<m_pBoardMetrics->GetHeight(); nY++) { DrawCell(nX, nY); } } }
void CCellView::ResizeCol(BPoint where, int colNr) { float x, minX, maxRow; BPoint newP, lastP; BRect bounds(Bounds()), r, b; ulong buttons, cnt; bool multi; int mCol = colNr; CRunArray backup(fCellWidths); StPenState save(this); ClearAnts(); cnt = fSelection.right - fSelection.left + 1; while (fCellWidths[colNr + 1] == fCellWidths[colNr]) colNr++; multi = fSelection.left != fSelection.right && colNr >= fSelection.left && colNr <= fSelection.right; if (colNr <= fFrozen.h) { x = fBorderWidth + fCellWidths[colNr]; minX = fBorderWidth + fCellWidths[multi?fSelection.left - 1 : colNr - 1]; } else { x = fBorderWidth + fCellWidths[colNr] + fCellWidths[fFrozen.h] - fCellWidths[fPosition.h - 1]; minX = fBorderWidth + fCellWidths[fFrozen.h] - fCellWidths[fPosition.h - 1] + fCellWidths[multi?fSelection.left - 1 : colNr - 1]; } r.top = 1; r.bottom = fBorderHeight - 1; r.left = minX + 1; if (multi) r.right = minX + fCellWidths[fSelection.right] - fCellWidths[fSelection.left - 1] - 1; else r.right = minX + fCellWidths[colNr] - fCellWidths[colNr - 1] - 1; b = bounds; b.left = r.right; maxRow = fPosition.v; while (fCellHeights[++maxRow] - fCellHeights[fPosition.v] < bounds.bottom - fBorderHeight) ; lastP = where; newP = where; do { if (newP.x != lastP.x) { float dx; int k = colNr; dx = newP.x - lastP.x; if (lastP.x + dx < bounds.left + fBorderWidth) dx = std::min(lastP.x - bounds.left - fBorderWidth, (float)0); if (lastP.x + dx > bounds.right) dx = std::max(bounds.right - lastP.x, (float)0); if (multi && x + dx < minX) dx = minX - x; if (multi) { float w, t; w = x + dx - minX; if (w > 0) w = Round(w / (colNr - fSelection.left + 1)); t = fCellWidths[fSelection.right]; fCellWidths.SetValue(fSelection.left, fSelection.right, w); dx = fCellWidths[fSelection.right] - t; } else if (x + dx < minX) { int t = k; fCellWidths.SetValue(colNr, 0); while (k > 1 && backup[k - 1] + fBorderWidth >= x + dx) k--; ASSERT(k<colNr); if (k <= mCol) while (mCol > k) fCellWidths.SetValue(mCol--, 0); else { t = mCol; for (;mCol<k;mCol++) fCellWidths.SetValue(mCol, backup[mCol] - backup[mCol - 1]); } float kw = x + dx - fBorderWidth; kw -= backup[k - 1]; fCellWidths.SetValue(k, std::max(kw, (float)0)); mCol = k; k = t; } else { k = mCol; for (; mCol < colNr; mCol++) fCellWidths.SetValue(mCol, backup[mCol] - backup[mCol - 1]); fCellWidths.SetValue(colNr, x + dx - minX); } if (dx != 0) { x += dx; lastP.x += dx; if (dx < 0) b.left += dx; StPenState save(this); StClipCells clip(this); ScrollRect(b, dx, 0); Window()->UpdateIfNeeded(); if (dx > 0) b.left += dx; if (multi) { int h = fSelection.left, v; do { for (v = 1; v < fFrozen.v; v++) DrawCell(cell(h, v)); for (v = fPosition.v; v < maxRow; v++) DrawCell(cell(h, v)); DrawBorderCell(h++, true); } while (h <= fSelection.right && bounds.left + fCellWidths[h] + fBorderWidth < bounds.right); } else { int v; for (v = 1; v < fFrozen.v; v++) DrawCell(cell(mCol, v)); for (v = fPosition.v; v < maxRow; v++) DrawCell(cell(mCol, v)); DrawBorderCell(mCol, true); } for (; k < colNr; k++) { int v; for (v = 1; v < fFrozen.v; v++) DrawCell(cell(k, v)); for (v = fPosition.v; v < maxRow; v++) DrawCell(cell(k, v)); DrawBorderCell(k, true); } } if (dx < 0) { float X; int h; X = bounds.right + dx - fBorderWidth; h = fSelection.right; do h++; while (fCellWidths[h] < X); while (h <= kColCount && bounds.left + fCellWidths[h] + fBorderWidth < bounds.right) { int v; for (v = 1; v < fFrozen.v; v++) DrawCell(cell(h, v)); for (v = fPosition.v; v < maxRow; v++) DrawCell(cell(h, v)); DrawBorderCell(h++, true); } } if (dx && fFirstGraphic) fFirstGraphic->HandleUpdate(bounds); } GetMouse(&newP, &buttons); } while (buttons); if (!(backup == fCellWidths)) { CRunArray temp(fCellWidths); fCellWidths = backup; ((CCellWindow*)Window())->RegisterCommand(new CResizeCommand(this, temp, false)); ((CCellWindow*)Window())->SetDirty(true); } } /* ResizeCol */
void LifeCanvas::OnMouse(wxMouseEvent& event) { if (!m_interactive) return; // which cell are we pointing at? wxInt32 i = XToCell( event.GetX() ); wxInt32 j = YToCell( event.GetY() ); #if wxUSE_STATUSBAR // set statusbar text wxString msg; msg.Printf(_("Cell: (%d, %d)"), i, j); ((LifeFrame *) wxGetApp().GetTopWindow())->SetStatusText(msg, 1); #endif // wxUSE_STATUSBAR // NOTE that wxMouseEvent::LeftDown() and wxMouseEvent::LeftIsDown() // have different semantics. The first one is used to signal that the // button was just pressed (i.e., in "button down" events); the second // one just describes the current status of the button, independently // of the mouse event type. LeftIsDown is typically used in "mouse // move" events, to test if the button is _still_ pressed. // is the button down? if (!event.LeftIsDown()) { m_status = MOUSE_NOACTION; return; } // was it pressed just now? if (event.LeftDown()) { // yes: start a new action and toggle this cell m_status = (m_life->IsAlive(i, j)? MOUSE_ERASING : MOUSE_DRAWING); m_mi = i; m_mj = j; m_life->SetCell(i, j, m_status == MOUSE_DRAWING); DrawCell(i, j, m_status == MOUSE_DRAWING); } else if ((m_mi != i) || (m_mj != j)) { // no: continue ongoing action bool alive = (m_status == MOUSE_DRAWING); // prepare DC and pen + brush to optimize drawing wxClientDC dc(this); dc.SetPen(alive? *wxBLACK_PEN : *wxWHITE_PEN); dc.SetBrush(alive? *wxBLACK_BRUSH : *wxWHITE_BRUSH); // draw a line of cells using Bresenham's algorithm wxInt32 d, ii, jj, di, ai, si, dj, aj, sj; di = i - m_mi; ai = abs(di) << 1; si = (di < 0)? -1 : 1; dj = j - m_mj; aj = abs(dj) << 1; sj = (dj < 0)? -1 : 1; ii = m_mi; jj = m_mj; if (ai > aj) { // iterate over i d = aj - (ai >> 1); while (ii != i) { m_life->SetCell(ii, jj, alive); DrawCell(ii, jj, dc); if (d >= 0) { jj += sj; d -= ai; } ii += si; d += aj; } }
// event handlers void LifeCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) { wxPaintDC dc(this); wxRect rect = GetUpdateRegion().GetBox(); wxCoord x, y, w, h; wxInt32 i0, j0, i1, j1; // find damaged area x = rect.GetX(); y = rect.GetY(); w = rect.GetWidth(); h = rect.GetHeight(); i0 = XToCell(x); j0 = YToCell(y); i1 = XToCell(x + w - 1); j1 = YToCell(y + h - 1); size_t ncells; LifeCell *cells; m_life->BeginFind(i0, j0, i1, j1, false); bool done = m_life->FindMore(&cells, &ncells); // erase all damaged cells and draw the grid dc.SetBrush(*wxWHITE_BRUSH); if (m_cellsize <= 2) { // no grid dc.SetPen(*wxWHITE_PEN); dc.DrawRectangle(x, y, w, h); } else { x = CellToX(i0); y = CellToY(j0); w = CellToX(i1 + 1) - x + 1; h = CellToY(j1 + 1) - y + 1; dc.SetPen(*wxLIGHT_GREY_PEN); for (wxInt32 yy = y; yy <= (y + h - m_cellsize); yy += m_cellsize) dc.DrawRectangle(x, yy, w, m_cellsize + 1); for (wxInt32 xx = x; xx <= (x + w - m_cellsize); xx += m_cellsize) dc.DrawLine(xx, y, xx, y + h); } // draw all alive cells dc.SetPen(*wxBLACK_PEN); dc.SetBrush(*wxBLACK_BRUSH); while (!done) { for (size_t m = 0; m < ncells; m++) DrawCell(cells[m].i, cells[m].j, dc); done = m_life->FindMore(&cells, &ncells); } // last set for (size_t m = 0; m < ncells; m++) DrawCell(cells[m].i, cells[m].j, dc); }
cad_picture *RenderMap(cad_render_module *self, cad_route_map * map, bool forceDrawLayer, uint32_t forceDrawLayerNunber) { if (map == NULL) { return draw_Nothing( self ); } int w = map->width; int h = map->height; int width, height; uint32_t value; int addw, addh; int cell_size; int image_width, image_height; cell_size = (int) max( ceil((double) WANT_WIDTH / w), ceil((double) WANT_HEIGHT / h) ); if (cell_size % 2 == 0) cell_size += 1; if (cell_size < MIN_CELL_SIZE) cell_size = MIN_CELL_SIZE; image_width = w * cell_size + w - 1; image_height = h * cell_size + h - 1; SetPitcureSize( self, image_width, image_height ); auto picture = allocate_picture( self ); memset( picture->data, 220, image_width * image_height * sizeof( uint32_t ) ); //================================================================================= // HORIZONTAL LINES //================================================================================= for (int y=cell_size; y < image_height; ) // horizontal lines { for (int i=0; i < image_width; i++) picture->data[image_width * y + i] = 0xeeeeee; y += (cell_size + 1); } //================================================================================= // VERTICAL LINES //================================================================================= for (int z=cell_size; z < image_width;) //vertical lines { for (int i=0; i < image_height; i++) picture->data[image_width * i + z] = 0xeeeeee; z += (cell_size + 1); } //int n = MapElement3D(map, 0,0,map->currerntLayer); for (int r1 =0 ; r1<h; r1 ++ ) for (int r2=0; r2<w; r2++) { value = MapElement3D(map, r1, r2, map->currerntLayer); DrawCell(picture, r1, r2, value, w); } return picture; }
void DlgPalette::OnPaint() { CPaintDC dc(this); // device context for painting for (int i = 0; i<m_numcolors; i++) DrawCell(&dc, i); }