X-Git-Url: http://git.mutantstargoat.com/user/nuclear/?a=blobdiff_plain;f=progs%2Fdemos%2FResizer%2FResizer.cpp;h=85ce4b890e0dbd21a0c5f4e581116d3eade8d4c5;hb=3cb75b2e5c19ab250a5dfd0ca7da0fe7355269ec;hp=8252d7deaabc16346b41dea39cf79151f826c8ac;hpb=793dce4091f5a4a609a6ed4b1b3afe229cad5ddb;p=freeglut

diff --git a/progs/demos/Resizer/Resizer.cpp b/progs/demos/Resizer/Resizer.cpp
index 8252d7d..85ce4b8 100644
--- a/progs/demos/Resizer/Resizer.cpp
+++ b/progs/demos/Resizer/Resizer.cpp
@@ -2,61 +2,234 @@
 
 #include <GL/freeglut.h>
 
-int nWindow;
+int nWindow, nChildWindow = -1;
 int nLoopMain = 0;
-
-int nPosX,  nPosY;
-int nWidth, nHeight;
+GLboolean bChildPosDone = GL_FALSE, bChildSizeDone = GL_FALSE;
 
 void SampleKeyboard( unsigned char cChar, int nMouseX, int nMouseY );
 void Redisplay();
-
+void Reshape(int width, int height);
+void Position(int x, int y);
+void WindowStatus(int state);
 
 
 
 
 void DrawQuad()
 {
+    int width  = glutGet(GLUT_WINDOW_WIDTH);
+    int height = glutGet(GLUT_WINDOW_HEIGHT);
+
     glBegin(GL_QUADS);
-        glVertex2d(nWidth*.25, nHeight*.75);
-        glVertex2d(nWidth*.75, nHeight*.75);
-        glVertex2d(nWidth*.75, nHeight*.25);
-        glVertex2d(nWidth*.25, nHeight*.25);
+        glVertex2d(width*.25, height*.75);
+        glVertex2d(width*.75, height*.75);
+        glVertex2d(width*.75, height*.25);
+        glVertex2d(width*.25, height*.25);
     glEnd();
 }
 
+void UnhideTimer(int window)
+{
+    glutSetWindow(window);
+    glutShowWindow();
+}
+
+void ChangeTitleTimer(int unused)
+{
+    glutSetIconTitle("new icon title");
+    glutSetWindowTitle("new test title");
+}
+
 void SampleKeyboard( unsigned char cChar, int nMouseX, int nMouseY )
 {
-    if (cChar == 27)
+    switch (cChar)
+    {
+    case 27:
         glutLeaveMainLoop();
 
-    else if (cChar=='f')
-    {
-        printf("main window toggle fullscreen\n");
+        break;
+
 
+    case 'f':
+    case 'F':
+        printf("main window toggle fullscreen\n");
         glutFullScreenToggle();
-    }
-    else if (cChar=='r')
-    {
-        printf("main window resize\n");
 
-        if (nWidth<400)
-            glutReshapeWindow(600,300);
+        break;
+
+
+    case 'r':
+    case 'R':
+        if (nChildWindow!=-1 && cChar=='r') /* Capital R always resizes the main window*/
+        {
+            glutSetWindow(nChildWindow);
+            printf("child window resize\n");
+            if (!bChildSizeDone)
+                glutReshapeWindow(glutGet(GLUT_WINDOW_WIDTH)+50,glutGet(GLUT_WINDOW_HEIGHT)+50);
+            else
+                glutReshapeWindow(glutGet(GLUT_WINDOW_WIDTH)-50,glutGet(GLUT_WINDOW_HEIGHT)-50);
+            bChildSizeDone = !bChildSizeDone;
+        }
         else
-            glutReshapeWindow(300,300);
-    }
-    else if (cChar=='m')
-    {
-        printf("main window position\n");
-
-        /* The window position you request is the outer top-left of the window,
-         * the client area is at a different position if the window has borders
-         * and/or a title bar.
-         */
-        if (nPosX<400)
-            glutPositionWindow(600,300);
+        {
+            glutSetWindow(nWindow);
+            printf("main window resize\n");
+            if (glutGet(GLUT_WINDOW_WIDTH)<400)
+                glutReshapeWindow(600,300);
+            else
+                glutReshapeWindow(300,300);
+        }
+
+        break;
+
+
+    case 'm':
+    case 'M':
+        if (nChildWindow!=-1 && cChar=='m') /* Capital M always moves the main window*/
+        {
+            glutSetWindow(nChildWindow);
+            /* The window position you request is relative to the top-left
+             * corner of the client area of the parent window.
+             */
+            if (!bChildPosDone)
+                glutPositionWindow(glutGet(GLUT_WINDOW_X)+50,glutGet(GLUT_WINDOW_Y)+50);
+            else
+                glutPositionWindow(glutGet(GLUT_WINDOW_X)-50,glutGet(GLUT_WINDOW_Y)-50);
+            bChildPosDone = !bChildPosDone;
+        }
         else
-            glutPositionWindow(300,300);
+        {
+            glutSetWindow(nWindow);
+            printf("main window position\n");
+            /* The window position you request is the outer top-left of the window,
+             * the client area is at a different position if the window has borders
+             * and/or a title bar.
+             */
+            if (glutGet(GLUT_WINDOW_X)<400)
+                glutPositionWindow(600,300);
+            else
+                glutPositionWindow(300,300);
+        }
+
+        break;
+
+
+    case 'd':
+    case 'D':
+        if (nChildWindow!=-1 && cChar=='d') /* Capital D always moves+resizes the main window*/
+        {
+            glutSetWindow(nChildWindow);
+            if (!bChildPosDone)
+                glutPositionWindow(glutGet(GLUT_WINDOW_X)+50,glutGet(GLUT_WINDOW_Y)+50);
+            else
+                glutPositionWindow(glutGet(GLUT_WINDOW_X)-50,glutGet(GLUT_WINDOW_Y)-50);
+            bChildPosDone = !bChildPosDone;
+            if (!bChildSizeDone)
+                glutReshapeWindow(glutGet(GLUT_WINDOW_WIDTH)+50,glutGet(GLUT_WINDOW_HEIGHT)+50);
+            else
+                glutReshapeWindow(glutGet(GLUT_WINDOW_WIDTH)-50,glutGet(GLUT_WINDOW_HEIGHT)-50);
+            bChildSizeDone = !bChildSizeDone;
+        }
+        else
+        {
+            if (glutGet(GLUT_WINDOW_X)<400)
+                glutPositionWindow(600,300);
+            else
+                glutPositionWindow(300,300);
+            if (glutGet(GLUT_WINDOW_WIDTH)<400)
+                glutReshapeWindow(600,300);
+            else
+                glutReshapeWindow(300,300);
+        }
+        break;
+
+
+    case 'c':
+    case 'C':
+        if (nChildWindow==-1)
+        {
+            int width  = glutGet(GLUT_WINDOW_WIDTH);
+            int height = glutGet(GLUT_WINDOW_HEIGHT);
+
+            /* open child window */
+            printf("open child window\n");
+
+            nChildWindow = glutCreateSubWindow(nWindow,(int)(width*.35),(int)(height*.35),(int)(width*.3),(int)(height*.3));
+            glutKeyboardFunc( SampleKeyboard );
+            glutDisplayFunc( Redisplay );
+            glutReshapeFunc( Reshape );
+            glutPositionFunc( Position );
+            glutWindowStatusFunc( WindowStatus );
+        }
+        else
+        {
+            /* close child window */
+            printf("close child window\n");
+            glutSetWindow(nWindow);
+            glutDestroyWindow(nChildWindow);
+            nChildWindow = -1;
+            bChildSizeDone = GL_FALSE;
+            bChildPosDone  = GL_FALSE;
+        }
+        break;
+
+
+    case 'i':
+    case 'I':
+        glutIconifyWindow();
+        glutTimerFunc(1500, ChangeTitleTimer, 0);
+        break;
+
+
+    case 'h':
+    case 'H':
+        if (nChildWindow!=-1 && cChar=='h') /* Capital H always hides the main window*/
+        {
+            glutSetWindow(nChildWindow);
+            glutTimerFunc(2000, UnhideTimer, nChildWindow);
+        }
+        else
+        {
+            glutSetWindow(nWindow);
+            glutTimerFunc(2000, UnhideTimer, nWindow);
+        }
+        glutHideWindow();
+        break;
+
+    case 'p':
+    case 'P':
+        if (nChildWindow!=-1 && cChar=='p') /* Capital P always changes pointer for the main window*/
+        {
+            glutSetWindow(nChildWindow);
+			if (glutGet(GLUT_WINDOW_CURSOR)==GLUT_CURSOR_TOP_SIDE)
+			{
+				glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
+				printf("reverting child window cursor\n");
+			}
+            else
+			{
+				glutSetCursor(GLUT_CURSOR_TOP_SIDE);
+				printf("changing child window cursor\n");
+			}
+        }
+        else
+        {
+            glutSetWindow(nWindow);
+            if (glutGet(GLUT_WINDOW_CURSOR)==GLUT_CURSOR_CYCLE)
+			{
+				glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
+				printf("reverting main window cursor\n");
+			}
+            else
+			{
+				glutSetCursor(GLUT_CURSOR_CYCLE);
+				printf("changing main window cursor\n");
+			}
+        }
+        break;
+
+    default:
+        break;
     }
 }
 
@@ -65,76 +238,158 @@ void Idle(void)
     glutPostRedisplay();
 }
 
-void Reshape(int x, int y)
+void Reshape(int width, int height)
 {
-    nWidth  = glutGet(GLUT_WINDOW_WIDTH);
-    nHeight = glutGet(GLUT_WINDOW_HEIGHT);
+    int win = glutGetWindow();
+
+    printf("reshape %s, client area: %dx%d\n",win==nWindow?"main":"child",
+        width, height);
 
-    glViewport(0,0,nWidth,nHeight);
+    glViewport(0,0,width,height);
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
-    gluOrtho2D(0,nWidth,0,nHeight);
+    gluOrtho2D(0,width,0,height);
+
+    if (win==nWindow && nChildWindow!=-1)
+    {
+        /* Put child window in right place */
+        int x = (int)(width*.35), y=(int)(height*.35), w=(int)(width*.3), h = (int)(height*.3);
+        if (bChildPosDone)
+        {
+            x += 50;
+            y += 50;
+        }
+        if (bChildSizeDone)
+        {
+            w += 50;
+            h += 50;
+        }
+        glutSetWindow(nChildWindow);
+        glutPositionWindow(x,y);
+        glutReshapeWindow(w,h);
+        glutSetWindow(nWindow);
+    }
+}
+
+void Position(int x, int y)
+{
+    int win = glutGetWindow();
+
+    printf("position, %s: (%d,%d)\n",win==nWindow?"top-left (non-client) of main":"top-left of child relative to parent",
+        x, y);
+}
+
+void WindowStatus(int state)
+{
+    int win = glutGetWindow();
+    printf("windowstatus (win %i): %i\n",win,state);
 }
 
 void Redisplay(void)
 {
-    if (nLoopMain++%6==0)
+    int win = glutGetWindow();
+    int viewport[4];
+
+    if (win==nWindow)
     {
-        int border, caption;
-
-        nPosX   = glutGet(GLUT_WINDOW_X);
-        nPosY   = glutGet(GLUT_WINDOW_Y);
-        nWidth  = glutGet(GLUT_WINDOW_WIDTH);
-        nHeight = glutGet(GLUT_WINDOW_HEIGHT);
-        border  = glutGet(GLUT_WINDOW_BORDER_WIDTH);
-        caption = glutGet(GLUT_WINDOW_HEADER_HEIGHT);
-        /* returned position is top-left of client area, to get top-left of
-         * of window you'll need to add the size of the border and caption
-         * of the current window (can be 0).
-         * Note that the window position is not necessarily positive (e.g.
-         * when the window is on a monitor to the left of the primary monitor
-         * or simply when maximized--try pressing the maximize button).
-         * the returned size is the size of the client area
-         */
-        printf("window now %dx%d, top-left of client at: (%d,%d), of window at: (%d,%d)\n",
-            nWidth, nHeight,
-            nPosX ,nPosY,
-            nPosX-border,
-            nPosY-border-caption);
+        glClearColor(.2f,0.f,0.f,0.f);
+        glColor3f(1,1,1);
+    }
+    else
+    {
+        /* child window */
+        glClearColor(.0f,.2f,0.f,0.f);
+        glColor3f(.5,.5,.5);
+        glutPostWindowRedisplay(nWindow);
     }
-
-    glClearColor(.2f,0.f,0.f,0.f);
     glClear(GL_COLOR_BUFFER_BIT);
-    glColor3f(1,1,1);
     DrawQuad();
 
+    if (win==nWindow)
+    {
+        glColor3f(1, 1, 0);
+        glGetIntegerv(GL_VIEWPORT, viewport);
+        glRasterPos2i(2, -glutBitmapHeight(GLUT_BITMAP_9_BY_15)+3+viewport[3]);
+        glutBitmapString(GLUT_BITMAP_9_BY_15, (unsigned char*)"press f/r/m/d/c/i/h/p");
+    }
+
     glutSwapBuffers();
-    glutPostRedisplay();
+    glutPostWindowRedisplay(win);
+}
+
+void Timer(int unused)
+{
+    int win = glutGetWindow();
+    int x, y;
+    int width, height;
+    int border, caption;
+
+    x       = glutGet(GLUT_WINDOW_X);
+    y       = glutGet(GLUT_WINDOW_Y);
+    width   = glutGet(GLUT_WINDOW_WIDTH);
+    height  = glutGet(GLUT_WINDOW_HEIGHT);
+    border  = glutGet(GLUT_WINDOW_BORDER_WIDTH);
+    caption = glutGet(GLUT_WINDOW_HEADER_HEIGHT);
+    /* returned position is top-left of client area, to get top-left of
+     * of window you'll need to add the size of the border and caption
+     * of the current window (can be 0).
+     * Note that the window position is not necessarily positive (e.g.
+     * when the window is on a monitor to the left of the primary monitor
+     * or simply when maximized--try pressing the maximize button).
+     * the returned size is the size of the client area
+     * Note that the top-left of a child window is relative to the
+     * top-left of the client area of the parent.
+     */
+    /* printf("window border: %dpx, caption: %dpx\n",border,caption); */
+    if (win==nWindow)
+        printf("main  window %dx%d, top-left of client at: (%d,%d), of window at: (%d,%d)\n",
+            width, height,
+            x ,y,
+            x-border,
+            y-caption);
+    else
+        printf("child window %dx%d, top-left of client at: (%d,%d), relative to parent\n",
+        width, height,
+        x ,y);
+
+    /* (re)set the timer callback and ask glut to call it in 500 ms */
+    glutTimerFunc(500, Timer, 0);
 }
 
 
 int main(int argc, char* argv[])
 {
+    int border, caption;
     glutInit( &argc, argv );
     glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE /*| GLUT_BORDERLESS*/); // do try as well with GLUT_BORDERLESS and GLUT_CAPTIONLESS
     glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,GLUT_ACTION_GLUTMAINLOOP_RETURNS);
+    
+    /* Get border and caption size of default window style */
+    border  = glutGet(GLUT_WINDOW_BORDER_WIDTH);
+    caption = glutGet(GLUT_WINDOW_HEADER_HEIGHT);
+    printf("default window style border: %dpx, caption: %dpx\n",border,caption);
 
-    /* The window position you request is the outer top-left of the window,
-     * the client area is at a different position if the window has borders
-     * and/or a title bar.
+    /* NB: The window position you request is the outer top-left of the
+     * window, the client area is at a different position if the window has
+     * borders and/or a title bar.
      */
     glutInitWindowPosition(150,250);
     glutInitWindowSize(200,200);
 
     nWindow = glutCreateWindow("test");
+    glutSetIconTitle("test icon title");
     printf("main window id: %d\n", nWindow);
 
     glutKeyboardFunc( SampleKeyboard );
     glutDisplayFunc( Redisplay );
     glutReshapeFunc( Reshape );
+    glutPositionFunc( Position );
+    glutWindowStatusFunc( WindowStatus );
+
+    glutTimerFunc(300, Timer, 0);
 
     glutMainLoop();
     printf("glutMainLoop returned\n");
 
-    return 1;
-}
\ No newline at end of file
+    return EXIT_SUCCESS;
+}