Page MenuHome
Differential D4291 Diff 13520 source/blender/windowmanager/intern/wm_window.c

Changeset View

Standalone View

View Options

source/blender/windowmanager/intern/wm_window.c

Context not available.
#include "wm_draw.h" #include "wm_draw.h"
#include "wm_window.h" #include "wm_window.h"
#include "wm_event_system.h" #include "wm_event_system.h"
#include "wm_files.h"
#include "ED_anim_api.h" #include "ED_anim_api.h"
#include "ED_scene.h" #include "ED_scene.h"
Context not available.
# include "BLI_threads.h" # include "BLI_threads.h"
#endif #endif
#define MINIMUM_WINDOW_WIDTH 640
#define MINIMUM_WINDOW_HEIGHT 480
/* the global to talk to ghost */ /* the global to talk to ghost */
static GHOST_SystemHandle g_system = NULL; static GHOST_SystemHandle g_system = NULL;
/* window position preferences: list of WMWindowPosition */
static ListBase window_positions = { NULL, NULL };
typedef enum WinOverrideFlag { typedef enum WinOverrideFlag {
WIN_OVERRIDE_GEOM = (1 << 0), WIN_OVERRIDE_GEOM = (1 << 0),
WIN_OVERRIDE_WINSTATE = (1 << 1), WIN_OVERRIDE_WINSTATE = (1 << 1),
Context not available.
/* set by commandline */ /* set by commandline */
static struct WMInitStruct { static struct WMInitStruct {
/* window geometry */ /* window geometry */
int size_x, size_y; rcti rect;
int start_x, start_y;
int windowstate; int windowstate;
WinOverrideFlag override_flag; WinOverrideFlag override_flag;
Context not available.
/* XXX this one should correctly check for apple top header... /* XXX this one should correctly check for apple top header...
* done for Cocoa : returns window contents (and not frame) max size*/ * done for Cocoa : returns window contents (and not frame) max size*/
void wm_get_screensize(int *r_width, int *r_height) void wm_window_get_main_display_dimensions(int *r_width, int *r_height)
{ {
unsigned int uiwidth; unsigned int uiwidth;
unsigned int uiheight; unsigned int uiheight;
Context not available.
*r_height = uiheight; *r_height = uiheight;
} }
/* keeps offset and size within monitor bounds */ void wm_window_get_display_dimensions(rcti *rect, int num)
/* XXX solve dual screen... */
static void wm_window_check_position(rcti *rect)
{ {
int width, height, d; int x, y, width, height;
GHOST_GetDisplayDimensions(g_system, &x, &y, &width, &height, num);
wm_get_screensize(&width, &height); rect->xmin = x;
rect->ymin = y;
rect->xmax = x + width - 1;
rect->ymax = y + height - 1;
}
if (rect->xmin < 0) { /* test if the given rect is completely within a display bounds.
rect->xmax -= rect->xmin; * checks all available displays.
rect->xmin = 0; * \param rect: rect of window in screen coordinates
} */
if (rect->ymin < 0) { static bool wm_window_within_display(rcti *rect)
rect->ymax -= rect->ymin; {
rect->ymin = 0; int display_count = GHOST_GetNumDisplays(g_system);
}
if (rect->xmax > width) { if (G.debug & G_DEBUG) {
d = rect->xmax - width; printf("display count: %d\n", display_count);
rect->xmax -= d; printf("test rect: (%d,%d)-(%d,%d)\n",
rect->xmin -= d; rect->xmin, rect->ymin, rect->xmax, rect->ymax);
}
if (rect->ymax > height) {
d = rect->ymax - height;
rect->ymax -= d;
rect->ymin -= d;
} }
if (rect->xmin < 0) rect->xmin = 0; for (int i = 0; i < display_count; i++) {
if (rect->ymin < 0) rect->ymin = 0; rcti display_rect;
wm_window_get_display_dimensions(&display_rect, i);
if (G.debug & G_DEBUG) {
printf("display #%d: (%d,%d)-(%d,%d)\n", i,
display_rect.xmin, display_rect.ymin,
display_rect.xmax, display_rect.ymax);
}
if (BLI_rcti_inside_rcti(&display_rect, rect)) {
/* rect is within this display_rect */
return true;
}
}
/* rect is not within any display_rect */
return false;
} }
static void wm_ghostwindow_destroy(wmWindowManager *wm, wmWindow *win) static void wm_ghostwindow_destroy(wmWindowManager *wm, wmWindow *win)
Context not available.
WorkSpaceLayout *layout_old = WM_window_get_active_layout(win_src); WorkSpaceLayout *layout_old = WM_window_get_active_layout(win_src);
WorkSpaceLayout *layout_new; WorkSpaceLayout *layout_new;
win_dst->posx = win_src->posx + 10; int translate_x = 10;
win_dst->posx = win_src->posx + translate_x;
win_dst->posy = win_src->posy; win_dst->posy = win_src->posy;
win_dst->sizex = win_src->sizex; win_dst->sizex = win_src->sizex;
win_dst->sizey = win_src->sizey; win_dst->sizey = win_src->sizey;
win_dst->ghost_rect = win_src->ghost_rect;
BLI_rcti_translate(&win_dst->ghost_rect, translate_x, 0);
win_dst->scene = win_src->scene; win_dst->scene = win_src->scene;
STRNCPY(win_dst->view_layer_name, win_src->view_layer_name); STRNCPY(win_dst->view_layer_name, win_src->view_layer_name);
Context not available.
} }
} }
/* get preferred window position by type.
* coordinates are in screen (ghost) coordinates.
*/
static wmWindowPosition *wm_window_get_preferred_window_position(int type)
{
for (wmWindowPosition *pos = window_positions.first; pos; pos = pos->next) {
if (pos->type == type) {
return pos;
}
}
return NULL;
}
/* set preferred window position by type.
* coordinates are in screen (ghost) coordinates.
*/
static void wm_window_set_preferred_window_position(wmWindow *win)
{
int type = win->type;
short state = win->windowstate;
if (win->parent == NULL)
type = WM_WINDOW_MAIN;
if (state < 0) {
/* CLOG_WARN(&LOG, "unknown window type or state for window: %p", win); */
if (G.debug & G_DEBUG) printf("wm_window: unknown state for window: %p\n", win);
return;
}
wmWindowPosition *pos = wm_window_get_preferred_window_position(type);
if (pos == NULL) {
pos = MEM_callocN(sizeof(wmWindowPosition), "wmWindowPosition");
pos->type = type;
BLI_addtail(&window_positions, pos);
}
if (state == GHOST_kWindowStateNormal) {
/* only save coordinates for screens in normal mode
* (don't save for maximised or full screen windows, so we can restore down to
* the previous size preference)
*/
int t, l, r, b;
GHOST_RectangleHandle rect_handle = GHOST_GetWindowBounds(win->ghostwin);
GHOST_GetRectangle(rect_handle, &l, &t, &r, &b);
pos->rect.xmin = l;
pos->rect.ymin = t;
pos->rect.xmax = r;
pos->rect.ymax = b;
}
pos->windowstate = state;
if (G.debug & G_DEBUG) {
printf("save position: window type %d, state: %d: (%d,%d)-(%d,%d)\n",
type, state, pos->rect.xmin, pos->rect.ymin, pos->rect.xmax, pos->rect.ymax);
}
}
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Quit Confirmation Dialog /** \name Quit Confirmation Dialog
Context not available.
} }
} }
wm_window_set_preferred_window_position(win);
if (win->parent == NULL && win_other == NULL) { if (win->parent == NULL && win_other == NULL) {
wm_quit_with_optional_confirmation_prompt(C, win); wm_quit_with_optional_confirmation_prompt(C, win);
return; return;
Context not available.
} }
} }
#define DEFAULT_WINDOW_TITLE IFACE_("Blender")
/**
* set window title
*/
void wm_window_title(wmWindowManager *wm, wmWindow *win) void wm_window_title(wmWindowManager *wm, wmWindow *win)
{ {
const char *title = NULL;
bool file_saved = !wm || wm->file_saved;
char str[sizeof(((Main *)NULL)->name) + 24];
if (WM_window_is_temp_screen(win)) { if (WM_window_is_temp_screen(win)) {
/* nothing to do for 'temp' windows, ScrArea *sa;
* because WM_window_open_temp always sets window title */ bScreen *screen;
screen = WM_window_get_active_screen(win);
sa = screen ? screen->areabase.first : NULL;
if (sa == NULL)
title = DEFAULT_WINDOW_TITLE;
if (sa->spacetype == SPACE_IMAGE)
title = IFACE_("Blender Render");
else if (ELEM(sa->spacetype, SPACE_OUTLINER, SPACE_USERPREF))
title = IFACE_("Blender Preferences");
else if (sa->spacetype == SPACE_FILE)
title = IFACE_("Blender File View");
else if (sa->spacetype == SPACE_IPO)
title = IFACE_("Blender Drivers Editor");
else
title = DEFAULT_WINDOW_TITLE;
} }
else if (win->ghostwin) { else if (win->ghostwin) {
/* this is set to 1 if you don't have startup.blend open */ /* this is set to 1 if you don't have startup.blend open */
if (G.save_over && BKE_main_blendfile_path_from_global()[0]) { if (G.save_over && BKE_main_blendfile_path_from_global()[0]) {
char str[sizeof(((Main *)NULL)->name) + 24]; BLI_snprintf(str, sizeof(str), "%s%s [%s%s]", DEFAULT_WINDOW_TITLE,
BLI_snprintf(str, sizeof(str), "Blender%s [%s%s]", wm->file_saved ? "" : "*", file_saved ? "" : "*",
BKE_main_blendfile_path_from_global(), BKE_main_blendfile_path_from_global(),
G_MAIN->recovered ? " (Recovered)" : ""); G_MAIN->recovered ? " (Recovered)" : "");
GHOST_SetTitle(win->ghostwin, str); title = str;
} }
else else
GHOST_SetTitle(win->ghostwin, "Blender"); title = DEFAULT_WINDOW_TITLE;
}
if (title && win->ghostwin) {
GHOST_SetTitle(win->ghostwin, title);
/* Informs GHOST of unsaved changes, to set window modified visual indicator (MAC OS X) /* Informs GHOST of unsaved changes, to set window modified visual indicator (MAC OS X)
* and to give hint of unsaved changes for a user warning mechanism * and to give hint of unsaved changes for a user warning mechanism
* in case of OS application terminate request (e.g. OS Shortcut Alt+F4, Cmd+Q, (...), or session end) */ * in case of OS application terminate request (e.g. OS Shortcut Alt+F4, Cmd+Q, (...), or session end) */
GHOST_SetWindowModifiedState(win->ghostwin, (GHOST_TUns8) !wm->file_saved); GHOST_SetWindowModifiedState(win->ghostwin, (GHOST_TUns8)!file_saved);
} }
} }
Context not available.
wm_get_cursor_position(win, &win->eventstate->x, &win->eventstate->y); wm_get_cursor_position(win, &win->eventstate->x, &win->eventstate->y);
} }
/* belongs to below */ static void wm_window_get_ghost_bounds(wmWindow *win, GHOST_RectangleHandle (*get_bounds_func)(GHOST_WindowHandle), short *sizex, short *sizey)
{
GHOST_RectangleHandle bounds;
bounds = get_bounds_func(win->ghostwin);
/* win32: gives undefined window size when minimized */
if (GHOST_GetWindowState(win->ghostwin) != GHOST_kWindowStateMinimized) {
*sizex = GHOST_GetWidthRectangle(bounds);
*sizey = GHOST_GetHeightRectangle(bounds);
}
GHOST_DisposeRectangle(bounds);
}
/**
* move a window to the center of its parent.
* if parent is NULL, move to the center of the main display
*/
void wm_window_centralise(wmWindow *win)
{
wmWindow *parent = win->parent;
vec2s center;
rcti *ghost_rect = &win->ghost_rect;
int sizex = BLI_rcti_size_x(ghost_rect);
int sizey = BLI_rcti_size_y(ghost_rect);
if (parent) {
/* find center point of parent window */
center.x = parent->posx + parent->sizex / 2;
center.y = parent->posy + parent->sizey / 2;
}
else {
int width, height;
wm_window_get_main_display_dimensions(&width, &height);
center.x = width / 2;
center.y = height / 2;
}
/* calculate position of new window */
ghost_rect->xmin = center.x - sizex / 2;
ghost_rect->ymin = center.y - sizey / 2;
ghost_rect->xmax = ghost_rect->xmin + sizex;
ghost_rect->ymax = ghost_rect->ymin + sizey;
}
/**
* update sizing on the given window.
* updates win->ghost_rect, win->pos[xy], win->size[xy]
* \param sizex, sizey: recommended window size. overidden by user preferred window size
*/
void wm_window_size_position(wmWindow *win, int sizex, int sizey)
{
wmWindowPosition *pos;
rcti *rect = &win->ghost_rect;
/* for the render window, override user preference for
* sizing because size depends on render settings */
bool override_size_preference = win->type == WM_WINDOW_RENDER;
pos = wm_window_get_preferred_window_position(win->type);
if (pos && !override_size_preference) {
/* use preferred window size & position */
*rect = pos->rect;
/* enforce a minimum window size. */
int width = MAX2(MINIMUM_WINDOW_WIDTH, BLI_rcti_size_x(rect));
int height = MAX2(MINIMUM_WINDOW_HEIGHT, BLI_rcti_size_y(rect));
BLI_rcti_resize(rect, width, height);
win->windowstate = pos->windowstate;
}
else {
/* use recommended window size and central window position */
BLI_rcti_init(rect, 0, sizex, 0, sizey);
wm_window_centralise(win);
}
if (!wm_window_within_display(rect)) {
/* window is not positioned within a physical display */
/* position the window at the center of the parent window */
wm_window_centralise(win);
}
/* NOTE: these coordinates aren't correct, but need to be set for new windows
* to avoid a crash in event handlers before the actual client dimensions are retrieved. */
win->posx = rect->xmin;
win->posy = rect->ymin;
win->sizex = BLI_rcti_size_x(rect);
win->sizey = BLI_rcti_size_y(rect);
if (win->ghostwin) {
wm_window_set_size(win, win->sizex, win->sizey); /* client size */
}
}
void wm_window_get_client_bounds(wmWindow *win, short *posx, short *posy, short *sizex, short *sizey)
{
GHOST_RectangleHandle client_rect;
int l, t, r, b, scr_w, scr_h;
client_rect = GHOST_GetClientBounds(win->ghostwin);
GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
GHOST_DisposeRectangle(client_rect);
wm_get_desktopsize(&scr_w, &scr_h);
*sizex = r - l;
*sizey = b - t;
*posx = l;
*posy = scr_h - t - win->sizey;
}
void wm_window_update_client_bounds(wmWindow *win)
{
wm_window_get_client_bounds(win, &win->posx, &win->posy, &win->sizex, &win->sizey);
}
static void wm_window_ghostwindow_add(wmWindowManager *wm, const char *title, wmWindow *win) static void wm_window_ghostwindow_add(wmWindowManager *wm, const char *title, wmWindow *win)
{ {
GHOST_WindowHandle ghostwin; GHOST_WindowHandle ghostwin;
GHOST_GLSettings glSettings = {0}; GHOST_GLSettings glSettings = {0};
int scr_w, scr_h, posy; rcti rect = win->ghost_rect;
/* a new window is created when pageflip mode is required for a window */ /* a new window is created when pageflip mode is required for a window */
if (win->stereo3d_format->display_mode == S3D_DISPLAY_PAGEFLIP) if (win->stereo3d_format->display_mode == S3D_DISPLAY_PAGEFLIP)
Context not available.
glSettings.flags |= GHOST_glDebugContext; glSettings.flags |= GHOST_glDebugContext;
} }
wm_get_screensize(&scr_w, &scr_h);
posy = (scr_h - win->posy - win->sizey);
/* Clear drawable so we can set the new window. */ /* Clear drawable so we can set the new window. */
wmWindow *prev_windrawable = wm->windrawable; wmWindow *prev_windrawable = wm->windrawable;
wm_window_clear_drawable(wm); wm_window_clear_drawable(wm);
ghostwin = GHOST_CreateWindow(g_system, title, ghostwin = GHOST_CreateWindow(
win->posx, posy, win->sizex, win->sizey, g_system, title,
(GHOST_TWindowState)win->windowstate, rect.xmin, rect.ymin, BLI_rcti_size_x(&rect), BLI_rcti_size_y(&rect),
GHOST_kDrawingContextTypeOpenGL, (GHOST_TWindowState)win->windowstate,
glSettings); GHOST_kDrawingContextTypeOpenGL,
glSettings);
if (ghostwin) { if (ghostwin) {
GHOST_RectangleHandle bounds;
win->gpuctx = GPU_context_create(); win->gpuctx = GPU_context_create();
Context not available.
wm_window_ensure_eventstate(win); wm_window_ensure_eventstate(win);
/* store actual window size in blender window */ /* store actual window size (client bounds) in blender window */
bounds = GHOST_GetClientBounds(win->ghostwin); wm_window_update_client_bounds(win);
/* win32: gives undefined window size when minimized */
if (GHOST_GetWindowState(win->ghostwin) != GHOST_kWindowStateMinimized) {
win->sizex = GHOST_GetWidthRectangle(bounds);
win->sizey = GHOST_GetHeightRectangle(bounds);
}
GHOST_DisposeRectangle(bounds);
#ifndef __APPLE__ #ifndef __APPLE__
/* set the state here, so minimized state comes up correct on windows */ /* set the state here, so minimized state comes up correct on windows */
sobakasuAuthorUnsubmitted
Done
Inline Actions

it seems like this is an invalid assumption - I just realised maximised windows have a smaller title bar in windows. bit of a chicken and egg problem with this code, as you need to have created the window before you can get the title bar size from ghost window.

sobakasu: it seems like this is an invalid assumption - I just realised maximised windows have a smaller…
Context not available.
BLI_assert(G.background == false); BLI_assert(G.background == false);
/* 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, don't start maximized because we can't figure out the dimensions
* of a single display yet if there are multiple, due to lack of Xinerama
* handling in GHOST. */
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) { for (win = wm->windows.first; win; win = win->next) {
if (win->ghostwin == NULL) { if (win->ghostwin == NULL) {
if ((win->sizex == 0) || (wm_init_state.override_flag & WIN_OVERRIDE_GEOM)) { if (wm_init_state.override_flag & WIN_OVERRIDE_GEOM) {
win->posx = wm_init_state.start_x; /* window geometry was overriden from command line */
win->posy = wm_init_state.start_y; win->ghost_rect = wm_init_state.rect;
win->sizex = wm_init_state.size_x;
win->sizey = wm_init_state.size_y;
win->windowstate = GHOST_kWindowStateNormal; win->windowstate = GHOST_kWindowStateNormal;
wm_init_state.override_flag &= ~WIN_OVERRIDE_GEOM; wm_init_state.override_flag &= ~WIN_OVERRIDE_GEOM;
} }
else if (BLI_rcti_size_x(&win->ghost_rect) == 0) {
/* no window geometry set, use main display dimensions or user preferred size */
int width, height;
wm_window_get_main_display_dimensions(&width, &height);
#ifdef WITH_X11
/* X11, don't start maximized because we can't figure out the dimensions
* of a single display yet if there are multiple, due to lack of Xinerama
* handling in GHOST. */
width -= WM_WIN_INIT_PAD * 2;
height -= WM_WIN_INIT_PAD * 2;
#endif
wm_window_size_position(win, width, height);
}
if (wm_init_state.override_flag & WIN_OVERRIDE_WINSTATE) { if (wm_init_state.override_flag & WIN_OVERRIDE_WINSTATE) {
win->windowstate = wm_init_state.windowstate; win->windowstate = wm_init_state.windowstate;
Context not available.
} }
/** /**
* Uses `screen->temp` tag to define what to do, currently it limits * Creates a "temp" window, used for render, preferences.
* to only one "temp" window for render out, preferences, filewindow, etc...
* *
* \param sizex, sizey: recommended initial size of window
* \param type: WM_WINDOW_RENDER, WM_WINDOW_USERPREFS... * \param type: WM_WINDOW_RENDER, WM_WINDOW_USERPREFS...
* \return the window or NULL. * \return the window or NULL.
*/ */
wmWindow *WM_window_open_temp(bContext *C, int x, int y, int sizex, int sizey, int type) wmWindow *WM_window_open_temp(bContext *C, int sizex, int sizey, int type)
{ {
Main *bmain = CTX_data_main(C); Main *bmain = CTX_data_main(C);
wmWindow *win_prev = CTX_wm_window(C); wmWindow *win_prev = CTX_wm_window(C);
Context not available.
ScrArea *sa; ScrArea *sa;
Scene *scene = CTX_data_scene(C); Scene *scene = CTX_data_scene(C);
ViewLayer *view_layer = CTX_data_view_layer(C); ViewLayer *view_layer = CTX_data_view_layer(C);
const char *title;
/* convert to native OS window coordinates */
const float native_pixel_size = GHOST_GetNativePixelSize(win_prev->ghostwin);
x /= native_pixel_size;
y /= native_pixel_size;
sizex /= native_pixel_size;
sizey /= native_pixel_size;
/* calculate position */ /* test if we have a temp screen of this type already */
rcti rect;
rect.xmin = x + win_prev->posx - sizex / 2;
rect.ymin = y + win_prev->posy - sizey / 2;
rect.xmax = rect.xmin + sizex;
rect.ymax = rect.ymin + sizey;
/* changes rect to fit within desktop */
wm_window_check_position(&rect);
/* test if we have a temp screen already */
for (win = CTX_wm_manager(C)->windows.first; win; win = win->next) for (win = CTX_wm_manager(C)->windows.first; win; win = win->next)
if (WM_window_is_temp_screen(win)) if (WM_window_is_temp_screen(win) && win->type == type)
break; break;
/* add new window? */ /* create new window if required */
if (win == NULL) { if (win == NULL) {
win = wm_window_new(C, win_prev); win = wm_window_new(C, win_prev);
win->posx = rect.xmin;
win->posy = rect.ymin;
} }
win->type = type;
screen = WM_window_get_active_screen(win); screen = WM_window_get_active_screen(win);
win->sizex = BLI_rcti_size_x(&rect); /* assign a size and position to the window */
win->sizey = BLI_rcti_size_y(&rect); wm_window_size_position(win, sizex, sizey);
if (win->ghostwin) { if (win->ghostwin) {
wm_window_set_size(win, win->sizex, win->sizey);
wm_window_raise(win); wm_window_raise(win);
} }
Context not available.
ED_drivers_editor_init(C, sa); ED_drivers_editor_init(C, sa);
} }
if (sa->spacetype == SPACE_IMAGE)
title = IFACE_("Blender Render");
else if (ELEM(sa->spacetype, SPACE_OUTLINER, SPACE_USERPREF))
title = IFACE_("Blender Preferences");
else if (sa->spacetype == SPACE_FILE)
title = IFACE_("Blender File View");
else if (sa->spacetype == SPACE_IPO)
title = IFACE_("Blender Drivers Editor");
else
title = "Blender";
if (win->ghostwin) { if (win->ghostwin) {
GHOST_SetTitle(win->ghostwin, title); /* update title after setting space type */
wm_window_title(NULL, win);
return win; return win;
} }
else { else {
Context not available.
} }
} }
/* ****************** Operators ****************** */ /* ****************** Operators ****************** */
int wm_window_close_exec(bContext *C, wmOperator *UNUSED(op)) int wm_window_close_exec(bContext *C, wmOperator *UNUSED(op))
Context not available.
} }
/* ************ events *************** */ /* ************ events *************** */
void wm_cursor_position_from_ghost(wmWindow *win, int *x, int *y) void wm_cursor_position_from_ghost(wmWindow *win, int *x, int *y)
Context not available.
/* win32: gives undefined window size when minimized */ /* win32: gives undefined window size when minimized */
if (state != GHOST_kWindowStateMinimized) { if (state != GHOST_kWindowStateMinimized) {
GHOST_RectangleHandle client_rect; short sizex, sizey, posx, posy;
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_window_get_client_bounds(win, &posx, &posy, &sizex, &sizey);
wm_get_desktopsize(&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. * Ghost sometimes send size or move events when the window hasn't changed.
Context not available.
/* bContext can be null in background mode because we don't /* bContext can be null in background mode because we don't
* need to event handling. */ * need to event handling. */
void wm_ghost_init(bContext *C) void wm_window_init(bContext *C)
{ {
if (!g_system) { if (!g_system) {
GHOST_EventConsumerHandle consumer; GHOST_EventConsumerHandle consumer;
wm_window_positions_file_read(&window_positions);
if (C != NULL) { if (C != NULL) {
consumer = GHOST_CreateEventConsumer(ghost_event_proc, C); consumer = GHOST_CreateEventConsumer(ghost_event_proc, C);
} }
Context not available.
} }
} }
void wm_ghost_exit(void) void wm_window_exit(void)
{ {
if (g_system) if (g_system)
GHOST_DisposeSystem(g_system); GHOST_DisposeSystem(g_system);
wm_window_positions_file_write(&window_positions);
BLI_freelistN(&window_positions);
g_system = NULL; g_system = NULL;
} }
Context not available.
/* ******************* exported api ***************** */ /* ******************* exported api ***************** */
/* called whem no ghost system was initialized */ /* called whem no ghost system was initialized */
void WM_init_state_size_set(int stax, int stay, int sizx, int sizy) void WM_init_state_size_set(int stax, int stay, int sizx, int sizy)
{ {
wm_init_state.start_x = stax; /* left hand pos */ rcti *rect = &wm_init_state.rect;
wm_init_state.start_y = stay; /* bottom pos */ int width = MAX2(sizx, MINIMUM_WINDOW_WIDTH);
wm_init_state.size_x = sizx < 640 ? 640 : sizx; int height = MAX2(sizy, MINIMUM_WINDOW_HEIGHT);
wm_init_state.size_y = sizy < 480 ? 480 : sizy;
BLI_rcti_init(rect, stax, stax + width, stay, stay + height);
wm_init_state.override_flag |= WIN_OVERRIDE_GEOM; wm_init_state.override_flag |= WIN_OVERRIDE_GEOM;
} }
Context not available.