void LoadLayout(struct layout *lay) { AutosaveLayout(D_layout); if (!lay) { while (D_canvas.c_slperp) FreeCanvas(D_canvas.c_slperp); MakeDefaultCanvas(); SetCanvasWindow(D_forecv, 0); D_layout = 0; return; } while (D_canvas.c_slperp) FreeCanvas(D_canvas.c_slperp); D_cvlist = 0; if (!D_forecv) MakeDefaultCanvas(); D_forecv = lay->lay_forecv; if (!D_forecv) MakeDefaultCanvas(); DupLayoutCv(&lay->lay_canvas, &D_canvas, 0); D_canvas.c_ys = (D_has_hstatus == HSTATUS_FIRSTLINE); D_canvas.c_ye = D_height - 1 - ((D_canvas.c_slperp && D_canvas.c_slperp->c_slnext) || captionalways) - (D_has_hstatus == HSTATUS_LASTLINE); ResizeCanvas(&D_canvas); RecreateCanvasChain(); RethinkDisplayViewports(); PutWindowCv(&D_canvas); ResizeLayersToCanvases(); D_layout = lay; }
void OneCanvas() { struct canvas *cv = D_forecv, *ocv = 0; if (cv->c_slprev) { ocv = cv->c_slprev; cv->c_slprev->c_slnext = cv->c_slnext; } if (cv->c_slnext) { ocv = cv->c_slnext; cv->c_slnext->c_slprev = cv->c_slprev; } if (!ocv) return; if (cv->c_slback && cv->c_slback->c_slperp == cv) cv->c_slback->c_slperp = ocv; cv->c_slorient = SLICE_UNKN; while (D_canvas.c_slperp) FreeCanvas(D_canvas.c_slperp); cv = D_forecv; D_canvas.c_slperp = cv; cv->c_slback = &D_canvas; cv->c_slnext = 0; cv->c_slprev = 0; ASSERT(!cv->c_slperp); if (!captionalways) D_canvas.c_ye++; /* caption line no longer needed */ ResizeCanvas(&D_canvas); RecreateCanvasChain(); RethinkDisplayViewports(); ResizeLayersToCanvases(); }
void ChangeScreenSize(int wi, int he, int change_fore) { struct win *p; struct canvas *cv; int wwi; debug2("ChangeScreenSize from (%d,%d) ", D_width, D_height); debug3("to (%d,%d) (change_fore: %d)\n",wi, he, change_fore); cv = &D_canvas; cv->c_xe = wi - 1; cv->c_ys = (D_has_hstatus == HSTATUS_FIRSTLINE); cv->c_ye = he - 1 - ((cv->c_slperp && cv->c_slperp->c_slnext) || captionalways) - (D_has_hstatus == HSTATUS_LASTLINE); cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1; if (cv->c_slperp) { ResizeCanvas(cv); RecreateCanvasChain(); RethinkDisplayViewports(); } if (D_forecv == 0) D_forecv = D_cvlist; if (D_forecv) D_fore = Layer2Window(D_forecv->c_layer); D_width = wi; D_height = he; CheckMaxSize(wi); if (D_CWS) { D_defwidth = D_CO; D_defheight = D_LI; } else { if (D_CZ0 && (wi == Z0width || wi == Z1width) && (D_CO == Z0width || D_CO == Z1width)) D_defwidth = D_CO; else D_defwidth = wi; D_defheight = he; } debug2("Default size: (%d,%d)\n", D_defwidth, D_defheight); if (change_fore) ResizeLayersToCanvases(); if (change_fore == 2 && D_CWS == NULL && displays->d_next == 0) { /* adapt all windows - to be removed ? */ for (p = windows; p; p = p->w_next) { debug1("Trying to change window %d.\n", p->w_number); wwi = wi; if (p->w_savelayer && p->w_savelayer->l_cvlist == 0) ResizeLayer(p->w_savelayer, wwi, he, 0); } } }
void GraphicsView::resizeEvent( QResizeEvent* event ) { if (scene()) { // Set same scene rect as the graphics view. scene()->setSceneRect(QRect(QPoint(0, 0), event->size())); emit ResizeCanvas(event->size()); } }
void RemCanvas() { int ye; struct canvas *cv; debug("RemCanvas\n"); cv = D_forecv; if (cv->c_slorient == SLICE_UNKN) return; while (cv->c_slprev) cv = cv->c_slprev; if (!cv->c_slnext) return; if (!cv->c_slnext->c_slnext && cv->c_slback->c_slback) { /* two canvases in slice, kill perp node */ cv = D_forecv; debug("deleting perp node\n"); FreePerp(cv->c_slprev ? cv->c_slprev : cv->c_slnext); FreePerp(cv->c_slback); } ye = cv->c_slback->c_ye; /* free canvas */ cv = D_forecv; D_forecv = cv->c_slprev; if (!D_forecv) D_forecv = cv->c_slnext; FreeCanvas(cv); cv = D_forecv; while (D_forecv->c_slperp) D_forecv = D_forecv->c_slperp; /* if only one canvas left, set orient back to unknown */ if (!cv->c_slnext && !cv->c_slprev && !cv->c_slback->c_slback && !cv->c_slperp) { cv->c_slorient = SLICE_UNKN; if (!captionalways) cv->c_slback->c_ye = ++ye; /* caption line no longer needed */ } cv = cv->c_slback; EqualizeCanvas(cv->c_slperp, 0); ResizeCanvas(cv); D_fore = Layer2Window(D_forecv->c_layer); flayer = D_forecv->c_layer; RecreateCanvasChain(); RethinkDisplayViewports(); ResizeLayersToCanvases(); }
void ChangeScreenSize(int wi, int he, int change_fore) { Window *p; Canvas *cv; int wwi; cv = &D_canvas; cv->c_xe = wi - 1; cv->c_ys = ((cv->c_slperp && cv->c_slperp->c_slnext) || captionalways) * captiontop + (D_has_hstatus == HSTATUS_FIRSTLINE); cv->c_ye = he - 1 - ((cv->c_slperp && cv->c_slperp->c_slnext) || captionalways) * !captiontop - (D_has_hstatus == HSTATUS_LASTLINE); cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1; if (cv->c_slperp) { ResizeCanvas(cv); RecreateCanvasChain(); RethinkDisplayViewports(); } if (D_forecv == 0) D_forecv = D_cvlist; if (D_forecv) D_fore = Layer2Window(D_forecv->c_layer); D_width = wi; D_height = he; CheckMaxSize(wi); if (D_CWS) { D_defwidth = D_CO; D_defheight = D_LI; } else { if (D_CZ0 && (wi == Z0width || wi == Z1width) && (D_CO == Z0width || D_CO == Z1width)) D_defwidth = D_CO; else D_defwidth = wi; D_defheight = he; } if (change_fore) ResizeLayersToCanvases(); if (change_fore == 2 && D_CWS == NULL && displays->d_next == 0) { /* adapt all windows - to be removed ? */ for (p = windows; p; p = p->w_next) { wwi = wi; if (p->w_savelayer && p->w_savelayer->l_cvlist == 0) ResizeLayer(p->w_savelayer, wwi, he, 0); } } }
ZED_UINT32 WindowsRendererOGL3::Create( GraphicsAdapter *p_pAdapter, const CanvasDescription &p_Canvas ) { // Grab the canvas m_Canvas = p_Canvas; if( !m_HDC ) { zedTrace( "The HDC has not been set" ); return ZED_FAIL; } switch( m_Canvas.GetBPP( ) ) { case ZED_FORMAT_A8R8G8B8: { m_PixelFormat.cColorBits = 32; m_PixelFormat.iPixelType = PFD_TYPE_RGBA; break; } default: { zedTrace( "Failed to set the colour format" ); return ZED_FAIL; } } switch( m_Canvas.GetDepthStencil( ) ) { case ZED_FORMAT_D24S8: { m_PixelFormat.cDepthBits = 24; m_PixelFormat.cStencilBits = 8; break; } default: { zedTrace( "Failed to set the depth/stencil format" ); return ZED_FAIL; } } m_PixelFormat.nSize = sizeof( PIXELFORMATDESCRIPTOR ); m_PixelFormat.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER | PFD_TYPE_RGBA; m_PixelFormat.iLayerType = PFD_MAIN_PLANE; // Select the most appropriate pixel format ZED_UINT32 PixelFormat = ChoosePixelFormat( m_HDC, &m_PixelFormat ); if( PixelFormat == 0 ) { zedTrace( "Failed to choose the pixel format" ); return ZED_FAIL; } ZED_BOOL PixelResult = SetPixelFormat( m_HDC, PixelFormat, &m_PixelFormat ); if( PixelResult == ZED_FALSE ) { zedTrace( "Failed to set the pixel format\n" ); return ZED_FAIL; } // Create a fallback GL RC (this is necessary, anyway) HGLRC TempHGLRC = wglCreateContext( m_HDC ); if( wglMakeCurrent( m_HDC, TempHGLRC ) == ZED_FALSE ) { zedTrace( "Could not make the HGLRC current\n" ); return ZED_FAIL; } m_Ext = GLExtender( m_HDC ); // List of OpenGL versions to try and use for the context creation const ZED_INT32 OGLVersions[ ] = { 3, 0, 3, 1, 3, 2, 3, 3, }; ZED_INT32 OpenGLVersion [ 2 ]; glGetIntegerv( GL_MAJOR_VERSION, &OpenGLVersion[ 0 ] ); glGetIntegerv( GL_MINOR_VERSION, &OpenGLVersion[ 1 ] ); zedTrace( "OpenGL Version in use: " " [ %d.%d ]\n", OpenGLVersion[ 0 ], OpenGLVersion[ 1 ] ); // Set the OpenGL Version member m_GLVersion.Major = OpenGLVersion[ 0 ]; m_GLVersion.Minor = OpenGLVersion[ 1 ]; m_Ext.Initialise( m_GLVersion ); ZED_INT32 Major = OGLVersions[ ( sizeof( OGLVersions ) / 4 ) - 2 ], Minor = OGLVersions[ ( sizeof( OGLVersions ) / 4 ) - 1 ]; ZED_INT32 Attribs[ ] = { WGL_CONTEXT_MAJOR_VERSION_ARB, Major, WGL_CONTEXT_MINOR_VERSION_ARB, Minor, WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, #if ZED_BUILD_DEBUG WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB, #endif 0 }; // Attempt to create an OGL 3.3 context if( m_Ext.IsWindowExtSupported( "WGL_ARB_create_context" ) == ZED_TRUE ) { // Try to use the highest available OpenGL version, keep trying // until no more can be tried for( ZED_INT32 i = 1; i < ( sizeof( OGLVersions ) / 4 ) / 2; i++ ) { m_HGLRC = zglCreateContextAttribs( m_HDC, 0, Attribs ); wglMakeCurrent( NULL, NULL ); wglDeleteContext( TempHGLRC ); wglMakeCurrent( m_HDC, m_HGLRC ); if( !m_HGLRC ) { // Loop, again zedTrace( "Failed to create GL Render Context for Version" " [ %d.%d ]\n", Major, Minor ); char Message[ 255 ] = { '\0' }; sprintf( Message, "Failed to create GL Render Context for Version" " [ %d.%d ]", Major, Minor ); MessageBoxA( NULL, Message, "[ZED|Renderer|WindowsRendererOGL3] ERROR", MB_ICONERROR | MB_OK ); } else { ZED_INT32 OpenGLVersion [ 2 ]; glGetIntegerv( GL_MAJOR_VERSION, &OpenGLVersion[ 0 ] ); glGetIntegerv( GL_MINOR_VERSION, &OpenGLVersion[ 1 ] ); // Report the OpenGL version in use const GLubyte *GLVersionString = glGetString( GL_VERSION ); zedTrace( "Created GL Render Context for Version" " [ %d.%d ]\n", OpenGLVersion[ 0 ], OpenGLVersion[ 1 ] ); char Message[ 255 ] = { '\0' }; sprintf( Message, "Created GL Render Context for Version" " [ %d.%d ]\n", Major, Minor ); // Break out break; } Major = OGLVersions[ ( sizeof( OGLVersions ) / 4 ) - ( 2 + ( i*2) ) ]; Minor = OGLVersions[ ( sizeof( OGLVersions ) / 4 ) - ( 1 + ( i*2 ) ) ]; // Use the next major and minor versions of OpenGL in the // list Attribs[ 1 ] = Major; Attribs[ 3 ] = Minor; } } else { m_HGLRC = TempHGLRC; } if( !m_HGLRC ) { zedTrace( "Failed to create GL Render Context" ); return ZED_FAIL; } // Set the viewport ResizeCanvas( m_Canvas.GetWidth( ), m_Canvas.GetHeight( ) ); // Create the Vertex Cache Manager m_pVertexCacheManager = new GLVertexCacheManager( ); return ZED_OK; }
ZED_UINT32 WindowsRendererOGL2::Create( GraphicsAdapter *p_pAdapter, const CanvasDescription &p_Canvas ) { // Grab the canvas for later m_Canvas = p_Canvas; if( !m_HDC ) { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> The HDC has not been set.\n" ); return ZED_FAIL; } switch( m_Canvas.GetBPP( ) ) { case ZED_FORMAT_A8R8G8B8: { m_PixelFormat.cColorBits = 32; m_PixelFormat.iPixelType = PFD_TYPE_RGBA; break; } default: { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Unsupported colour depth.\n" ); return ZED_FAIL; } } switch( m_Canvas.GetDepthStencil( ) ) { case ZED_FORMAT_D24S8: { m_PixelFormat.cDepthBits = 24; m_PixelFormat.cStencilBits = 8; break; } default: { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Unsupported depth/stencil format.\n" ); return ZED_FAIL; } } m_PixelFormat.nSize = sizeof( PIXELFORMATDESCRIPTOR ); m_PixelFormat.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW | PFD_DOUBLEBUFFER | PFD_TYPE_RGBA; m_PixelFormat.iLayerType = PFD_MAIN_PLANE; // Select the most appropriate pixel format ZED_UINT32 PixelFormat = ChoosePixelFormat( m_HDC, &m_PixelFormat ); if( PixelFormat == 0 ) { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Failed to choose the preferred pixel format.\n" ); } ZED_BOOL PixelResult = SetPixelFormat( m_HDC, PixelFormat, &m_PixelFormat ); if( PixelResult == ZED_FALSE ) { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Failed to set the preferred pixel format.\n" ); return ZED_FAIL; } m_HGLRC = wglCreateContext( m_HDC ); if( wglMakeCurrent( m_HDC, m_HGLRC ) == ZED_FALSE ) { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Failed ro create the OpenGL Render Context.\n" ); return ZED_FAIL; } // Make absolutely certain the GL RC is fine if( !m_HGLRC ) { zedTrace( "[ZED|Renderer|WindowsRendererOGL2|Create]" " <ERROR> Failed to create GL Render Context.\n" ); return ZED_FAIL; } m_Ext = GLExtender( m_HDC ); // Get the OpenGL version, both for testing and for GL extensions const GLubyte *GLVersionString = glGetString( GL_VERSION ); ZED_INT32 OpenGLVersion[ 2 ]; // Extract the version number from the string OpenGLVersion[ 0 ] = ( GLVersionString[ 0 ] - 48 ); OpenGLVersion[ 1 ] = ( GLVersionString[ 2 ] - 48 ); zedTrace( "<INFO> OpenGL Version in use: " " [ %d.%d ]\n", OpenGLVersion[ 0 ], OpenGLVersion[ 1 ] ); // Set the class-side OpenGL Version information m_GLVersion.Major = OpenGLVersion[ 0 ]; m_GLVersion.Minor = OpenGLVersion[ 1 ]; if( m_Ext.Initialise( m_GLVersion ) != ZED_OK ) { zedAssert( ZED_FALSE ); zedTrace( "<ERROR> Failed to initialise OpenGL extensions.\n" ); MessageBoxA( NULL, "Failed to initialise OpenGL extensions", "ZED|Error", MB_OK ); return ZED_FAIL; } zedTrace( "Created GL Render Context for Version" " [ %s ]\n", GLVersionString ); char Message[ 255 ] = { '\0' }; sprintf( Message, "Created GL Render Context for Version" " [ %d.%d ]\n", OpenGLVersion[ 0 ], OpenGLVersion[ 1 ] ); /* MessageBoxA( NULL, Message, "[ZED|Renderer|WindowsRendererOGL3] INFO", MB_ICONINFORMATION | MB_OK );*/ // Set up the viewport ResizeCanvas( m_Canvas.GetWidth( ), m_Canvas.GetHeight( ) ); return ZED_OK; }
int AddCanvas(int orient) { struct canvas *cv; int xs, xe, ys, ye; int h, num; cv = D_forecv; debug("AddCanvas orient %d, forecv is %d\n", orient, cv->c_slorient); if (cv->c_slorient != SLICE_UNKN && cv->c_slorient != orient) if (!AddPerp(cv)) return -1; cv = D_forecv; xs = cv->c_slback->c_xs; xe = cv->c_slback->c_xe; ys = cv->c_slback->c_ys; ye = cv->c_slback->c_ye; if (!captionalways && cv == D_canvas.c_slperp && !cv->c_slnext) ye--; /* need space for caption */ debug("Adding Canvas to slice %d,%d ", xs, ys); debug("%d,%d\n", xe, ye); num = CountCanvas(cv->c_slback->c_slperp) + 1; debug("Num = %d\n", num); if (orient == SLICE_VERT) h = ye - ys + 1; else h = xe - xs + 1; h -= 2 * num - 1; if (h < 0) return -1; /* can't fit in */ if ((cv = calloc(1, sizeof *cv)) == 0) return -1; D_forecv->c_slback->c_ye = ye; /* in case we modified it above */ D_forecv->c_slorient = orient; /* in case it was UNKN */ cv->c_slnext = D_forecv->c_slnext; cv->c_slprev = D_forecv; D_forecv->c_slnext = cv; if (cv->c_slnext) cv->c_slnext->c_slprev = cv; cv->c_slorient = orient; cv->c_slback = D_forecv->c_slback; cv->c_xs = xs; cv->c_xe = xe; cv->c_ys = ys; cv->c_ye = ye; cv->c_xoff = 0; cv->c_yoff = 0; cv->c_display = display; cv->c_vplist = 0; cv->c_captev.type = EV_TIMEOUT; cv->c_captev.data = (char *)cv; cv->c_captev.handler = NULL; CanvasInitBlank(cv); cv->c_lnext = 0; cv->c_next = 0; cv = cv->c_slback; EqualizeCanvas(cv->c_slperp, 0); ResizeCanvas(cv); RecreateCanvasChain(); RethinkDisplayViewports(); ResizeLayersToCanvases(); return 0; }
void ResizeCanvas(struct canvas *cv) { struct canvas *cv2, *cvn, *fcv; int nh, i, maxi, hh, m, w, wsum; int need, got; int xs, ys, xe, ye; int focusmin = 0; xs = cv->c_xs; ys = cv->c_ys; xe = cv->c_xe; ye = cv->c_ye; cv = cv->c_slperp; debug("ResizeCanvas: %d,%d", xs, ys); debug(" %d,%d\n", xe, ye); if (cv == 0) return; if (cv->c_slorient == SLICE_UNKN) { ASSERT(!cv->c_slnext && !cv->c_slperp); cv->c_xs = xs; cv->c_xe = xe; cv->c_ys = ys; cv->c_ye = ye; cv->c_xoff = cv->c_xs; cv->c_yoff = cv->c_ys; cv->c_blank.l_width = cv->c_xe - cv->c_xs + 1; cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1; return; } fcv = 0; if (focusminwidth || focusminheight) { debug("searching for focus canvas\n"); cv2 = D_forecv; while (cv2->c_slback) { if (cv2->c_slback == cv->c_slback) { fcv = cv2; focusmin = cv->c_slorient == SLICE_VERT ? focusminheight : focusminwidth; if (focusmin > 0) focusmin--; else if (focusmin < 0) focusmin = cv->c_slorient == SLICE_VERT ? ye - ys + 2 : xe - xs + 2; debug("found, focusmin=%d\n", focusmin); } cv2 = cv2->c_slback; } } if (focusmin) { m = CountCanvas(cv) * 2; nh = cv->c_slorient == SLICE_VERT ? ye - ys + 2 : xe - xs + 2; nh -= m; if (nh < 0) nh = 0; if (focusmin > nh) focusmin = nh; debug("corrected to %d\n", focusmin); } /* pass 1: calculate weight sum */ for (cv2 = cv, wsum = 0; cv2; cv2 = cv2->c_slnext) { debug(" weight %d\n", cv2->c_slweight); wsum += cv2->c_slweight; } debug("wsum = %d\n", wsum); if (wsum == 0) wsum = 1; w = wsum; /* pass 2: calculate need/excess space */ nh = cv->c_slorient == SLICE_VERT ? ye - ys + 2 : xe - xs + 2; for (cv2 = cv, need = got = 0; cv2; cv2 = cv2->c_slnext) { m = cv2->c_slperp ? CountCanvasPerp(cv2) * 2 - 1 : 1; if (cv2 == fcv) m += focusmin; hh = cv2->c_slweight ? nh * cv2->c_slweight / w : 0; w -= cv2->c_slweight; nh -= hh; debug(" should %d min %d\n", hh, m); if (hh <= m + 1) need += m + 1 - hh; else got += hh - m - 1; } debug("need: %d, got %d\n", need, got); if (need > got) need = got; /* pass 3: distribute space */ nh = cv->c_slorient == SLICE_VERT ? ye - ys + 2 : xe - xs + 2; i = cv->c_slorient == SLICE_VERT ? ys : xs; maxi = cv->c_slorient == SLICE_VERT ? ye : xe; w = wsum; for (; cv; cv = cvn) { cvn = cv->c_slnext; if (i > maxi) { if (cv->c_slprev && !cv->c_slback->c_slback && !cv->c_slprev->c_slperp && !cv->c_slprev->c_slprev) { cv->c_slprev->c_slorient = SLICE_UNKN; if (!captionalways) { cv->c_slback->c_ye++; cv->c_slprev->c_ye++; } } SetCanvasWindow(cv, 0); FreeCanvas(cv); continue; } m = cv->c_slperp ? CountCanvasPerp(cv) * 2 - 1 : 1; if (cv == fcv) m += focusmin; hh = cv->c_slweight ? nh * cv->c_slweight / w : 0; w -= cv->c_slweight; nh -= hh; debug(" should %d min %d\n", hh, m); if (hh <= m + 1) { hh = m + 1; debug(" -> %d\n", hh); } else { int hx = need * (hh - m - 1) / got; debug(" -> %d - %d = %d\n", hh, hx, hh - hx); got -= (hh - m - 1); hh -= hx; need -= hx; debug(" now need=%d got=%d\n", need, got); } ASSERT(hh >= m + 1); /* hh is window size plus pation line */ if (i + hh > maxi + 2) { hh = maxi + 2 - i; debug(" not enough space, reducing to %d\n", hh); } if (i + hh == maxi + 1) { hh++; debug(" incrementing as no other canvas will fit\n"); } if (cv->c_slorient == SLICE_VERT) { cv->c_xs = xs; cv->c_xe = xe; cv->c_ys = i; cv->c_ye = i + hh - 2; cv->c_xoff = xs; cv->c_yoff = i; } else { cv->c_xs = i; cv->c_xe = i + hh - 2; cv->c_ys = ys; cv->c_ye = ye; cv->c_xoff = i; cv->c_yoff = ys; } cv->c_xoff = cv->c_xs; cv->c_yoff = cv->c_ys; cv->c_blank.l_width = cv->c_xe - cv->c_xs + 1; cv->c_blank.l_height = cv->c_ye - cv->c_ys + 1; if (cv->c_slperp) { ResizeCanvas(cv); if (!cv->c_slperp->c_slnext) { debug("deleting perp node\n"); FreePerp(cv->c_slperp); FreePerp(cv); } } i += hh; } }
TreeNode* Parser::Statement() { kdDebug(0)<<"Parser::Statement()"<<endl; while (currentToken.type == tokEOL) getToken(); // statements can allways start on newlines switch (currentToken.type) { case tokLearn : return Learn(); break; case tokIf : return If(); break; case tokFor : return For(); break; case tokForEach : return ForEach(); break; case tokWhile : return While(); break; case tokRun : return ExternalRun(); break; case tokReturn : return Return(); break; case tokBreak : return Break(); break; case tokUnknown : return Other(); break; //assignment or function call case tokClear : return Clear(); break; case tokGo : return Go(); break; case tokGoX : return GoX(); break; case tokGoY : return GoY(); break; case tokForward : return Forward(); break; case tokBackward : return Backward(); break; case tokDirection : return Direction(); break; case tokTurnLeft : return TurnLeft(); break; case tokTurnRight : return TurnRight(); break; case tokCenter : return Center(); break; case tokSetPenWidth : return SetPenWidth(); break; case tokPenUp : return PenUp(); break; case tokPenDown : return PenDown(); break; case tokSetFgColor : return SetFgColor(); break; case tokSetBgColor : return SetBgColor(); break; case tokResizeCanvas : return ResizeCanvas(); break; case tokSpriteShow : return SpriteShow(); break; case tokSpriteHide : return SpriteHide(); break; case tokSpritePress : return SpritePress(); break; case tokSpriteChange : return SpriteChange(); break; case tokPrint : return Print(); break; case tokInputWindow : return InputWindow(); break; case tokMessage : return Message(); break; case tokFontType : return FontType(); break; case tokFontSize : return FontSize(); break; case tokRepeat : return Repeat(); break; case tokRandom : return Random(); break; case tokWait : return Wait(); break; case tokWrapOn : return WrapOn(); break; case tokWrapOff : return WrapOff(); break; case tokReset : return Reset(); break; case tokEOF : return EndOfFile(); break; case tokEnd : Error(currentToken, i18n("Cannot understand ']'"), 1050); getToken(); return new TreeNode(currentToken, Unknown); break; case tokBegin : Error(currentToken, i18n("Cannot understand '['"), 1050); getToken(); return new TreeNode(currentToken, Unknown); break; default : break; } if (currentToken.type != tokEnd) { Error(currentToken, i18n("Cannot understand '%1'").arg(currentToken.look), 1060); } getToken(); return new TreeNode(currentToken, Unknown); // fall-though for unknowns }
void Image::ResizeToSquare() { uint32 newImageSize = Max(width, height); ResizeCanvas(newImageSize, newImageSize); }