21c456fd51c8d4ee26d5b0deb296ba64b0f2640d
[blender-staging.git] / source / blender / windowmanager / intern / wm_window.c
1 /**
2  * $Id: wm_window.c
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. 
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2007 Blender Foundation but based 
21  * on ghostwinlay.c (C) 2001-2002 by NaN Holding BV
22  * All rights reserved.
23  *
24  * Contributor(s): Blender Foundation
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 #include <stdlib.h>
30 #include <stdio.h>
31
32 #include "DNA_listBase.h"       
33 #include "DNA_screen_types.h"
34 #include "DNA_windowmanager_types.h"
35
36 #include "MEM_guardedalloc.h"
37
38 #include "GHOST_C-api.h"
39
40 #include "BLI_blenlib.h"
41
42 #include "BKE_blender.h"
43 #include "BKE_global.h"
44 #include "BKE_utildefines.h"
45
46 #include "BIF_gl.h"
47
48 #include "WM_api.h"
49 #include "WM_types.h"
50 #include "wm.h"
51 #include "wm_window.h"
52 #include "wm_subwindow.h"
53 #include "wm_event_system.h"
54
55 #include "ED_screen.h"
56
57 /* the global to talk to ghost */
58 GHOST_SystemHandle g_system= NULL;
59
60 /* set by commandline */
61 static int prefsizx= 0, prefsizy= 0, prefstax= 0, prefstay= 0;
62
63
64 /* ******** win open & close ************ */
65
66
67 static void wm_get_screensize(int *width_r, int *height_r) 
68 {
69         unsigned int uiwidth;
70         unsigned int uiheight;
71         
72         GHOST_GetMainDisplayDimensions(g_system, &uiwidth, &uiheight);
73         *width_r= uiwidth;
74         *height_r= uiheight;
75 }
76
77 static void wm_ghostwindow_destroy(wmWindow *win) 
78 {
79         
80         if (win->timer) {
81                 GHOST_RemoveTimer(g_system, (GHOST_TimerTaskHandle)win->timer);
82                 win->timer= NULL;
83         }
84         
85         if(win->ghostwin) {
86                 GHOST_DisposeWindow(g_system, win->ghostwin);
87                 win->ghostwin= NULL;
88         }
89 }
90
91 /* including window itself */
92 void wm_window_free(bContext *C, wmWindow *win)
93 {
94         
95         /* update context */
96         if(C) {
97                 if(C->wm->windrawable==win)
98                         C->wm->windrawable= NULL;
99                 if(C->wm->winactive==win)
100                         C->wm->winactive= NULL;
101                 if(C->window==win)
102                         C->window= NULL;
103                 if(C->screen==win->screen)
104                         C->screen= NULL;
105         }       
106         /* XXX free screens */
107         
108         if(win->eventstate) MEM_freeN(win->eventstate);
109         
110         wm_event_free_handlers(&win->handlers);
111         wm_event_free_all(win);
112         wm_subwindows_free(win);
113         
114         wm_ghostwindow_destroy(win);
115         
116         MEM_freeN(win);
117 }
118
119 static int find_free_winid(wmWindowManager *wm)
120 {
121         wmWindow *win;
122         int id= 0;
123         
124         for(win= wm->windows.first; win; win= win->next)
125                 if(id <= win->winid)
126                         id= win->winid+1;
127         
128         return id;
129 }
130
131 /* dont change context itself */
132 wmWindow *wm_window_new(bContext *C, bScreen *screen)
133 {
134         wmWindow *win= MEM_callocN(sizeof(wmWindow), "window");
135         
136         BLI_addtail(&C->wm->windows, win);
137         win->winid= find_free_winid(C->wm);
138
139         win->screen= screen;
140         return win;
141 }
142
143 /* part of wm_window.c api */
144 wmWindow *wm_window_copy(bContext *C, wmWindow *winorig)
145 {
146         wmWindow *win= wm_window_new(C, winorig->screen);
147         
148         win->posx= winorig->posx+10;
149         win->posy= winorig->posy;
150         win->sizex= winorig->sizex;
151         win->sizey= winorig->sizey;
152         
153         win->screen= ED_screen_duplicate(win, win->screen);
154         win->screen->do_refresh= 1;
155         win->screen->do_draw= 1;
156         
157         return win;
158 }
159
160 /* operator callback */
161 int wm_window_duplicate_op(bContext *C, wmOperator *op)
162 {
163         
164         wm_window_copy(C, C->window);
165         wm_check(C);
166         
167         return 1;
168 }
169
170 /* fullscreen operator callback */
171 int wm_window_fullscreen_toggle_op(bContext *C, wmOperator *op)
172 {
173         GHOST_TWindowState state = GHOST_GetWindowState(C->window->ghostwin);
174         if(state!=GHOST_kWindowStateFullScreen)
175                 GHOST_SetWindowState(C->window->ghostwin, GHOST_kWindowStateFullScreen);
176         else
177                 GHOST_SetWindowState(C->window->ghostwin, GHOST_kWindowStateNormal);
178
179         return 1;
180         
181 }
182
183 /* this is event from ghost */
184 static void wm_window_close(bContext *C, wmWindow *win)
185 {
186         BLI_remlink(&C->wm->windows, win);
187         wm_window_free(C, win);
188         
189         if(C->wm->windows.first==NULL)
190                 WM_exit(C);
191 }
192         
193 static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
194 {
195         GHOST_WindowHandle ghostwin;
196         GHOST_TWindowState inital_state;
197         int scr_w, scr_h, posy;
198         
199         wm_get_screensize(&scr_w, &scr_h);
200         posy= (scr_h - win->posy - win->sizey);
201         
202 //              inital_state = GHOST_kWindowStateFullScreen;
203 //              inital_state = GHOST_kWindowStateMaximized;
204                 inital_state = GHOST_kWindowStateNormal;
205
206 #ifdef __APPLE__
207         {
208                 extern int macPrefState; /* creator.c */
209                 inital_state += macPrefState;
210         }
211 #endif
212         
213         ghostwin= GHOST_CreateWindow(g_system, title, 
214                                                                  win->posx, posy, win->sizex, win->sizey, 
215                                                                  inital_state, 
216                                                                  GHOST_kDrawingContextTypeOpenGL,
217                                                                  0 /* no stereo */);
218         
219         if (ghostwin) {
220
221                 win->ghostwin= ghostwin;
222                 GHOST_SetWindowUserData(ghostwin, win); /* pointer back */
223                 
224                 if(win->eventstate==NULL)
225                         win->eventstate= MEM_callocN(sizeof(wmEvent), "window event state");
226                 
227                 /* add keymap handlers (1 for all keys in map!) */
228                 WM_event_add_keymap_handler(&wm->windowkeymap, &win->handlers);
229                 WM_event_add_keymap_handler(&wm->screenkeymap, &win->handlers);
230                 
231                 /* until screens get drawn, make it nice grey */
232                 glClearColor(.55, .55, .55, 0.0);
233                 glClear(GL_COLOR_BUFFER_BIT);
234                 wm_window_swap_buffers(win);
235
236                 /* standard state vars for window */
237                 glEnable(GL_SCISSOR_TEST);
238         }
239 }
240
241 /* for wmWindows without ghostwin, open these and clear */
242 void wm_window_add_ghostwindows(wmWindowManager *wm)
243 {
244         wmWindow *win;
245         
246         /* no commandline prefsize? then we set this */
247         if (!prefsizx) {
248                 wm_get_screensize(&prefsizx, &prefsizy);
249                 
250 #ifdef __APPLE__
251                 {
252                         extern void wm_set_apple_prefsize(int, int);    /* wm_apple.c */
253                 
254                         wm_set_apple_prefsize(prefsizx, prefsizy);
255                 }
256 #else
257                 prefstax= 0;
258                 prefstay= 0;
259                 
260 #endif
261         }
262         
263         for(win= wm->windows.first; win; win= win->next) {
264                 if(win->ghostwin==NULL) {
265                         if(win->sizex==0) {
266                                 win->posx= prefstax;
267                                 win->posy= prefstay;
268                                 win->sizex= prefsizx;
269                                 win->sizey= prefsizy;
270                                 win->windowstate= 0;
271                         }
272                         wm_window_open(wm, "Blender", win);
273                 }
274         }
275 }
276
277 /* ************ events *************** */
278
279 static int query_qual(char qual) 
280 {
281         GHOST_TModifierKeyMask left, right;
282         int val= 0;
283         
284         if (qual=='s') {
285                 left= GHOST_kModifierKeyLeftShift;
286                 right= GHOST_kModifierKeyRightShift;
287         } else if (qual=='c') {
288                 left= GHOST_kModifierKeyLeftControl;
289                 right= GHOST_kModifierKeyRightControl;
290         } else if (qual=='C') {
291                 left= right= GHOST_kModifierKeyCommand;
292         } else {
293                 left= GHOST_kModifierKeyLeftAlt;
294                 right= GHOST_kModifierKeyRightAlt;
295         }
296         
297         GHOST_GetModifierKeyState(g_system, left, &val);
298         if (!val)
299                 GHOST_GetModifierKeyState(g_system, right, &val);
300         
301         return val;
302 }
303
304 void wm_window_make_drawable(bContext *C, wmWindow *win) 
305 {
306         if (win != C->window && win->ghostwin) {
307 //              win->lmbut= 0;  /* keeps hanging when mousepressed while other window opened */
308                 
309                 C->wm->windrawable= win;
310                 C->window= win;
311                 C->screen= win->screen;
312                 printf("set drawable %d\n", win->winid);
313                 GHOST_ActivateWindowDrawingContext(win->ghostwin);
314         }
315 }
316
317 /* called by ghost, here we handle events for windows themselves or send to event system */
318 static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private) 
319 {
320         bContext *C= private;
321         GHOST_TEventType type= GHOST_GetEventType(evt);
322         
323         if (type == GHOST_kEventQuit) {
324                 WM_exit(C);
325         } else {
326                 GHOST_WindowHandle ghostwin= GHOST_GetEventWindow(evt);
327                 GHOST_TEventDataPtr data= GHOST_GetEventData(evt);
328                 wmWindow *win;
329                 
330                 if (!ghostwin) {
331                         // XXX - should be checked, why are we getting an event here, and
332                         //      what is it?
333                         
334                         return 1;
335                 } else if (!GHOST_ValidWindow(g_system, ghostwin)) {
336                         // XXX - should be checked, why are we getting an event here, and
337                         //      what is it?
338                         
339                         return 1;
340                 } else {
341                         win= GHOST_GetWindowUserData(ghostwin);
342                 }
343                 
344                 switch(type) {
345                         case GHOST_kEventWindowDeactivate:
346                                 win->active= 0; /* XXX */
347                                 break;
348                         case GHOST_kEventWindowActivate: 
349                         {
350                                 GHOST_TEventKeyData kdata;
351                                 int cx, cy, wx, wy;
352                                 
353                                 C->wm->winactive= win; /* no context change! c->window is drawable, or for area queues */
354                                 
355                                 win->active= 1;
356 //                              window_handle(win, INPUTCHANGE, win->active);
357                                 
358                                 /* bad ghost support for modifier keys... so on activate we set the modifiers again */
359                                 kdata.ascii= 0;
360                                 if (win->eventstate->shift && !query_qual('s')) {
361                                         kdata.key= GHOST_kKeyLeftShift;
362                                         wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
363                                 }
364                                 if (win->eventstate->ctrl && !query_qual('c')) {
365                                         kdata.key= GHOST_kKeyLeftControl;
366                                         wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
367                                 }
368                                 if (win->eventstate->alt && !query_qual('a')) {
369                                         kdata.key= GHOST_kKeyLeftAlt;
370                                         wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
371                                 }
372                                 if (win->eventstate->oskey && !query_qual('C')) {
373                                         kdata.key= GHOST_kKeyCommand;
374                                         wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
375                                 }
376                                 
377                                 /* entering window, update mouse pos. but no event */
378                                 GHOST_GetCursorPosition(g_system, &wx, &wy);
379                                 
380                                 GHOST_ScreenToClient(win->ghostwin, wx, wy, &cx, &cy);
381                                 win->eventstate->x= cx;
382                                 win->eventstate->y= (win->sizey-1) - cy;
383                                 
384                                 ED_screen_set_subwinactive(win);        /* active subwindow in screen */
385                                 
386                                 wm_window_make_drawable(C, win);
387                                 break;
388                         }
389                         case GHOST_kEventWindowClose: {
390                                 wm_window_close(C, win);
391                                 break;
392                         }
393                         case GHOST_kEventWindowUpdate: {
394                                 printf("ghost redraw\n");
395                                 
396                                 wm_window_make_drawable(C, win);
397                                 WM_event_add_notifier(C->wm, win, 0, WM_NOTE_WINDOW_REDRAW, 0);
398
399                                 break;
400                         }
401                         case GHOST_kEventWindowSize:
402                         case GHOST_kEventWindowMove: {
403                                 GHOST_RectangleHandle client_rect;
404                                 int l, t, r, b, scr_w, scr_h;
405                                 
406                                 client_rect= GHOST_GetClientBounds(win->ghostwin);
407                                 GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
408                                 
409                                 GHOST_DisposeRectangle(client_rect);
410                                 
411                                 wm_get_screensize(&scr_w, &scr_h);
412                                 win->sizex= r-l;
413                                 win->sizey= b-t;
414                                 win->posx= l;
415                                 win->posy= scr_h - t - win->sizey;
416
417                                 /* debug prints */
418                                 if(0) {
419                                         GHOST_TWindowState state;
420                                         state = GHOST_GetWindowState(win->ghostwin);
421
422                                         if(state==GHOST_kWindowStateNormal)
423                                                 printf("window state: normal\n");
424                                         else if(state==GHOST_kWindowStateMinimized)
425                                                 printf("window state: minimized\n");
426                                         else if(state==GHOST_kWindowStateMaximized)
427                                                 printf("window state: maximized\n");
428                                         else if(state==GHOST_kWindowStateFullScreen)
429                                                 printf("window state: fullscreen\n");
430                                         
431                                         if(type!=GHOST_kEventWindowSize)
432                                                 printf("win move event pos %d %d size %d %d\n", win->posx, win->posy, win->sizex, win->sizey);
433                                         
434                                 }
435                                 
436                                 wm_window_make_drawable(C, win);
437                                 WM_event_add_notifier(C->wm, win, 0, WM_NOTE_SCREEN_CHANGED, 0);
438                                 
439                                 break;
440                         }
441                         default:
442                                 if(type==GHOST_kEventKeyDown) // XXX debug
443                                         WM_event_add_notifier(C->wm, win, 0, WM_NOTE_WINDOW_REDRAW, 0);
444                                 wm_event_add_ghostevent(win, type, data);
445                                 break;
446                 }
447
448         }
449         return 1;
450 }
451
452 void wm_window_process_events(int wait_for_event) 
453 {
454         GHOST_ProcessEvents(g_system, wait_for_event);
455         GHOST_DispatchEvents(g_system);
456 }
457
458 /* **************** init ********************** */
459
460 void wm_ghost_init(bContext *C)
461 {
462         if (!g_system) {
463                 GHOST_EventConsumerHandle consumer= GHOST_CreateEventConsumer(ghost_event_proc, C);
464                 
465                 g_system= GHOST_CreateSystem();
466                 GHOST_AddEventConsumer(g_system, consumer);
467         }       
468 }
469
470 /* **************** timer ********************** */
471
472 static void window_timer_proc(GHOST_TimerTaskHandle timer, GHOST_TUns64 time)
473 {
474         wmWindow *win= GHOST_GetTimerTaskUserData(timer);
475         
476         wm_event_add_ghostevent(win, win->timer_event, NULL);
477 }
478
479 void wm_window_set_timer(wmWindow *win, int delay_ms, int event)
480 {
481         if (win->timer) GHOST_RemoveTimer(g_system, win->timer);
482         
483         win->timer_event= event;
484         win->timer= GHOST_InstallTimer(g_system, delay_ms, delay_ms, window_timer_proc, win);
485 }
486
487 /* ************************************ */
488
489 void wm_window_set_title(wmWindow *win, char *title) 
490 {
491         GHOST_SetTitle(win->ghostwin, title);
492 }
493
494 void wm_window_get_position(wmWindow *win, int *posx_r, int *posy_r) 
495 {
496         *posx_r= win->posx;
497         *posy_r= win->posy;
498 }
499
500 void wm_window_get_size(wmWindow *win, int *width_r, int *height_r) 
501 {
502         *width_r= win->sizex;
503         *height_r= win->sizey;
504 }
505
506 void wm_window_set_size(wmWindow *win, int width, int height) 
507 {
508         GHOST_SetClientSize(win->ghostwin, width, height);
509 }
510
511 void wm_window_lower(wmWindow *win) 
512 {
513         GHOST_SetWindowOrder(win->ghostwin, GHOST_kWindowOrderBottom);
514 }
515
516 void wm_window_raise(wmWindow *win) 
517 {
518         GHOST_SetWindowOrder(win->ghostwin, GHOST_kWindowOrderTop);
519 #ifdef _WIN32
520 //      markdirty_all(); /* to avoid redraw errors in fullscreen mode (aphex) */
521 #endif
522 }
523
524 void wm_window_swap_buffers(wmWindow *win)
525 {
526         GHOST_SwapWindowBuffers(win->ghostwin);
527 }
528
529 /* ******************* exported api ***************** */
530
531
532 /* called whem no ghost system was initialized */
533 void WM_setprefsize(int stax, int stay, int sizx, int sizy)
534 {
535         prefstax= stax;
536         prefstay= stay;
537         prefsizx= sizx;
538         prefsizy= sizy;
539 }
540