/* XXX solve dual screen... */
static void wm_window_check_position(rcti *rect)
{
int width, height, d;
wm_get_screensize(&width, &height);
#if defined(__APPLE__) && !defined(GHOST_COCOA)
height -= 70;
#endif
if (rect->xmin < 0) {
rect->xmax -= rect->xmin;
rect->xmin = 0;
}
if (rect->ymin < 0) {
rect->ymax -= rect->ymin;
rect->ymin = 0;
}
if (rect->xmax > width) {
d = rect->xmax - width;
rect->xmax -= d;
rect->xmin -= d;
}
if (rect->ymax > height) {
d = rect->ymax - height;
rect->ymax -= d;
rect->ymin -= d;
}
if (rect->xmin < 0) rect->xmin = 0;
if (rect->ymin < 0) rect->ymin = 0;
}
/* XXX solve dual screen... */
static void wm_window_check_position(rcti *rect)
{
int width, height, d;
wm_get_screensize(&width, &height);
if (rect->xmin < 0) {
rect->xmax -= rect->xmin;
rect->xmin = 0;
}
if (rect->ymin < 0) {
rect->ymax -= rect->ymin;
rect->ymin = 0;
}
if (rect->xmax > width) {
d = rect->xmax - width;
rect->xmax -= d;
rect->xmin -= d;
}
if (rect->ymax > height) {
d = rect->ymax - height;
rect->ymax -= d;
rect->ymin -= d;
}
if (rect->xmin < 0) rect->xmin = 0;
if (rect->ymin < 0) rect->ymin = 0;
}
/* belongs to below */
static void wm_window_add_ghostwindow(const char *title, wmWindow *win)
{
GHOST_WindowHandle ghostwin;
int scr_w, scr_h, posy;
wm_get_screensize(&scr_w, &scr_h);
posy = (scr_h - win->posy - win->sizey);
#if defined(__APPLE__) && !defined(GHOST_COCOA)
{
extern int macPrefState; /* creator.c */
initial_state += macPrefState;
}
#endif
/* Disable AA for now, as GL_SELECT (used for border, lasso, ... select)
* doesn't work well when AA is initialized, even if not used. */
ghostwin = GHOST_CreateWindow(g_system, title,
win->posx, posy, win->sizex, win->sizey,
(GHOST_TWindowState)win->windowstate,
GHOST_kDrawingContextTypeOpenGL,
0 /* no stereo */,
0 /* no AA */);
if (ghostwin) {
/* needed so we can detect the graphics card below */
GPU_extensions_init();
/* set the state*/
GHOST_SetWindowState(ghostwin, (GHOST_TWindowState)win->windowstate);
win->ghostwin = ghostwin;
GHOST_SetWindowUserData(ghostwin, win); /* pointer back */
if (win->eventstate == NULL)
win->eventstate = MEM_callocN(sizeof(wmEvent), "window event state");
/* until screens get drawn, make it nice gray */
glClearColor(0.55, 0.55, 0.55, 0.0);
/* Crash on OSS ATI: bugs.launchpad.net/ubuntu/+source/mesa/+bug/656100 */
if (!GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_UNIX, GPU_DRIVER_OPENSOURCE)) {
glClear(GL_COLOR_BUFFER_BIT);
}
wm_window_swap_buffers(win);
//GHOST_SetWindowState(ghostwin, GHOST_kWindowStateModified);
/* standard state vars for window */
glEnable(GL_SCISSOR_TEST);
GPU_state_init();
}
}
void KX_BlenderCanvas::GetDisplayDimensions(int &width, int &height)
{
wm_get_screensize(&width, &height);
}
bool WM_init_game(bContext *C)
{
wmWindowManager *wm = CTX_wm_manager(C);
wmWindow *win;
ScrArea *sa;
ARegion *ar = NULL;
Scene *scene = CTX_data_scene(C);
if (!scene) {
/* XXX, this should not be needed. */
Main *bmain = CTX_data_main(C);
scene = bmain->scene.first;
}
win = wm->windows.first;
/* first to get a valid window */
if (win)
CTX_wm_window_set(C, win);
sa = BKE_screen_find_big_area(CTX_wm_screen(C), SPACE_VIEW3D, 0);
ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
/* if we have a valid 3D view */
if (sa && ar) {
ARegion *arhide;
CTX_wm_area_set(C, sa);
CTX_wm_region_set(C, ar);
/* disable quad view */
if (ar->alignment == RGN_ALIGN_QSPLIT)
WM_operator_name_call(C, "SCREEN_OT_region_quadview", WM_OP_EXEC_DEFAULT, NULL);
/* toolbox, properties panel and header are hidden */
for (arhide = sa->regionbase.first; arhide; arhide = arhide->next) {
if (arhide->regiontype != RGN_TYPE_WINDOW) {
if (!(arhide->flag & RGN_FLAG_HIDDEN)) {
ED_region_toggle_hidden(C, arhide);
}
}
}
/* full screen the area */
if (!sa->full) {
ED_screen_state_toggle(C, win, sa, SCREENMAXIMIZED);
}
/* Fullscreen */
if ((scene->gm.playerflag & GAME_PLAYER_FULLSCREEN)) {
WM_operator_name_call(C, "WM_OT_window_fullscreen_toggle", WM_OP_EXEC_DEFAULT, NULL);
wm_get_screensize(&ar->winrct.xmax, &ar->winrct.ymax);
ar->winx = ar->winrct.xmax + 1;
ar->winy = ar->winrct.ymax + 1;
}
else {
GHOST_RectangleHandle rect = GHOST_GetClientBounds(win->ghostwin);
ar->winrct.ymax = GHOST_GetHeightRectangle(rect);
ar->winrct.xmax = GHOST_GetWidthRectangle(rect);
ar->winx = ar->winrct.xmax + 1;
ar->winy = ar->winrct.ymax + 1;
GHOST_DisposeRectangle(rect);
}
WM_operator_name_call(C, "VIEW3D_OT_game_start", WM_OP_EXEC_DEFAULT, NULL);
BKE_sound_exit();
return true;
}
else {
ReportTimerInfo *rti;
BKE_report(&wm->reports, RPT_ERROR, "No valid 3D View found, game auto start is not possible");
/* After adding the report to the global list, reset the report timer. */
WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);
/* Records time since last report was added */
wm->reports.reporttimer = WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.02);
rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");
wm->reports.reporttimer->customdata = rti;
return false;
}
}
/* called by ghost, here we handle events for windows themselves or send to event system */
static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr C_void_ptr)
{
bContext *C = C_void_ptr;
wmWindowManager *wm = CTX_wm_manager(C);
GHOST_TEventType type = GHOST_GetEventType(evt);
int time = GHOST_GetEventTime(evt);
if (type == GHOST_kEventQuit) {
WM_exit(C);
}
else {
GHOST_WindowHandle ghostwin = GHOST_GetEventWindow(evt);
GHOST_TEventDataPtr data = GHOST_GetEventData(evt);
wmWindow *win;
if (!ghostwin) {
/* XXX - should be checked, why are we getting an event here, and */
/* what is it? */
puts("<!> event has no window");
return 1;
}
else if (!GHOST_ValidWindow(g_system, ghostwin)) {
/* XXX - should be checked, why are we getting an event here, and */
/* what is it? */
puts("<!> event has invalid window");
return 1;
}
else {
win = GHOST_GetWindowUserData(ghostwin);
}
switch (type) {
case GHOST_kEventWindowDeactivate:
wm_event_add_ghostevent(wm, win, type, time, data);
win->active = 0; /* XXX */
break;
case GHOST_kEventWindowActivate:
{
GHOST_TEventKeyData kdata;
wmEvent event;
int cx, cy, wx, wy;
wm->winactive = win; /* no context change! c->wm->windrawable is drawable, or for area queues */
win->active = 1;
// window_handle(win, INPUTCHANGE, win->active);
/* bad ghost support for modifier keys... so on activate we set the modifiers again */
kdata.ascii = '\0';
kdata.utf8_buf[0] = '\0';
if (win->eventstate->shift && !query_qual(SHIFT)) {
kdata.key = GHOST_kKeyLeftShift;
wm_event_add_ghostevent(wm, win, GHOST_kEventKeyUp, time, &kdata);
}
if (win->eventstate->ctrl && !query_qual(CONTROL)) {
kdata.key = GHOST_kKeyLeftControl;
wm_event_add_ghostevent(wm, win, GHOST_kEventKeyUp, time, &kdata);
}
if (win->eventstate->alt && !query_qual(ALT)) {
kdata.key = GHOST_kKeyLeftAlt;
wm_event_add_ghostevent(wm, win, GHOST_kEventKeyUp, time, &kdata);
}
if (win->eventstate->oskey && !query_qual(OS)) {
kdata.key = GHOST_kKeyOS;
wm_event_add_ghostevent(wm, win, GHOST_kEventKeyUp, time, &kdata);
}
/* keymodifier zero, it hangs on hotkeys that open windows otherwise */
win->eventstate->keymodifier = 0;
/* entering window, update mouse pos. but no event */
GHOST_GetCursorPosition(g_system, &wx, &wy);
GHOST_ScreenToClient(win->ghostwin, wx, wy, &cx, &cy);
win->eventstate->x = cx;
win->eventstate->y = (win->sizey - 1) - cy;
win->addmousemove = 1; /* enables highlighted buttons */
wm_window_make_drawable(C, win);
/* window might be focused by mouse click in configuration of window manager
* when focus is not following mouse
* click could have been done on a button and depending on window manager settings
* click would be passed to blender or not, but in any case button under cursor
* should be activated, so at max next click on button without moving mouse
* would trigger it's handle function
* currently it seems to be common practice to generate new event for, but probably
* we'll need utility function for this? (sergey)
*/
event = *(win->eventstate);
event.type = MOUSEMOVE;
event.prevx = event.x;
event.prevy = event.y;
wm_event_add(win, &event);
break;
}
case GHOST_kEventWindowClose: {
wm_window_close(C, wm, win);
break;
}
case GHOST_kEventWindowUpdate: {
if (G.debug & G_DEBUG_EVENTS) {
printf("%s: ghost redraw %d\n", __func__, win->winid);
}
wm_window_make_drawable(C, win);
WM_event_add_notifier(C, NC_WINDOW, NULL);
break;
}
case GHOST_kEventWindowSize:
case GHOST_kEventWindowMove: {
GHOST_TWindowState state;
state = GHOST_GetWindowState(win->ghostwin);
win->windowstate = state;
/* win32: gives undefined window size when minimized */
if (state != GHOST_kWindowStateMinimized) {
GHOST_RectangleHandle client_rect;
int l, t, r, b, scr_w, scr_h;
int sizex, sizey, posx, posy;
client_rect = GHOST_GetClientBounds(win->ghostwin);
GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
GHOST_DisposeRectangle(client_rect);
wm_get_screensize(&scr_w, &scr_h);
sizex = r - l;
sizey = b - t;
posx = l;
posy = scr_h - t - win->sizey;
/*
* Ghost sometimes send size or move events when the window hasn't changed.
* One case of this is using compiz on linux. To alleviate the problem
* we ignore all such event here.
*
* It might be good to eventually do that at Ghost level, but that is for
* another time.
*/
if (win->sizex != sizex ||
win->sizey != sizey ||
win->posx != posx ||
win->posy != posy)
{
win->sizex = sizex;
win->sizey = sizey;
win->posx = posx;
win->posy = posy;
/* debug prints */
if (G.debug & G_DEBUG_EVENTS) {
const char *state_str;
state = GHOST_GetWindowState(win->ghostwin);
if (state == GHOST_kWindowStateNormal) {
state_str = "normal";
}
else if (state == GHOST_kWindowStateMinimized) {
state_str = "minimized";
}
else if (state == GHOST_kWindowStateMaximized) {
state_str = "maximized";
}
else if (state == GHOST_kWindowStateFullScreen) {
state_str = "fullscreen";
}
else {
state_str = "<unknown>";
}
printf("%s: window %d state = %s\n", __func__, win->winid, state_str);
if (type != GHOST_kEventWindowSize) {
printf("win move event pos %d %d size %d %d\n",
win->posx, win->posy, win->sizex, win->sizey);
}
}
wm_window_make_drawable(C, win);
wm_draw_window_clear(win);
WM_event_add_notifier(C, NC_SCREEN | NA_EDITED, NULL);
WM_event_add_notifier(C, NC_WINDOW | NA_EDITED, NULL);
}
}
break;
}
case GHOST_kEventOpenMainFile:
{
PointerRNA props_ptr;
wmWindow *oldWindow;
char *path = GHOST_GetEventData(evt);
if (path) {
/* operator needs a valid window in context, ensures
* it is correctly set */
oldWindow = CTX_wm_window(C);
CTX_wm_window_set(C, win);
WM_operator_properties_create(&props_ptr, "WM_OT_open_mainfile");
RNA_string_set(&props_ptr, "filepath", path);
WM_operator_name_call(C, "WM_OT_open_mainfile", WM_OP_EXEC_DEFAULT, &props_ptr);
WM_operator_properties_free(&props_ptr);
CTX_wm_window_set(C, oldWindow);
}
break;
}
case GHOST_kEventDraggingDropDone:
{
wmEvent event;
GHOST_TEventDragnDropData *ddd = GHOST_GetEventData(evt);
int cx, cy, wx, wy;
/* entering window, update mouse pos */
GHOST_GetCursorPosition(g_system, &wx, &wy);
GHOST_ScreenToClient(win->ghostwin, wx, wy, &cx, &cy);
win->eventstate->x = cx;
win->eventstate->y = (win->sizey - 1) - cy;
event = *(win->eventstate); /* copy last state, like mouse coords */
/* activate region */
event.type = MOUSEMOVE;
event.prevx = event.x;
event.prevy = event.y;
wm->winactive = win; /* no context change! c->wm->windrawable is drawable, or for area queues */
win->active = 1;
wm_event_add(win, &event);
/* make blender drop event with custom data pointing to wm drags */
event.type = EVT_DROP;
event.val = KM_RELEASE;
event.custom = EVT_DATA_LISTBASE;
event.customdata = &wm->drags;
event.customdatafree = 1;
wm_event_add(win, &event);
/* printf("Drop detected\n"); */
/* add drag data to wm for paths: */
if (ddd->dataType == GHOST_kDragnDropTypeFilenames) {
GHOST_TStringArray *stra = ddd->data;
int a, icon;
for (a = 0; a < stra->count; a++) {
printf("drop file %s\n", stra->strings[a]);
/* try to get icon type from extension */
icon = ED_file_extension_icon((char *)stra->strings[a]);
WM_event_start_drag(C, icon, WM_DRAG_PATH, stra->strings[a], 0.0);
/* void poin should point to string, it makes a copy */
break; /* only one drop element supported now */
}
}
break;
}
default:
wm_event_add_ghostevent(wm, win, type, time, data);
break;
}
}
return 1;
}
/* called in WM_check, also inits stuff after file read */
void wm_window_add_ghostwindows(wmWindowManager *wm)
{
wmKeyMap *keymap;
wmWindow *win;
/* no commandline prefsize? then we set this.
* Note that these values will be used only
* when there is no startup.blend yet.
*/
if (wm_init_state.size_x == 0) {
wm_get_screensize(&wm_init_state.size_x, &wm_init_state.size_y);
#if defined(__APPLE__) && !defined(GHOST_COCOA)
/* Cocoa provides functions to get correct max window size */
{
extern void wm_set_apple_prefsize(int, int); /* wm_apple.c */
wm_set_apple_prefsize(wm_init_state.size_x, wm_init_state.size_y);
}
#else
wm_init_state.start_x = 0;
wm_init_state.start_y = 0;
#endif
}
for (win = wm->windows.first; win; win = win->next) {
if (win->ghostwin == NULL) {
if ((win->sizex == 0) || (wm_init_state.override_flag & WIN_OVERRIDE_GEOM)) {
win->posx = wm_init_state.start_x;
win->posy = wm_init_state.start_y;
win->sizex = wm_init_state.size_x;
win->sizey = wm_init_state.size_y;
wm_init_state.override_flag &= ~WIN_OVERRIDE_GEOM;
}
if (wm_init_state.override_flag & WIN_OVERRIDE_WINSTATE) {
win->windowstate = wm_init_state.windowstate;
wm_init_state.override_flag &= ~WIN_OVERRIDE_WINSTATE;
}
wm_window_add_ghostwindow("Blender", win);
}
/* happens after fileread */
if (win->eventstate == NULL)
win->eventstate = MEM_callocN(sizeof(wmEvent), "window event state");
/* add keymap handlers (1 handler for all keys in map!) */
keymap = WM_keymap_find(wm->defaultconf, "Window", 0, 0);
WM_event_add_keymap_handler(&win->handlers, keymap);
keymap = WM_keymap_find(wm->defaultconf, "Screen", 0, 0);
WM_event_add_keymap_handler(&win->handlers, keymap);
keymap = WM_keymap_find(wm->defaultconf, "Screen Editing", 0, 0);
WM_event_add_keymap_handler(&win->modalhandlers, keymap);
/* add drop boxes */
{
ListBase *lb = WM_dropboxmap_find("Window", 0, 0);
WM_event_add_dropbox_handler(&win->handlers, lb);
}
wm_window_title(wm, win);
}
}
/* called in WM_check, also inits stuff after file read */
void wm_window_add_ghostwindows(wmWindowManager *wm)
{
wmKeyMap *keymap;
wmWindow *win;
/* no commandline prefsize? then we set this.
* Note that these values will be used only
* when there is no startup.blend yet.
*/
if (wm_init_state.size_x == 0) {
wm_get_screensize(&wm_init_state.size_x, &wm_init_state.size_y);
/* note!, this isnt quite correct, active screen maybe offset 1000s if PX,
* we'd need a wm_get_screensize like function that gives offset,
* in practice the window manager will likely move to the correct monitor */
wm_init_state.start_x = 0;
wm_init_state.start_y = 0;
#ifdef WITH_X11 /* X11 */
/* X11, start maximized but use default sane size */
wm_init_state.size_x = min_ii(wm_init_state.size_x, WM_WIN_INIT_SIZE_X);
wm_init_state.size_y = min_ii(wm_init_state.size_y, WM_WIN_INIT_SIZE_Y);
/* pad */
wm_init_state.start_x = WM_WIN_INIT_PAD;
wm_init_state.start_y = WM_WIN_INIT_PAD;
wm_init_state.size_x -= WM_WIN_INIT_PAD * 2;
wm_init_state.size_y -= WM_WIN_INIT_PAD * 2;
#endif
}
for (win = wm->windows.first; win; win = win->next) {
if (win->ghostwin == NULL) {
if ((win->sizex == 0) || (wm_init_state.override_flag & WIN_OVERRIDE_GEOM)) {
win->posx = wm_init_state.start_x;
win->posy = wm_init_state.start_y;
win->sizex = wm_init_state.size_x;
win->sizey = wm_init_state.size_y;
win->windowstate = GHOST_kWindowStateNormal;
wm_init_state.override_flag &= ~WIN_OVERRIDE_GEOM;
}
if (wm_init_state.override_flag & WIN_OVERRIDE_WINSTATE) {
win->windowstate = wm_init_state.windowstate;
wm_init_state.override_flag &= ~WIN_OVERRIDE_WINSTATE;
}
/* without this, cursor restore may fail, T45456 */
if (win->cursor == 0) {
win->cursor = CURSOR_STD;
}
wm_window_add_ghostwindow(wm, "Blender", win);
}
/* happens after fileread */
if (win->eventstate == NULL)
win->eventstate = MEM_callocN(sizeof(wmEvent), "window event state");
/* add keymap handlers (1 handler for all keys in map!) */
keymap = WM_keymap_find(wm->defaultconf, "Window", 0, 0);
WM_event_add_keymap_handler(&win->handlers, keymap);
keymap = WM_keymap_find(wm->defaultconf, "Screen", 0, 0);
WM_event_add_keymap_handler(&win->handlers, keymap);
keymap = WM_keymap_find(wm->defaultconf, "Screen Editing", 0, 0);
WM_event_add_keymap_handler(&win->modalhandlers, keymap);
/* add drop boxes */
{
ListBase *lb = WM_dropboxmap_find("Window", 0, 0);
WM_event_add_dropbox_handler(&win->handlers, lb);
}
wm_window_title(wm, win);
}
}
/* belongs to below */
static void wm_window_add_ghostwindow(wmWindowManager *wm, const char *title, wmWindow *win)
{
GHOST_WindowHandle ghostwin;
GHOST_GLSettings glSettings = {0};
static int multisamples = -1;
int scr_w, scr_h, posy;
/* force setting multisamples only once, it requires restart - and you cannot
* mix it, either all windows have it, or none (tested in OSX opengl) */
if (multisamples == -1)
multisamples = U.ogl_multisamples;
glSettings.numOfAASamples = multisamples;
/* a new window is created when pageflip mode is required for a window */
if (win->stereo3d_format->display_mode == S3D_DISPLAY_PAGEFLIP)
glSettings.flags |= GHOST_glStereoVisual;
if (G.debug & G_DEBUG_GPU) {
glSettings.flags |= GHOST_glDebugContext;
}
if (!(U.uiflag2 & USER_OPENGL_NO_WARN_SUPPORT))
glSettings.flags |= GHOST_glWarnSupport;
wm_get_screensize(&scr_w, &scr_h);
posy = (scr_h - win->posy - win->sizey);
ghostwin = GHOST_CreateWindow(g_system, title,
win->posx, posy, win->sizex, win->sizey,
(GHOST_TWindowState)win->windowstate,
GHOST_kDrawingContextTypeOpenGL,
glSettings);
if (ghostwin) {
GHOST_RectangleHandle bounds;
/* the new window has already been made drawable upon creation */
wm->windrawable = win;
/* needed so we can detect the graphics card below */
GPU_init();
win->ghostwin = ghostwin;
GHOST_SetWindowUserData(ghostwin, win); /* pointer back */
if (win->eventstate == NULL)
win->eventstate = MEM_callocN(sizeof(wmEvent), "window event state");
#ifdef __APPLE__
/* set the state here, else OSX would not recognize changed screen resolution */
/* we agreed to not set any fullscreen or iconized state on startup */
GHOST_SetWindowState(ghostwin, GHOST_kWindowStateNormal);
#endif
/* store actual window size in blender window */
bounds = GHOST_GetClientBounds(win->ghostwin);
win->sizex = GHOST_GetWidthRectangle(bounds);
win->sizey = GHOST_GetHeightRectangle(bounds);
GHOST_DisposeRectangle(bounds);
#ifndef __APPLE__
/* set the state here, so minimized state comes up correct on windows */
GHOST_SetWindowState(ghostwin, (GHOST_TWindowState)win->windowstate);
#endif
/* until screens get drawn, make it nice gray */
glClearColor(0.55, 0.55, 0.55, 0.0);
/* Crash on OSS ATI: bugs.launchpad.net/ubuntu/+source/mesa/+bug/656100 */
if (!GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_UNIX, GPU_DRIVER_OPENSOURCE)) {
glClear(GL_COLOR_BUFFER_BIT);
}
/* displays with larger native pixels, like Macbook. Used to scale dpi with */
/* needed here, because it's used before it reads userdef */
U.pixelsize = wm_window_pixelsize(win);
BKE_userdef_state();
wm_window_swap_buffers(win);
//GHOST_SetWindowState(ghostwin, GHOST_kWindowStateModified);
/* standard state vars for window */
glEnable(GL_SCISSOR_TEST);
GPU_state_init();
}
}
/* belongs to below */
static void wm_window_add_ghostwindow(const char *title, wmWindow *win)
{
GHOST_WindowHandle ghostwin;
static int multisamples = -1;
int scr_w, scr_h, posy;
/* force setting multisamples only once, it requires restart - and you cannot
* mix it, either all windows have it, or none (tested in OSX opengl) */
if (multisamples == -1)
multisamples = U.ogl_multisamples;
wm_get_screensize(&scr_w, &scr_h);
posy = (scr_h - win->posy - win->sizey);
ghostwin = GHOST_CreateWindow(g_system, title,
win->posx, posy, win->sizex, win->sizey,
(GHOST_TWindowState)win->windowstate,
GHOST_kDrawingContextTypeOpenGL,
0 /* no stereo */,
multisamples /* AA */);
if (ghostwin) {
GHOST_RectangleHandle bounds;
/* needed so we can detect the graphics card below */
GPU_extensions_init();
win->ghostwin = ghostwin;
GHOST_SetWindowUserData(ghostwin, win); /* pointer back */
if (win->eventstate == NULL)
win->eventstate = MEM_callocN(sizeof(wmEvent), "window event state");
/* set the state */
GHOST_SetWindowState(ghostwin, (GHOST_TWindowState)win->windowstate);
/* until screens get drawn, make it nice gray */
glClearColor(0.55, 0.55, 0.55, 0.0);
/* Crash on OSS ATI: bugs.launchpad.net/ubuntu/+source/mesa/+bug/656100 */
if (!GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_UNIX, GPU_DRIVER_OPENSOURCE)) {
glClear(GL_COLOR_BUFFER_BIT);
}
/* displays with larger native pixels, like Macbook. Used to scale dpi with */
/* needed here, because it's used before it reads userdef */
U.pixelsize = GHOST_GetNativePixelSize(win->ghostwin);
BKE_userdef_state();
/* store actual window size in blender window */
bounds = GHOST_GetClientBounds(win->ghostwin);
win->sizex = GHOST_GetWidthRectangle(bounds);
win->sizey = GHOST_GetHeightRectangle(bounds);
GHOST_DisposeRectangle(bounds);
wm_window_swap_buffers(win);
//GHOST_SetWindowState(ghostwin, GHOST_kWindowStateModified);
/* standard state vars for window */
glEnable(GL_SCISSOR_TEST);
GPU_state_init();
}
}
