John Fay: Implement the modified logic of the direct/indirect rendering context.
[freeglut] / src / freeglut_window.c
1 /*
2  * freeglut_window.c
3  *
4  * Window management methods.
5  *
6  * Copyright (c) 1999-2000 Pawel W. Olszta. All Rights Reserved.
7  * Written by Pawel W. Olszta, <olszta@sourceforge.net>
8  * Creation date: Fri Dec 3 1999
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a
11  * copy of this software and associated documentation files (the "Software"),
12  * to deal in the Software without restriction, including without limitation
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  * and/or sell copies of the Software, and to permit persons to whom the
15  * Software is furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included
18  * in all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
23  * PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
24  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
25  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26  */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include <GL/freeglut.h>
33 #include "freeglut_internal.h"
34
35 #if TARGET_HOST_WINCE
36 #include <aygshell.h>
37 #pragma comment( lib, "Aygshell.lib" )
38
39 wchar_t* wstr_from_str(const char* str)
40 {
41     int i,len=strlen(str);
42     wchar_t* wstr = (wchar_t*)malloc(2*len+2);
43     for(i=0; i<len; i++)
44         wstr[i] = str[i];
45     wstr[len] = 0;
46     return wstr;
47 }
48
49
50 #endif /* TARGET_HOST_WINCE */
51
52 /*
53  * TODO BEFORE THE STABLE RELEASE:
54  *
55  *  fgChooseVisual()        -- OK, but what about glutInitDisplayString()?
56  *  fgSetupPixelFormat      -- ignores the display mode settings
57  *  fgOpenWindow()          -- check the Win32 version, -iconic handling!
58  *  fgCloseWindow()         -- check the Win32 version
59  *  glutCreateWindow()      -- Check when default position and size is {-1,-1}
60  *  glutCreateSubWindow()   -- Check when default position and size is {-1,-1}
61  *  glutDestroyWindow()     -- check the Win32 version
62  *  glutSetWindow()         -- check the Win32 version
63  *  glutGetWindow()         -- OK
64  *  glutSetWindowTitle()    -- check the Win32 version
65  *  glutSetIconTitle()      -- check the Win32 version
66  *  glutShowWindow()        -- check the Win32 version
67  *  glutHideWindow()        -- check the Win32 version
68  *  glutIconifyWindow()     -- check the Win32 version
69  *  glutReshapeWindow()     -- check the Win32 version
70  *  glutPositionWindow()    -- check the Win32 version
71  *  glutPushWindow()        -- check the Win32 version
72  *  glutPopWindow()         -- check the Win32 version
73  */
74
75 /* -- PRIVATE FUNCTIONS ---------------------------------------------------- */
76
77 /*
78  * Chooses a visual basing on the current display mode settings
79  */
80 #if TARGET_HOST_UNIX_X11
81
82 XVisualInfo* fgChooseVisual( void )
83 {
84 #define BUFFER_SIZES 6
85     int bufferSize[BUFFER_SIZES] = { 16, 12, 8, 4, 2, 1 };
86     GLboolean wantIndexedMode = GL_FALSE;
87     int attributes[ 32 ];
88     int where = 0;
89
90     /*
91      * First we have to process the display mode settings...
92      */
93 /*
94  * Why is there a semi-colon in this #define?  The code
95  * that uses the macro seems to always add more semicolons...
96  */
97 #define ATTRIB(a) attributes[where++]=a;
98 #define ATTRIB_VAL(a,v) {ATTRIB(a); ATTRIB(v);}
99
100     if( fgState.DisplayMode & GLUT_INDEX )
101     {
102         ATTRIB_VAL( GLX_BUFFER_SIZE, 8 );
103         wantIndexedMode = GL_TRUE;
104     }
105     else
106     {
107         ATTRIB( GLX_RGBA );
108         ATTRIB_VAL( GLX_RED_SIZE,   1 );
109         ATTRIB_VAL( GLX_GREEN_SIZE, 1 );
110         ATTRIB_VAL( GLX_BLUE_SIZE,  1 );
111         if( fgState.DisplayMode & GLUT_ALPHA )
112             ATTRIB_VAL( GLX_ALPHA_SIZE, 1 );
113     }
114
115     if( fgState.DisplayMode & GLUT_DOUBLE )
116         ATTRIB( GLX_DOUBLEBUFFER );
117
118     if( fgState.DisplayMode & GLUT_STEREO )
119         ATTRIB( GLX_STEREO );
120
121     if( fgState.DisplayMode & GLUT_DEPTH )
122         ATTRIB_VAL( GLX_DEPTH_SIZE, 1 );
123
124     if( fgState.DisplayMode & GLUT_STENCIL )
125         ATTRIB_VAL( GLX_STENCIL_SIZE, 1 );
126
127     if( fgState.DisplayMode & GLUT_ACCUM )
128     {
129         ATTRIB_VAL( GLX_ACCUM_RED_SIZE,   1 );
130         ATTRIB_VAL( GLX_ACCUM_GREEN_SIZE, 1 );
131         ATTRIB_VAL( GLX_ACCUM_BLUE_SIZE,  1 );
132         if( fgState.DisplayMode & GLUT_ALPHA )
133             ATTRIB_VAL( GLX_ACCUM_ALPHA_SIZE, 1 );
134     }
135
136     /*
137      * Push a null at the end of the list
138      */
139     ATTRIB( None );
140
141     if( ! wantIndexedMode )
142         return glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
143                                 attributes );
144     else
145     {
146         XVisualInfo* visualInfo;
147         int i;
148
149         /*
150          * In indexed mode, we need to check how many bits of depth can we
151          * achieve.  We do this by trying each possibility from the list
152          * given in the {bufferSize} array.  If we match, we return to caller.
153          */
154         for( i=0; i<BUFFER_SIZES; i++ )
155         {
156             attributes[ 1 ] = bufferSize[ i ];
157             visualInfo = glXChooseVisual( fgDisplay.Display, fgDisplay.Screen,
158                                           attributes );
159             if( visualInfo != NULL )
160                 return visualInfo;
161         }
162         return NULL;
163     }
164 }
165 #endif
166
167 /*
168  * Setup the pixel format for a Win32 window
169  */
170 #if TARGET_HOST_WIN32
171 GLboolean fgSetupPixelFormat( SFG_Window* window, GLboolean checkOnly,
172                               unsigned char layer_type )
173 {
174 #if TARGET_HOST_WINCE
175     return GL_TRUE;
176 #else
177     PIXELFORMATDESCRIPTOR* ppfd, pfd;
178     int flags, pixelformat;
179
180     freeglut_return_val_if_fail( window != NULL, 0 );
181     flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
182     if( fgState.DisplayMode & GLUT_DOUBLE )
183         flags |= PFD_DOUBLEBUFFER;
184
185 #if defined(_MSC_VER)
186 #pragma message( "fgSetupPixelFormat(): there is still some work to do here!" )
187 #endif
188
189     /*
190      * Specify which pixel format do we opt for...
191      */
192     pfd.nSize           = sizeof(PIXELFORMATDESCRIPTOR);
193     pfd.nVersion        = 1;
194     pfd.dwFlags         = flags;
195     pfd.iPixelType      = PFD_TYPE_RGBA;
196     pfd.cColorBits      = 24;
197     pfd.cRedBits        = 0;
198     pfd.cRedShift       = 0;
199     pfd.cGreenBits      = 0;
200     pfd.cGreenShift     = 0;
201     pfd.cBlueBits       = 0;
202     pfd.cBlueShift      = 0;
203     pfd.cAlphaBits      = 0;
204     pfd.cAlphaShift     = 0;
205     pfd.cAccumBits      = 0;
206     pfd.cAccumRedBits   = 0;
207     pfd.cAccumGreenBits = 0;
208     pfd.cAccumBlueBits  = 0;
209     pfd.cAccumAlphaBits = 0;
210 #if 0
211     pfd.cDepthBits      = 32;
212     pfd.cStencilBits    = 0;
213 #else
214     pfd.cDepthBits      = 24;
215     pfd.cStencilBits    = 8;
216 #endif
217     pfd.cAuxBuffers     = 0;
218     pfd.iLayerType      = layer_type;
219     pfd.bReserved       = 0;
220     pfd.dwLayerMask     = 0;
221     pfd.dwVisibleMask   = 0;
222     pfd.dwDamageMask    = 0;
223
224     pfd.cColorBits = (BYTE) GetDeviceCaps( window->Window.Device, BITSPIXEL );
225     ppfd = &pfd;
226
227     pixelformat = ChoosePixelFormat( window->Window.Device, ppfd );
228     if( pixelformat == 0 )
229         return GL_FALSE;
230
231     if( checkOnly )
232         return GL_TRUE;
233     return SetPixelFormat( window->Window.Device, pixelformat, ppfd );
234 #endif /* TARGET_HOST_WINCE */
235 }
236 #endif
237
238 /*
239  * Sets the OpenGL context and the fgStructure "Current Window" pointer to
240  * the window structure passed in.
241  */
242 void fgSetWindow ( SFG_Window *window )
243 {
244 #if TARGET_HOST_UNIX_X11
245     if ( window )
246         glXMakeCurrent(
247             fgDisplay.Display,
248             window->Window.Handle,
249             window->Window.Context
250         );
251 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
252     if( fgStructure.Window )
253         ReleaseDC( fgStructure.Window->Window.Handle,
254                    fgStructure.Window->Window.Device );
255
256     if ( window )
257     {
258         window->Window.Device = GetDC( window->Window.Handle );
259         wglMakeCurrent(
260             window->Window.Device,
261             window->Window.Context
262         );
263     }
264 #endif
265     fgStructure.Window = window;
266 }
267
268
269 /*
270  * Opens a window. Requires a SFG_Window object created and attached
271  * to the freeglut structure. OpenGL context is created here.
272  */
273 void fgOpenWindow( SFG_Window* window, const char* title,
274                    int x, int y, int w, int h,
275                    GLboolean gameMode, GLboolean isSubWindow )
276 {
277 #if TARGET_HOST_UNIX_X11
278     XSetWindowAttributes winAttr;
279     XTextProperty textProperty;
280     XSizeHints sizeHints;
281     XWMHints wmHints;
282     unsigned long mask;
283
284     freeglut_assert_ready;
285
286     /*
287      * XXX fgChooseVisual() is a common part of all three.
288      * XXX With a little thought, we should be able to greatly
289      * XXX simplify this.
290      */
291     if( !window->IsMenu )
292         window->Window.VisualInfo = fgChooseVisual( );
293     else if( fgStructure.MenuContext )
294         window->Window.VisualInfo = fgChooseVisual( );
295     else
296     {
297         /* XXX Why are menus double- and depth-buffered? */
298         unsigned int current_DisplayMode = fgState.DisplayMode ;
299         fgState.DisplayMode = GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH ;
300         window->Window.VisualInfo = fgChooseVisual( );
301         fgState.DisplayMode = current_DisplayMode ;
302     }
303
304     if( ! window->Window.VisualInfo )
305     {
306         /*
307          * The "fgChooseVisual" returned a null meaning that the visual
308          * context is not available.
309          * Try a couple of variations to see if they will work.
310          */
311         if( !( fgState.DisplayMode & GLUT_DOUBLE ) )
312         {
313             fgState.DisplayMode |= GLUT_DOUBLE ;
314             window->Window.VisualInfo = fgChooseVisual( );
315             fgState.DisplayMode &= ~GLUT_DOUBLE;
316         }
317
318         /*
319          * GLUT also checks for multi-sampling, but I don't see that
320          * anywhere else in FREEGLUT so I won't bother with it for the moment.
321          */
322     }
323
324     /*
325      * XXX This seems to be abusing an assert() for error-checking.
326      * XXX It is possible that the visual simply can't be found,
327      * XXX in which case we should print an error and return a 0
328      * XXX for the window id, I think.
329      */
330     assert( window->Window.VisualInfo != NULL );
331
332
333     /*
334      * XXX HINT: the masks should be updated when adding/removing callbacks.
335      * XXX       This might speed up message processing. Is that true?
336      * XXX
337      * XXX A: Not appreciably, but it WILL make it easier to debug.
338      * XXX    Try tracing old GLUT and try tracing freeglut.  Old GLUT
339      * XXX    turns off events that it doesn't need and is a whole lot
340      * XXX    more pleasant to trace.  (Think mouse-motion!  Tons of
341      * XXX    ``bonus'' GUI events stream in.)
342      */
343     winAttr.event_mask        =
344         StructureNotifyMask | SubstructureNotifyMask | ExposureMask |
345         ButtonPressMask | ButtonReleaseMask | KeyPressMask | KeyRelease |
346         VisibilityChangeMask | EnterWindowMask | LeaveWindowMask |
347         PointerMotionMask | ButtonMotionMask;
348     winAttr.background_pixmap = None;
349     winAttr.background_pixel  = 0;
350     winAttr.border_pixel      = 0;
351
352     winAttr.colormap = XCreateColormap(
353         fgDisplay.Display, fgDisplay.RootWindow,
354         window->Window.VisualInfo->visual, AllocNone
355     );
356
357     mask = CWBackPixmap | CWBorderPixel | CWColormap | CWEventMask;
358
359     if( window->IsMenu )
360     {
361         winAttr.override_redirect = True;
362         mask |= CWOverrideRedirect;
363     }
364
365     window->Window.Handle = XCreateWindow(
366         fgDisplay.Display,
367         window->Parent == NULL ? fgDisplay.RootWindow :
368         window->Parent->Window.Handle,
369         x, y, w, h, 0,
370         window->Window.VisualInfo->depth, InputOutput,
371         window->Window.VisualInfo->visual, mask,
372         &winAttr
373     );
374
375     /*
376      * The GLX context creation, possibly trying the direct context rendering
377      *  or else use the current context if the user has so specified
378      */
379     if( window->IsMenu )
380     {
381         /*
382          * If there isn't already an OpenGL rendering context for menu
383          * windows, make one
384          */
385         if( !fgStructure.MenuContext )
386         {
387             fgStructure.MenuContext =
388                 (SFG_MenuContext *)malloc( sizeof(SFG_MenuContext) );
389             fgStructure.MenuContext->VisualInfo = window->Window.VisualInfo;
390             fgStructure.MenuContext->Context = glXCreateContext(
391                 fgDisplay.Display, fgStructure.MenuContext->VisualInfo,
392                 NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT )
393             );
394         }
395
396         /* window->Window.Context = fgStructure.MenuContext->Context; */
397         window->Window.Context = glXCreateContext(
398             fgDisplay.Display, window->Window.VisualInfo,
399             NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT )
400         );
401     }
402     else if( fgState.UseCurrentContext )
403     {
404         window->Window.Context = glXGetCurrentContext( );
405
406         if( ! window->Window.Context )
407             window->Window.Context = glXCreateContext(
408                 fgDisplay.Display, window->Window.VisualInfo,
409                 NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT )
410             );
411     }
412     else
413         window->Window.Context = glXCreateContext(
414             fgDisplay.Display, window->Window.VisualInfo,
415             NULL, ( fgState.DirectContext != GLUT_FORCE_INDIRECT_CONTEXT )
416         );
417
418     if(  !glXIsDirect( fgDisplay.Display, window->Window.Context ) )
419     {
420       if( fgState.DirectContext == GLUT_FORCE_DIRECT_CONTEXT )
421         fgError( "Unable to force direct context rendering for window '%s'",
422                  title );
423       else if( fgState.DirectContext == GLUT_TRY_DIRECT_CONTEXT )
424         fgWarning( "Unable to create direct context rendering for window '%s'\nThis may hurt performance.",
425                  title );
426     }
427
428     glXMakeCurrent(
429         fgDisplay.Display,
430         window->Window.Handle,
431         window->Window.Context
432     );
433
434     /*
435      * XXX Assume the new window is visible by default
436      * XXX Is this a  safe assumption?
437      */
438     window->State.Visible = GL_TRUE;
439
440     sizeHints.flags = 0;
441     if ( fgState.Position.Use )
442         sizeHints.flags |= USPosition;
443     if ( fgState.Size.Use )
444         sizeHints.flags |= USSize;
445
446     /*
447      * Fill in the size hints values now (the x, y, width and height
448      * settings are obsolote, are there any more WMs that support them?)
449      * Unless the X servers actually stop supporting these, we should
450      * continue to fill them in.  It is *not* our place to tell the user
451      * that they should replace a window manager that they like, and which
452      * works, just because *we* think that it's not "modern" enough.
453      */
454 #if TARGET_HOST_WINCE
455     sizeHints.x      = 0;
456     sizeHints.y      = 0;
457     sizeHints.width  = 320;
458     sizeHints.height = 240;
459 #else
460     sizeHints.x      = x;
461     sizeHints.y      = y;
462     sizeHints.width  = w;
463     sizeHints.height = h;
464 #endif /* TARGET_HOST_WINCE */
465
466     wmHints.flags = StateHint;
467     wmHints.initial_state = fgState.ForceIconic ? IconicState : NormalState;
468     /*
469      * Prepare the window and iconified window names...
470      */
471     XStringListToTextProperty( (char **) &title, 1, &textProperty );
472
473     XSetWMProperties(
474         fgDisplay.Display,
475         window->Window.Handle,
476         &textProperty,
477         &textProperty,
478         0,
479         0,
480         &sizeHints,
481         &wmHints,
482         NULL
483     );
484
485     XSetWMProtocols( fgDisplay.Display, window->Window.Handle,
486                      &fgDisplay.DeleteWindow, 1 );
487
488     XMapWindow( fgDisplay.Display, window->Window.Handle );
489
490 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
491
492     WNDCLASS wc;
493     DWORD flags;
494     DWORD exFlags = 0;
495     ATOM atom;
496
497     freeglut_assert_ready;
498
499     /*
500      * Grab the window class we have registered on glutInit():
501      */
502     atom = GetClassInfo( fgDisplay.Instance, _T("FREEGLUT"), &wc );
503     assert( atom != 0 );
504
505     if( gameMode )
506     {
507         assert( window->Parent == NULL );
508
509         /*
510          * Set the window creation flags appropriately to make the window
511          * entirely visible:
512          */
513         flags = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
514     }
515     else
516     {
517 #if !TARGET_HOST_WINCE
518         if ( ( ! isSubWindow ) && ( ! window->IsMenu ) )
519         {
520             /*
521              * Update the window dimensions, taking account of window
522              * decorations.  "freeglut" is to create the window with the
523              * outside of its border at (x,y) and with dimensions (w,h).
524              */
525             w += (GetSystemMetrics( SM_CXSIZEFRAME ) )*2;
526             h += (GetSystemMetrics( SM_CYSIZEFRAME ) )*2 +
527                 GetSystemMetrics( SM_CYCAPTION );
528         }
529 #endif /* TARGET_HOST_WINCE */
530
531         if( ! fgState.Position.Use )
532         {
533             x = CW_USEDEFAULT;
534             y = CW_USEDEFAULT;
535         }
536         if( ! fgState.Size.Use )
537         {
538             w = CW_USEDEFAULT;
539             h = CW_USEDEFAULT;
540         }
541
542         /*
543          * There's a small difference between creating the top, child and
544          * game mode windows
545          */
546         flags = WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE;
547
548         if ( window->IsMenu )
549         {
550             flags |= WS_POPUP;
551             exFlags |= WS_EX_TOOLWINDOW;
552         }
553 #if !TARGET_HOST_WINCE
554         else if( window->Parent == NULL )
555             flags |= WS_OVERLAPPEDWINDOW;
556 #endif
557         else
558             flags |= WS_CHILD;
559     }
560
561 #if TARGET_HOST_WINCE
562     {
563         wchar_t* wstr = wstr_from_str(title);
564
565         window->Window.Handle = CreateWindow(
566             _T("FREEGLUT"),
567             wstr,
568             WS_VISIBLE | WS_POPUP,
569             0,0, 240,320,
570             NULL,
571             NULL,
572             fgDisplay.Instance,
573             (LPVOID) window
574         );
575
576         free(wstr);
577
578         SHFullScreen(window->Window.Handle, SHFS_HIDESTARTICON);
579         SHFullScreen(window->Window.Handle, SHFS_HIDESIPBUTTON);
580         SHFullScreen(window->Window.Handle, SHFS_HIDETASKBAR);
581         MoveWindow(window->Window.Handle, 0, 0, 240, 320, TRUE);
582         ShowWindow(window->Window.Handle, SW_SHOW);
583         UpdateWindow(window->Window.Handle);
584     }
585 #else
586     window->Window.Handle = CreateWindowEx(
587         exFlags,
588         "FREEGLUT",
589         title,
590         flags,
591         x, y, w, h,
592         (HWND) window->Parent == NULL ? NULL : window->Parent->Window.Handle,
593         (HMENU) NULL,
594         fgDisplay.Instance,
595         (LPVOID) window
596     );
597 #endif /* TARGET_HOST_WINCE */
598
599     if( !( window->Window.Handle ) )
600         fgError( "Failed to create a window (%s)!", title );
601
602 #if TARGET_HOST_WINCE
603     ShowWindow( window->Window.Handle, SW_SHOW );
604 #else
605     ShowWindow( window->Window.Handle,
606                 fgState.ForceIconic ? SW_SHOWMINIMIZED : SW_SHOW );
607 #endif /* TARGET_HOST_WINCE */
608
609     UpdateWindow( window->Window.Handle );
610     ShowCursor( TRUE );  /* XXX Old comments say "hide cusror"! */
611
612 #endif
613
614     fgSetWindow( window );
615
616     window->Window.DoubleBuffered =
617         ( fgState.DisplayMode & GLUT_DOUBLE ) ? 1 : 0;
618
619     if ( ! window->Window.DoubleBuffered )
620     {
621         glDrawBuffer ( GL_FRONT );
622         glReadBuffer ( GL_FRONT );
623     }
624 }
625
626 /*
627  * Closes a window, destroying the frame and OpenGL context
628  */
629 void fgCloseWindow( SFG_Window* window )
630 {
631     freeglut_assert_ready;
632
633 #if TARGET_HOST_UNIX_X11
634
635     glXDestroyContext( fgDisplay.Display, window->Window.Context );
636     XDestroyWindow( fgDisplay.Display, window->Window.Handle );
637     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
638
639 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
640
641     /*
642      * Make sure we don't close a window with current context active
643      */
644     if( fgStructure.Window == window )
645         wglMakeCurrent( NULL, NULL );
646
647     /*
648      * Step through the list of windows.  If the rendering context
649      * is not being used by another window, then we delete it.
650      */
651     {
652         int used = FALSE ;
653         SFG_Window *iter ;
654
655         for( iter = (SFG_Window *)fgStructure.Windows.First;
656              iter;
657              iter = (SFG_Window *)iter->Node.Next )
658         {
659             if( ( iter->Window.Context == window->Window.Context ) &&
660                 ( iter != window ) )
661                 used = TRUE;
662         }
663
664         if( ! used )
665             wglDeleteContext( window->Window.Context );
666     }
667
668     DestroyWindow( window->Window.Handle );
669 #endif
670 }
671
672
673 /* -- INTERFACE FUNCTIONS -------------------------------------------------- */
674
675 /*
676  * Creates a new top-level freeglut window
677  */
678 int FGAPIENTRY glutCreateWindow( const char* title )
679 {
680     return fgCreateWindow( NULL, title, fgState.Position.X, fgState.Position.Y,
681                            fgState.Size.X, fgState.Size.Y, GL_FALSE,
682                            GL_FALSE )->ID;
683 }
684
685 /*
686  * This function creates a sub window.
687  */
688 int FGAPIENTRY glutCreateSubWindow( int parentID, int x, int y, int w, int h )
689 {
690     int ret = 0;
691
692     SFG_Window* window = NULL;
693     SFG_Window* parent = NULL;
694
695     freeglut_assert_ready;
696     parent = fgWindowByID( parentID );
697     freeglut_return_val_if_fail( parent != NULL, 0 );
698     window = fgCreateWindow( parent, "", x, y, w, h, GL_FALSE, GL_FALSE );
699     ret = window->ID;
700
701     return ret;
702 }
703
704 /*
705  * Destroys a window and all of its subwindows
706  */
707 void FGAPIENTRY glutDestroyWindow( int windowID )
708 {
709     SFG_Window* window = fgWindowByID( windowID );
710     freeglut_return_if_fail( window != NULL );
711     {
712         fgExecutionState ExecState = fgState.ExecState;
713         fgAddToWindowDestroyList( window );
714         fgState.ExecState = ExecState;
715     }
716 }
717
718 /*
719  * This function selects the current window
720  */
721 void FGAPIENTRY glutSetWindow( int ID )
722 {
723     SFG_Window* window = NULL;
724
725     freeglut_assert_ready;
726     if( fgStructure.Window != NULL )
727         if( fgStructure.Window->ID == ID )
728             return;
729
730     window = fgWindowByID( ID );
731     if( window == NULL )
732     {
733         fgWarning( "glutSetWindow(): window ID %i not found!", ID );
734         return;
735     }
736
737     fgSetWindow( window );
738 }
739
740 /*
741  * This function returns the ID number of the current window, 0 if none exists
742  */
743 int FGAPIENTRY glutGetWindow( void )
744 {
745     freeglut_assert_ready;
746     if( fgStructure.Window == NULL )
747         return 0;
748     return fgStructure.Window->ID;
749 }
750
751 /*
752  * This function makes the current window visible
753  */
754 void FGAPIENTRY glutShowWindow( void )
755 {
756     freeglut_assert_ready;
757     freeglut_assert_window;
758
759 #if TARGET_HOST_UNIX_X11
760
761     XMapWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
762     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
763
764 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
765
766     ShowWindow( fgStructure.Window->Window.Handle, SW_SHOW );
767
768 #endif
769
770     fgStructure.Window->State.Redisplay = GL_TRUE;
771 }
772
773 /*
774  * This function hides the current window
775  */
776 void FGAPIENTRY glutHideWindow( void )
777 {
778     freeglut_assert_ready;
779     freeglut_assert_window;
780
781 #if TARGET_HOST_UNIX_X11
782
783     if( fgStructure.Window->Parent == NULL )
784         XWithdrawWindow( fgDisplay.Display,
785                          fgStructure.Window->Window.Handle,
786                          fgDisplay.Screen );
787     else
788         XUnmapWindow( fgDisplay.Display,
789                       fgStructure.Window->Window.Handle );
790     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
791
792 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
793
794     ShowWindow( fgStructure.Window->Window.Handle, SW_HIDE );
795
796 #endif
797
798     fgStructure.Window->State.Redisplay = GL_FALSE;
799 }
800
801 /*
802  * Iconify the current window (top-level windows only)
803  */
804 void FGAPIENTRY glutIconifyWindow( void )
805 {
806     freeglut_assert_ready;
807     freeglut_assert_window;
808
809     fgStructure.Window->State.Visible   = GL_FALSE;
810 #if TARGET_HOST_UNIX_X11
811
812     XIconifyWindow( fgDisplay.Display, fgStructure.Window->Window.Handle,
813                     fgDisplay.Screen );
814     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
815
816 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
817
818     ShowWindow( fgStructure.Window->Window.Handle, SW_MINIMIZE );
819
820 #endif
821
822     fgStructure.Window->State.Redisplay = GL_FALSE;
823 }
824
825 /*
826  * Set the current window's title
827  */
828 void FGAPIENTRY glutSetWindowTitle( const char* title )
829 {
830     freeglut_assert_ready;
831     freeglut_assert_window;
832     if( ! fgStructure.Window->Parent )
833     {
834 #if TARGET_HOST_UNIX_X11
835
836         XTextProperty text;
837
838         text.value = (unsigned char *) title;
839         text.encoding = XA_STRING;
840         text.format = 8;
841         text.nitems = strlen( title );
842
843         XSetWMName(
844             fgDisplay.Display,
845             fgStructure.Window->Window.Handle,
846             &text
847         );
848
849         XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
850
851 #elif TARGET_HOST_WIN32
852
853         SetWindowText( fgStructure.Window->Window.Handle, title );
854
855 #elif TARGET_HOST_WINCE
856         {
857             wchar_t* wstr = wstr_from_str(title);
858
859             SetWindowText( fgStructure.Window->Window.Handle, wstr );
860
861             free(wstr);
862         }
863 #endif
864     }
865 }
866
867 /*
868  * Set the current window's iconified title
869  */
870 void FGAPIENTRY glutSetIconTitle( const char* title )
871 {
872     freeglut_assert_ready;
873     freeglut_assert_window;
874
875     if( ! fgStructure.Window->Parent )
876     {
877 #if TARGET_HOST_UNIX_X11
878
879         XTextProperty text;
880
881         text.value = (unsigned char *) title;
882         text.encoding = XA_STRING;
883         text.format = 8;
884         text.nitems = strlen( title );
885
886         XSetWMIconName(
887             fgDisplay.Display,
888             fgStructure.Window->Window.Handle,
889             &text
890         );
891
892         XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
893
894 #elif TARGET_HOST_WIN32
895
896         SetWindowText( fgStructure.Window->Window.Handle, title );
897
898 #elif TARGET_HOST_WINCE
899         {
900             wchar_t* wstr = wstr_from_str(title);
901
902             SetWindowText( fgStructure.Window->Window.Handle, wstr );
903
904             free(wstr);
905         }
906 #endif
907     }
908 }
909
910 /*
911  * Change the current window's size
912  */
913 void FGAPIENTRY glutReshapeWindow( int width, int height )
914 {
915     freeglut_assert_ready;
916     freeglut_assert_window;
917
918     fgStructure.Window->State.NeedToResize = GL_TRUE;
919     fgStructure.Window->State.Width  = width ;
920     fgStructure.Window->State.Height = height;
921 }
922
923 /*
924  * Change the current window's position
925  */
926 void FGAPIENTRY glutPositionWindow( int x, int y )
927 {
928     freeglut_assert_ready;
929     freeglut_assert_window;
930
931 #if TARGET_HOST_UNIX_X11
932
933     XMoveWindow( fgDisplay.Display, fgStructure.Window->Window.Handle,
934                  x, y );
935     XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
936
937 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
938
939     {
940         RECT winRect;
941
942         GetWindowRect( fgStructure.Window->Window.Handle, &winRect );
943         MoveWindow(
944             fgStructure.Window->Window.Handle,
945             x,
946             y,
947             winRect.right - winRect.left,
948             winRect.bottom - winRect.top,
949             TRUE
950         );
951     }
952
953 #endif
954 }
955
956 /*
957  * Lowers the current window (by Z order change)
958  */
959 void FGAPIENTRY glutPushWindow( void )
960 {
961     freeglut_assert_ready;
962     freeglut_assert_window;
963
964 #if TARGET_HOST_UNIX_X11
965
966     XLowerWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
967
968 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
969
970     SetWindowPos(
971         fgStructure.Window->Window.Handle,
972         HWND_BOTTOM,
973         0, 0, 0, 0,
974         SWP_NOSIZE | SWP_NOMOVE
975     );
976
977 #endif
978 }
979
980 /*
981  * Raises the current window (by Z order change)
982  */
983 void FGAPIENTRY glutPopWindow( void )
984 {
985     freeglut_assert_ready;
986     freeglut_assert_window;
987
988 #if TARGET_HOST_UNIX_X11
989
990     XRaiseWindow( fgDisplay.Display, fgStructure.Window->Window.Handle );
991
992 #elif TARGET_HOST_WIN32 || TARGET_HOST_WINCE
993
994     SetWindowPos(
995         fgStructure.Window->Window.Handle,
996         HWND_TOP,
997         0, 0, 0, 0,
998         SWP_NOSIZE | SWP_NOMOVE
999     );
1000
1001 #endif
1002 }
1003
1004 /*
1005  * Resize the current window so that it fits the whole screen
1006  */
1007 void FGAPIENTRY glutFullScreen( void )
1008 {
1009     freeglut_assert_ready;
1010     freeglut_assert_window;
1011
1012     {
1013 #if TARGET_HOST_UNIX_X11
1014         int x, y;
1015         Window w;
1016
1017         XMoveResizeWindow(
1018             fgDisplay.Display,
1019             fgStructure.Window->Window.Handle,
1020             0, 0,
1021             fgDisplay.ScreenWidth,
1022             fgDisplay.ScreenHeight
1023         );
1024
1025         XFlush( fgDisplay.Display ); /* This is needed */
1026
1027         XTranslateCoordinates(
1028             fgDisplay.Display,
1029             fgStructure.Window->Window.Handle,
1030             fgDisplay.RootWindow,
1031             0, 0, &x, &y, &w
1032         );
1033
1034         if (x || y)
1035         {
1036             XMoveWindow(
1037                 fgDisplay.Display,
1038                 fgStructure.Window->Window.Handle,
1039                 -x, -y
1040             );
1041             XFlush( fgDisplay.Display ); /* XXX Shouldn't need this */
1042         }
1043 #elif TARGET_HOST_WIN32
1044         RECT rect;
1045
1046         /* For fullscreen mode, force the top-left corner to 0,0
1047          * and adjust the window rectangle so that the client area
1048          * covers the whole screen.
1049          */
1050
1051         rect.left   = 0;
1052         rect.top    = 0;
1053         rect.right  = fgDisplay.ScreenWidth;
1054         rect.bottom = fgDisplay.ScreenHeight;
1055
1056         AdjustWindowRect ( &rect, WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS |
1057                                   WS_CLIPCHILDREN, FALSE );
1058
1059         /*
1060          * SWP_NOACTIVATE     Do not activate the window
1061          * SWP_NOOWNERZORDER  Do not change position in z-order
1062          * SWP_NOSENDCHANGING Supress WM_WINDOWPOSCHANGING message
1063          * SWP_NOZORDER       Retains the current Z order (ignore 2nd param)
1064          */
1065
1066         SetWindowPos( fgStructure.Window->Window.Handle,
1067                       HWND_TOP,
1068                       rect.left,
1069                       rect.top,
1070                       rect.right  - rect.left,
1071                       rect.bottom - rect.top,
1072                       SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSENDCHANGING |
1073                       SWP_NOZORDER
1074                     );
1075 #endif
1076     }
1077 }
1078
1079 /*
1080  * A.Donev: Set and retrieve the window's user data
1081  */
1082 void* FGAPIENTRY glutGetWindowData( void )
1083 {
1084     return fgStructure.Window->UserData;
1085 }
1086
1087 void FGAPIENTRY glutSetWindowData(void* data)
1088 {
1089     fgStructure.Window->UserData = data;
1090 }
1091
1092 /*** END OF FILE ***/