void CGUINumberControl::processRender(const GsRect<float> &RectDispCoordFloat) { // Transform to the display coordinates GsRect<float> displayRect = mRect; displayRect.transform(RectDispCoordFloat); GsRect<Uint16> lRect(displayRect); GsWeakSurface blitsfc(gVideoDriver.getBlitSurface()); if( mReleased ) { blitsfc.drawRect( lRect, 1, 0x00BBBBBB, 0x00CFCFCF ); } else if( mPressed ) { blitsfc.drawRect( lRect, 1, 0x00BBBBBB, 0x00DFDFDF ); } else if( mHovered ) { blitsfc.drawRect( lRect, 1, 0x00BBBBBB, 0x00EFEFEF ); } else { blitsfc.drawRect( lRect, 1, 0x00BBBBBB, 0x00FFFFFF ); } // Now lets draw the text of the list control GsFont &Font = gGraphics.getFont(mFontID); Font.drawFontCentered( blitsfc, mText, lRect, false ); }
//*******************************************************************************************************/ //* FileName: clPlot.cpp //* //* Contents: Implementation of clPlot, axis, legend, serie and timeaxis //* //* NOTE 1: Only a minimum of parameter validation is implemented to save time since this plot is //* time critical. //* //* NOTE 2: All functionality is not fully implemented. //* //* Author: Jan Vidar Berger //*******************************************************************************************************/ //* 12.feb.98 Jan Vidar Berger Implemented flicker free drawing. Thanks to John Kim for providing //* the CGridMemDC and to Keith Rule, the author of CMemDC. //*******************************************************************************************************/ #include "stdafx.h" #include "clPlot.h" #include "GridMemDC.h" #include "malloc.h" #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE[] = __FILE__; #endif long clPlot::m_lMaxDataPrSerie; // max allowed data pr. serie. long clPlot::m_lMaxDataTotal; // max allowed data total. //*******************************************************************************************************/ //* time axis threshold. contains grid and label intervals to be used within specified //* seconds pr. pixels thresholds. The array is terminated by a 'bIAmInUse'=FALSE. //*******************************************************************************************************/ struct{ BOOL bIAmInUse; // indicate valid entry, last=FALSE long lgridinterval; // grid line interval in seconds long llabelinterval; // time label interval in seconds long lmodethreshold; // mode threshold in seconds pr. pixel }gridsetting[]={ TRUE, 1, 4, 0, // 0: pr. second FALSE, 1, 1,0, // last entry in table }; //*******************************************************************************************************/ //* Function: serie::serie //*******************************************************************************************************/ serie::serie() { m_bIAmInUse = FALSE; m_color = RGB(0,0,0); m_iLineStyle = PS_SOLID; m_bRightAxisAlign = FALSE; m_lNoValues = 0; m_lbegin = 0; m_lend = 0; m_pvalues = NULL; } //*******************************************************************************************************/ //* Function: serie::~serie //*******************************************************************************************************/ serie::~serie() { if(m_pvalues !=NULL) free(m_pvalues); } //*******************************************************************************************************/ //* Function: serie::AddPoint //* //* Description: AddPoint add new data to the end of a data serie. It will simply append the data, //* update the list index and get out. //* //* This function will also call realloc or malloc to re-size or create the plot array as //* needed. //* //* The nice thing about circular lists is that they are multi thread enabled as is. You //* must however implement a syncronization mechanism if more than one thread is supposed //* to enter data into the plot. //* //* Parameters: valuetime Time (x value). //* y y value //* //* Return Value: -none- //* //* Author: Jan Vidar Berger //*******************************************************************************************************/ void serie::AddPoint(CTime &valuetime , double &y) { if(m_lNoValues > 0) m_pvalues = (value*)realloc(m_pvalues, (m_lNoValues+1)*sizeof(value)); else m_pvalues = (value*)malloc((m_lNoValues+1)*sizeof(value)); m_pvalues[m_lend].ValueTime = valuetime; m_pvalues[m_lend].dValue = y; m_lNoValues++; m_lend++; if(m_lend >= clPlot::m_lMaxDataPrSerie) m_lend=0; if(m_lbegin == m_lend){ m_lbegin++; if(m_lbegin >= clPlot::m_lMaxDataPrSerie) m_lbegin=0; } } //*******************************************************************************************************/ //* Function: serie::Reset //* //* Description: Reset the serie. Remove data and reset indexes and pointers. //* //* Parameters: -none- //* //* Return Value: -none- //* //* Author: Jan Vidar Berger //*******************************************************************************************************/ void serie::Reset() { m_lNoValues=0; if(m_pvalues !=NULL) free(m_pvalues); m_pvalues = NULL; m_lbegin = 0; m_lend = 0; } //*******************************************************************************************************/ //*******************************************************************************************************/ clPlot::clPlot() { m_ctlBkColor = RGB(255,255,255); m_plotBkColor = RGB(255,255,255); m_legendBkColor = RGB(255,255,255); m_gridColor = RGB(127,127,127); m_bctlBorder = TRUE; m_bplotBorder = TRUE; m_blegendBorder = TRUE; m_bPrimaryLegend = FALSE; m_bSecondaryLegend = FALSE; m_bAxisLY = TRUE; m_bAxisRY = TRUE; m_bAxisBX = TRUE; m_bAutoScrollX = FALSE; m_bSimMode = FALSE; m_lMaxDataPrSerie = 10000; m_lMaxDataTotal = 100000; m_dNoData = 0.0; m_dzoom = 1.0; lArraySize = 1000; // only points with differebt x,y will be put into the array pLineArray = new CPoint[lArraySize]; SetBXRange(CTime::GetCurrentTime()-CTimeSpan(60),CTime::GetCurrentTime()); m_logFont.lfHeight = -13; m_logFont.lfWidth = 0; m_logFont.lfEscapement = 0; m_logFont.lfOrientation = 0; m_logFont.lfWeight = 400; m_logFont.lfItalic = FALSE; m_logFont.lfUnderline = FALSE; m_logFont.lfStrikeOut = FALSE; m_logFont.lfCharSet = ANSI_CHARSET; m_logFont.lfOutPrecision = OUT_DEFAULT_PRECIS; m_logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS; m_logFont.lfQuality = PROOF_QUALITY; m_logFont.lfPitchAndFamily = DEFAULT_PITCH; wcscpy(m_logFont.lfFaceName,_T("Ariel")); m_zoomFont.lfHeight = -13; m_zoomFont.lfWidth = 0; m_zoomFont.lfEscapement = 0; m_zoomFont.lfOrientation = 0; m_zoomFont.lfWeight = 400; m_zoomFont.lfItalic = FALSE; m_zoomFont.lfUnderline = FALSE; m_zoomFont.lfStrikeOut = FALSE; m_zoomFont.lfCharSet = ANSI_CHARSET; m_zoomFont.lfOutPrecision = OUT_DEFAULT_PRECIS; m_zoomFont.lfClipPrecision = CLIP_DEFAULT_PRECIS; m_zoomFont.lfQuality = PROOF_QUALITY; m_zoomFont.lfPitchAndFamily = DEFAULT_PITCH; wcscpy(m_zoomFont.lfFaceName,_T("Ariel")); m_font.CreateFontIndirect(&m_zoomFont); } //*******************************************************************************************************/ //*******************************************************************************************************/ clPlot::~clPlot() { delete [] pLineArray; } //*******************************************************************************************************/ //*******************************************************************************************************/ BEGIN_MESSAGE_MAP(clPlot, CWnd) //{{AFX_MSG_MAP(clPlot) ON_WM_PAINT() //}}AFX_MSG_MAP END_MESSAGE_MAP() //*******************************************************************************************************/ //*******************************************************************************************************/ BOOL clPlot::Create(DWORD dwstyle, CRect &rect, CWnd *pParent, UINT id) { DWORD style = dwstyle & (~WS_BORDER); if(dwstyle & WS_BORDER) m_bctlBorder=TRUE; else m_bctlBorder=FALSE; if(!CWnd::Create(NULL, _T(""), style, rect, pParent, id, NULL)) return FALSE; m_ctlRect = rect; pParent->ClientToScreen(m_ctlRect); ScreenToClient(m_ctlRect); ComputeRects(TRUE); return TRUE; } //*******************************************************************************************************/ //* Function : clPlot::ComputeRects //* //* Description : Compute rects used for internal possitioning of different objects. This function is //* called when the plot is created or sized. //* //* Return type : void //* //* Parameter(s) : bInitialization indicate wherever parameters that can be changed abu the user //* also should be computed. //* //* Author : Jan Vidar Berger //*******************************************************************************************************/ void clPlot::ComputeRects(BOOL bInitialization) { // adjust the client rect for borders //GetClientRect(m_ctlRect); CClientDC dc(this); int w = 0; int n=0; CSize z=dc.GetTextExtent(CString("A")); // m_TextHeight = z.cy; m_dzoom = ((double)m_ctlRect.Height()/(double)z.cy) / 25.0; m_zoomFont.lfWidth = (int)(m_logFont.lfWidth * m_dzoom); m_zoomFont.lfHeight = (int)(m_logFont.lfHeight * m_dzoom); m_font.Detach(); m_font.CreateFontIndirect(&m_zoomFont); CFont *oFont = dc.SelectObject(&m_font); // SetFont(&m_font); z=dc.GetTextExtent(CString("A")); m_TextHeight = z.cy; if(m_bctlBorder){ m_clientRect.left = m_ctlRect.left+2; m_clientRect.right = m_ctlRect.right-2; m_clientRect.top = m_ctlRect.top+2; m_clientRect.bottom = m_ctlRect.bottom-2; }else{ m_clientRect = m_ctlRect; } if(bInitialization) { m_iMtop = m_iMbottom = m_clientRect.Height()/10; m_iMleft = m_iMright = m_clientRect.Width()/10; } // compute plot rect. m_plotRect.left = m_clientRect.left + m_iMleft; m_plotRect.right = m_clientRect.right - m_iMright; m_plotRect.top = m_clientRect.top + m_iMtop; m_plotRect.bottom = m_clientRect.bottom - m_iMbottom; // compute default legend possition if(bInitialization) { m_legendRect.left = m_plotRect.left + (m_iMleft/5); m_legendRect.right = m_plotRect.left + (m_plotRect.Width()/5); m_legendRect.top = m_plotRect.top - (m_iMtop/2); m_legendRect.bottom = m_plotRect.top + (m_iMtop); int w = 0; int n=0; for(int x = 0; x< MAXLEGENDS;x++){ if(m_primarylegends[x].m_bIAmInUse){ n++; z=dc.GetTextExtent(CString(m_primarylegends[x].m_szTitle)); if(z.cx > w ) w=z.cx; // m_TextHeight = z.cy; } } m_legendRect.right = m_legendRect.left + 40 + w; m_legendRect.bottom = m_legendRect.top + 10 + (m_TextHeight*n); } // compute left axis area m_axisLYRect.left = m_clientRect.left + (m_iMleft/5); m_axisLYRect.right = m_plotRect.left; m_axisLYRect.top = m_plotRect.top; m_axisLYRect.bottom = m_plotRect.bottom; // compute right axis area m_axisRYRect.left = m_plotRect.left; m_axisRYRect.right = m_clientRect.right - (m_iMright/5); m_axisRYRect.top = m_plotRect.top; m_axisRYRect.bottom = m_plotRect.bottom; // compute bottom axis area m_axisBXRect.left = m_plotRect.left; m_axisBXRect.right = m_plotRect.right; m_axisBXRect.top = m_plotRect.bottom; m_axisBXRect.bottom = m_clientRect.bottom - (m_iMbottom/5); // if(bInitialization) // { m_timeaxis.m_dSecondsPrPixel = ((double)(m_timeaxis.m_maxtime.GetTime() - m_timeaxis.m_mintime.GetTime())) / (double)m_plotRect.Width(); m_leftaxis.m_dValuePrPixel = ((double)(m_leftaxis.maxrange- m_leftaxis.minrange) / (double)m_plotRect.Height()); m_rightaxis.m_dValuePrPixel = ((double)(m_rightaxis.maxrange- m_rightaxis.minrange) / (double)m_plotRect.Height()); // } dc.SelectObject(oFont); } //*******************************************************************************************************/ //* Function: clPlot::OnPaint //* //* Description: This function will create a memory image, call Draw to draw the plot on it, and when //* copy the image into memory. //* //* This is fast and provides flicker free plot update. //* //* Author: Jan Vidar Berger //*******************************************************************************************************/ void clPlot::OnPaint() { CPaintDC dc(this); // device context for painting CGridMemDC pdc(&dc); // non flickering painting Draw(&pdc); // Do not call CWnd::OnPaint() for painting messages } BOOL clPlot::OnEraseBkgnd(CDC* pDC) { return FALSE; } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::Draw(CDC * dc) { CFont *oFont = dc->SelectObject(&m_font); DrawBasic(dc); DrawGrid(dc); DrawPlot(dc); DrawLegend(dc); dc->SelectObject(oFont); } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawBasic(CDC * dc) { CBrush brushctlBkColor(m_ctlBkColor); dc->FillRect(m_ctlRect,&brushctlBkColor); if(m_bctlBorder) { dc->DrawEdge(m_ctlRect,BDR_SUNKENINNER|BDR_SUNKENOUTER, BF_RECT); } dc->Rectangle(m_plotRect); DrawLegendShadow(dc); } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawPlot(CDC * dc) { for(int s=0;s<MAXSERIES;s++) { if(m_series[s].m_bIAmInUse) { DrawSerie(dc, s); } } } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawSerie(CDC *dc,int s) { BOOL bMore=TRUE; BOOL bDraw; CPoint p; int ly; // lets get some serie parameters now and save the time of indexing during the loop long y = m_series[s].m_lbegin; long m = m_series[s].m_lend; long a = m_series[s].m_lNoValues; BOOL bRightAxis = m_series[s].m_bRightAxisAlign; CPen pen(m_series[s].m_iLineStyle, 1, m_series[s].m_color); CPen *old = dc->SelectObject(&pen); while(bMore){ bDraw=FALSE; bMore=FALSE; ly=0; while(y != m && !bDraw){ if(m_series[s].m_pvalues[y].dValue == m_dNoData) { bDraw = TRUE; bMore = TRUE; }else{ // Scaling. We do scaling inline to save some time time_t valuetime = m_series[s].m_pvalues[y].ValueTime.GetTime(); p.x = (int)(m_plotRect.left + ((valuetime-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel)); if(bRightAxis){ p.y = (int)(m_plotRect.bottom - ((m_series[s].m_pvalues[y].dValue-m_rightaxis.minrange)/m_rightaxis.m_dValuePrPixel)); }else{ p.y = (int)(m_plotRect.bottom - ((m_series[s].m_pvalues[y].dValue-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel)); } if((ly == 0 || p.x != pLineArray[ly].x || p.y != pLineArray[ly].y) && (p.x >= m_plotRect.left && p.x <= m_plotRect.right)) { pLineArray[ly].x = p.x; pLineArray[ly].y = p.y; ly++; } } y++; if(y > a) // wrap list index ? y=0; } if(ly > 0){ dc->Polyline(pLineArray, ly); } } dc->SelectObject(old); } //*******************************************************************************************************/ //* //*******************************************************************************************************/ void clPlot::DrawGrid(CDC * dc) { DrawXAxisGrid(dc); DrawYAxisGrid(dc); } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawYAxisGrid(CDC * dc) { double yGrid = m_leftaxis.minrange; double delta = 25.0 + (long)(((m_leftaxis.m_dValuePrPixel)))*25; if((long)delta%50 != 0 && delta > 20.0) delta +=25; double d10 = delta / 5.0; // todo: delta switch long diff = ((long)yGrid)%((long)delta); yGrid = yGrid - diff; CPen *old, pen(PS_SOLID, 1, m_gridColor); CPen stick(PS_SOLID,0,RGB(0,0,0)); CPen mline(PS_SOLID,0,RGB(192,192,192)); for( long sy = (long)((long)(m_leftaxis.minrange) - diff); sy < m_leftaxis.maxrange; sy+=(long)d10) { int off=3; if((long)sy%(long)delta == 0){ off=5; } if(sy > m_leftaxis.minrange){ int y = (int)(m_plotRect.bottom - ((sy-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel)); old = dc->SelectObject(&stick); dc->MoveTo(CPoint(m_plotRect.left,y)); dc->LineTo(CPoint(m_plotRect.left-off,y)); dc->MoveTo(CPoint(m_plotRect.right,y)); dc->LineTo(CPoint(m_plotRect.right+off,y)); dc->SelectObject(old); old = dc->SelectObject(&mline); dc->MoveTo(CPoint(m_plotRect.left+1,y)); dc->LineTo(CPoint(m_plotRect.right-1,y)); dc->SelectObject(old); } } old = dc->SelectObject(&pen); while(yGrid <= m_leftaxis.maxrange) { double yy = m_plotRect.bottom - ((yGrid-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel); int y = (int)yy; if(yGrid > m_leftaxis.minrange && yGrid<m_leftaxis.maxrange){ dc->MoveTo(CPoint(m_plotRect.left+1,y)); dc->LineTo(CPoint(m_plotRect.right-1,y)); } TCHAR b[100]; swprintf(b, _T("%.0f"), yGrid); dc->DrawText(b, CRect(m_clientRect.left, y-m_TextHeight/2,m_plotRect.left-5,y+m_TextHeight/2), DT_RIGHT|DT_BOTTOM); double yr = (m_plotRect.bottom - yy) * m_rightaxis.m_dValuePrPixel + m_rightaxis.minrange; swprintf(b, _T("%.0f"), yr); dc->DrawText(b, CRect(m_plotRect.right+5, y-m_TextHeight/2,m_clientRect.right,y+m_TextHeight/2), DT_LEFT|DT_BOTTOM); yGrid += delta; } dc->SelectObject(old); } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawXAxisGrid(CDC * dc) { long yGrid = m_timeaxis.m_mintime.GetTime(); long delta = (long)(10.0 + (long)(((m_timeaxis.m_dSecondsPrPixel)))*10); long d10 = (long)(delta / 10.0); // todo: delta switch long diff = ((long)yGrid)%((long)delta); yGrid = yGrid - diff; CPen *old, pen(PS_SOLID, 1, m_gridColor); CPen stick(PS_SOLID,0,RGB(0,0,0)); CPen mline(PS_SOLID,0,RGB(192,192,192)); for( long sx = m_timeaxis.m_mintime.GetTime() - diff; sx < m_timeaxis.m_maxtime.GetTime(); sx+=d10) { int off=3; if((long)sx%(long)delta == 0){ off=5; } if(sx > m_timeaxis.m_mintime.GetTime()){ int x = (int)(m_plotRect.left + ((sx-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel)); // int x = m_plotRect.right - ((sx-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_lSecondsPrPixel); old = dc->SelectObject(&stick); dc->MoveTo(CPoint(x,m_plotRect.bottom)); dc->LineTo(CPoint(x+off,m_plotRect.bottom)); dc->SelectObject(old); old = dc->SelectObject(&mline); dc->MoveTo(CPoint(x,m_plotRect.bottom-1)); dc->LineTo(CPoint(x,m_plotRect.top+1)); dc->SelectObject(old); } } old = dc->SelectObject(&pen); while(yGrid <= m_timeaxis.m_maxtime.GetTime()) { int x = (int)(m_plotRect.left + ((yGrid-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel)); if(yGrid > m_timeaxis.m_mintime.GetTime() && yGrid<m_timeaxis.m_maxtime.GetTime()){ dc->MoveTo(CPoint(x,m_plotRect.bottom-1)); dc->LineTo(CPoint(x,m_plotRect.top+1)); } // char b[100]; // sprintf(b, "%.0f", yGrid); // dc->DrawText(b, CRect(m_clientRect.left, y-m_TextHeight/2,m_plotRect.left-5,y+m_TextHeight/2), DT_RIGHT|DT_BOTTOM); yGrid += delta; } dc->SelectObject(old); } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawLegendShadow(CDC * dc) { if(m_blegendBorder){ CPen pen(PS_SOLID, 1, RGB(127,127,127)); CPen *oPen = dc->SelectObject(&pen); CBrush *oBrush , brush(RGB(127,127,127)); oBrush = dc->SelectObject(&brush); dc->Rectangle(CRect(m_legendRect.left+5,m_legendRect.top+5,m_legendRect.right+5, m_legendRect.bottom+5)); dc->SelectObject(oBrush); dc->SelectObject(oPen); } } //*******************************************************************************************************/ //*******************************************************************************************************/ void clPlot::DrawLegend(CDC * dc) { if(m_blegendBorder){ CPen pen(PS_SOLID, 1, RGB(0,0,0)); CPen *oPen = dc->SelectObject(&pen); CBrush *oBrush , brush(m_legendBkColor); oBrush = dc->SelectObject(&brush); dc->Rectangle(m_legendRect); dc->SelectObject(oBrush); dc->SelectObject(oPen); } int y = m_legendRect.top + 5; int dx = m_legendRect.left + (2*m_TextHeight); int mh = m_TextHeight/2; for(int x = 0; x< MAXLEGENDS;x++){ if(m_primarylegends[x].m_bIAmInUse){ CRect lRect( dx + 5, y, m_legendRect.right - 5, y + m_TextHeight); CPen pen(m_primarylegends[x].m_istyle, 1, m_primarylegends[x].m_color); CPen *oPen = dc->SelectObject(&pen); dc->MoveTo(CPoint(m_legendRect.left+5, y + mh)); dc->LineTo(CPoint(dx, y+mh)); dc->SelectObject(oPen); dc->DrawText(m_primarylegends[x].m_szTitle, lRect, DT_LEFT); y+=m_TextHeight+1; } } }
void QtOpenCVZedDemo::timerEvent(QTimerEvent *event) { Q_UNUSED(event); updateFps( mElabTime.elapsed() ); mElabTime.restart(); cv::Mat image; mCapture >> image; if( mFlipVert && mFlipHoriz ) cv::flip( image,image, -1); else if( mFlipVert ) cv::flip( image,image, 0); else if( mFlipHoriz ) cv::flip( image,image, 1); // Do what you want with the image :-) int w = image.cols/2; int h = image.rows; cv::Rect lRect( 0,0,w,h ); cv::Rect rRect( w,0,w,h ); cv::Mat left = image(lRect); cv::Mat right = image(rRect); ui->graphicsView_left->setScene( &mLeft ); // Show the image mLeft.setBgImage( left ); mRight.setBgImage( right ); if( ui->tabWidget->currentIndex() == 0 ) { doStereoSGBM_CPU( left, right ); } else if( ui->tabWidget->currentIndex() == 1 ) { // TODO Cuda processing } else if( ui->tabWidget->currentIndex() == 2 ) { #ifndef Q_PROCESSOR_ARM doStereoSBM_OCL(left, right ); //doStereoCSBP_OCL( left, right ); //doStereoBP_OCL(left,right); #endif } mDisp.setBgImage( mDisparity ); }
//UI void SetupUI() { DBOXUIPROPERTIES props = {0}; props.BaseWidth = 1280; props.BaseHeight = 1024; props.eng2d = Engine2D; props.FontColor = 0xffdddddd; props.hWnd = App->GetWindowHandle(); props.pDevice = Engine3D->GetDevice(); props.inp = Input; props.FontFace = "Arial Black"; props.TextureKeyColor = 0xffff00ff; props.TextureName = "UI.png"; props.LabelWordSize = 85; props.BtnRects[0] = lRect(0,0 , 386,139); props.BtnRects[1] = lRect(0,140 , 386,279); props.BtnRects[2] = lRect(0,280 , 386,419); props.TextboxRect = lRect(0,420 , 589,559); UIm.Create(props); //select profile UIm.Pages["prof"]["Hello Label"] = DBOXUICreateLabel(&UIm , lRect(0, 90, 1280 , 400) , "Impossible Game for PC(beta)\n\rOriginal game by : flukedude.com\n\rThe remake by K.Petkov\n\rSelect your profile..."); UIm.Pages["prof"]["prof1"] = DBOXUICreateButton(&UIm , Profiles::profiles[0].Name , lPoint(1280/4 - 387/2 - 90, 500)); UIm.Pages["prof"]["prof2"] = DBOXUICreateButton(&UIm , Profiles::profiles[1].Name , lPoint(1280/2 - 387/2 , 500)); UIm.Pages["prof"]["prof3"] = DBOXUICreateButton(&UIm , Profiles::profiles[2].Name , lPoint(1920/2 - 387/2 + 90 , 500)); UIm.Pages["prof"]["ok"] = DBOXUICreateButton(&UIm , "OK" , lPoint(740, 800)); UIm.Pages["prof"]["tb"] = DBOXUICreateTextbox(&UIm , 9 , lPoint(120 , 800) , "profile"); UIm.Pages["prof"]["Name Label"] = DBOXUICreateLabel(&UIm , lRect(0, 670, 1280 , 100) , "Enter your name ..."); //main UIm.Pages["main"]["Hello Label"] = DBOXUICreateLabel(&UIm , lRect(0, 0, 1280 , 100) , "Hello "); UIm.Pages["main"]["Start"] = DBOXUICreateButton(&UIm , "Start" , lPoint(1280/2 - 387/2 , 350)); UIm.Pages["main"]["Settings"] = DBOXUICreateButton(&UIm , "Settings" , lPoint(1280/2 - 387 - 1, 500)); UIm.Pages["main"]["Controls"] = DBOXUICreateButton(&UIm , "Controls" , lPoint(1280/2 + 1, 500)); UIm.Pages["main"]["Stats"] = DBOXUICreateButton(&UIm , "Stats" , lPoint(1280/2 - 387 - 1, 650)); UIm.Pages["main"]["Profiles"] = DBOXUICreateButton(&UIm , "Profiles" , lPoint(1280/2 + 1 , 650)); UIm.Pages["main"]["Exit"] = DBOXUICreateButton(&UIm , "Exit" , lPoint(1280/2 - 387/2 , 800)); UIm.Pages["main"]["Controls"]->InfoState.Locked = UIm.Pages["main"]["Stats"]->InfoState.Locked = true; //settings UIm.Pages["settings"]["ResolutionSelect"] = DBOXUICreateLabel(&UIm , lRect(0, 100, 1280 , 100) , "Select your screen resolution .."); UIm.Pages["settings"]["640x480"] = DBOXUICreateButton(&UIm , "640x480" , lPoint(1280/2 - 387 - 10, 270)); UIm.Pages["settings"]["800x600"] = DBOXUICreateButton(&UIm , "800x600", lPoint(1280/2 + 10 , 270)); UIm.Pages["settings"]["1024x768"] = DBOXUICreateButton(&UIm , "1024x768" , lPoint(1280/2 - 387 - 10, 420)); UIm.Pages["settings"]["1280x1024"] = DBOXUICreateButton(&UIm , "1280x1024" , lPoint(1280/2 + 10 , 420)); UIm.Pages["settings"]["Toggle"] = DBOXUICreateButton(&UIm , "Fullscreen" , lPoint(1280/2 - 387 - 10 , 570)); // UIm.Pages["settings"]["Toggle"]->InfoState.Locked = true; UIm.Pages["settings"]["Back"] = DBOXUICreateButton(&UIm , "Back" , lPoint(1280/2 + 10 , 570)); //select level UIm.Pages["level"]["l1"] = DBOXUICreateButton(&UIm , "Level 1" , lPoint(1280/2 - 387/2 , 350)); UIm.Pages["level"]["l2"] = DBOXUICreateButton(&UIm , "Level 2" , lPoint(1280/2 - 387/2 , 500)); UIm.Pages["level"]["l3"] = DBOXUICreateButton(&UIm , "Level 3" , lPoint(1280/2 - 387/2 , 650)); UIm.Pages["level"]["Back"] = DBOXUICreateButton(&UIm , "Menu" , lPoint(1920/2 - 387/2 + 90 , 800)); UIm.Pages["ingame"]["Menu"] = DBOXUICreateButton(&UIm , "Menu" , lPoint(1920/2 - 387/2 + 110 , 830)); UIm.Pages["paused"]["Resume"] = DBOXUICreateButton(&UIm , "Resume" , lPoint(1280/2 - 387/2 , 500)); UIm.Pages["paused"]["Leave"] = DBOXUICreateButton(&UIm , "Leave" , lPoint(1280/2 - 387/2 , 650)); UIm.Pages["lcompleate"]["Menu"] = DBOXUICreateButton(&UIm , "Menu" , lPoint(1280/2 - 387/2 , 650)); UIm.Pages["lcompleate"]["label"] = DBOXUICreateLabel(&UIm , lRect(0 , 400 , 1280 , 400) , "Level clear !!!"); UIm.ActivePage = "prof"; }