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