Brecht Van Lommel
d93fd9ffc1
* Screen level regions created for menus are now a separate CTX_wm_menu in the context, so they don't interfere with existing regions. * Fix context in popup menus to always come from the area and region the popup was opened from. * Removed some unused context stuff: tasks and reports. The places that were using context reports were using it wrong anyway. * Fix F6 closing immediately after editing a button, by making uiBlockSetFlag not clear existing flags anymore. * Don't use ":" in boolean X/Y/Z buttons.
689 lines
17 KiB
C
689 lines
17 KiB
C
/**
|
|
* $Id:
|
|
*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2007 Blender Foundation.
|
|
* All rights reserved.
|
|
*
|
|
*
|
|
* Contributor(s): Blender Foundation
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <GL/glew.h>
|
|
|
|
#include "DNA_listBase.h"
|
|
#include "DNA_screen_types.h"
|
|
#include "DNA_windowmanager_types.h"
|
|
#include "DNA_userdef_types.h"
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
|
|
#include "BKE_context.h"
|
|
#include "BKE_global.h"
|
|
|
|
#include "ED_screen.h"
|
|
|
|
#include "WM_api.h"
|
|
#include "WM_types.h"
|
|
#include "wm.h"
|
|
#include "wm_draw.h"
|
|
#include "wm_window.h"
|
|
#include "wm_event_system.h"
|
|
|
|
/* swap */
|
|
#define WIN_NONE_OK 0
|
|
#define WIN_BACK_OK 1
|
|
#define WIN_FRONT_OK 2
|
|
#define WIN_BOTH_OK 3
|
|
|
|
/* ********************* drawing, swap ****************** */
|
|
|
|
static void wm_paintcursor_draw(bContext *C, ARegion *ar)
|
|
{
|
|
wmWindowManager *wm= CTX_wm_manager(C);
|
|
|
|
if(wm->paintcursors.first) {
|
|
wmWindow *win= CTX_wm_window(C);
|
|
bScreen *screen= win->screen;
|
|
wmPaintCursor *pc;
|
|
|
|
if(screen->subwinactive == ar->swinid) {
|
|
for(pc= wm->paintcursors.first; pc; pc= pc->next) {
|
|
if(pc->poll(C)) {
|
|
ARegion *ar= CTX_wm_region(C);
|
|
pc->draw(C, win->eventstate->x - ar->winrct.xmin, win->eventstate->y - ar->winrct.ymin, pc->customdata);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/********************** draw all **************************/
|
|
/* - reference method, draw all each time */
|
|
|
|
static void wm_method_draw_full(bContext *C, wmWindow *win)
|
|
{
|
|
bScreen *screen= win->screen;
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
|
|
/* draw area regions */
|
|
for(sa= screen->areabase.first; sa; sa= sa->next) {
|
|
CTX_wm_area_set(C, sa);
|
|
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid) {
|
|
CTX_wm_region_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
wm_paintcursor_draw(C, ar);
|
|
ED_area_overdraw_flush(C, sa, ar);
|
|
CTX_wm_region_set(C, NULL);
|
|
}
|
|
}
|
|
|
|
CTX_wm_area_set(C, NULL);
|
|
}
|
|
|
|
ED_screen_draw(win);
|
|
ED_area_overdraw(C);
|
|
|
|
/* draw overlapping regions */
|
|
for(ar=screen->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid) {
|
|
CTX_wm_menu_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
CTX_wm_menu_set(C, NULL);
|
|
}
|
|
}
|
|
|
|
if(screen->do_draw_gesture)
|
|
wm_gesture_draw(win);
|
|
}
|
|
|
|
/****************** draw overlap all **********************/
|
|
/* - redraw marked areas, and anything that overlaps it */
|
|
/* - it also handles swap exchange optionally, assuming */
|
|
/* that on swap no clearing happens and we get back the */
|
|
/* same buffer as we swapped to the front */
|
|
|
|
/* mark area-regions to redraw if overlapped with rect */
|
|
static void wm_flush_regions_down(bScreen *screen, rcti *dirty)
|
|
{
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
|
|
for(sa= screen->areabase.first; sa; sa= sa->next) {
|
|
for(ar= sa->regionbase.first; ar; ar= ar->next) {
|
|
if(BLI_isect_rcti(dirty, &ar->winrct, NULL)) {
|
|
ar->do_draw= 1;
|
|
memset(&ar->drawrct, 0, sizeof(ar->drawrct));
|
|
ar->swap= WIN_NONE_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* mark menu-regions to redraw if overlapped with rect */
|
|
static void wm_flush_regions_up(bScreen *screen, rcti *dirty)
|
|
{
|
|
ARegion *ar;
|
|
|
|
for(ar= screen->regionbase.first; ar; ar= ar->next) {
|
|
if(BLI_isect_rcti(dirty, &ar->winrct, NULL)) {
|
|
ar->do_draw= 1;
|
|
memset(&ar->drawrct, 0, sizeof(ar->drawrct));
|
|
ar->swap= WIN_NONE_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void wm_method_draw_overlap_all(bContext *C, wmWindow *win)
|
|
{
|
|
bScreen *screen= win->screen;
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
int exchange= (G.f & G_SWAP_EXCHANGE);
|
|
|
|
/* flush overlapping regions */
|
|
if(screen->regionbase.first) {
|
|
/* flush redraws of area regions up to overlapping regions */
|
|
for(sa= screen->areabase.first; sa; sa= sa->next)
|
|
for(ar= sa->regionbase.first; ar; ar= ar->next)
|
|
if(ar->swinid && ar->do_draw)
|
|
wm_flush_regions_up(screen, &ar->winrct);
|
|
|
|
/* flush between overlapping regions */
|
|
for(ar= screen->regionbase.last; ar; ar= ar->prev)
|
|
if(ar->swinid && ar->do_draw)
|
|
wm_flush_regions_up(screen, &ar->winrct);
|
|
|
|
/* flush redraws of overlapping regions down to area regions */
|
|
for(ar= screen->regionbase.last; ar; ar= ar->prev)
|
|
if(ar->swinid && ar->do_draw)
|
|
wm_flush_regions_down(screen, &ar->winrct);
|
|
}
|
|
|
|
/* draw marked area regions */
|
|
for(sa= screen->areabase.first; sa; sa= sa->next) {
|
|
CTX_wm_area_set(C, sa);
|
|
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid) {
|
|
if(ar->do_draw) {
|
|
CTX_wm_region_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
wm_paintcursor_draw(C, ar);
|
|
ED_area_overdraw_flush(C, sa, ar);
|
|
CTX_wm_region_set(C, NULL);
|
|
|
|
if(exchange)
|
|
ar->swap= WIN_FRONT_OK;
|
|
}
|
|
else if(exchange) {
|
|
if(ar->swap == WIN_FRONT_OK) {
|
|
CTX_wm_region_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
wm_paintcursor_draw(C, ar);
|
|
ED_area_overdraw_flush(C, sa, ar);
|
|
CTX_wm_region_set(C, NULL);
|
|
|
|
ar->swap= WIN_BOTH_OK;
|
|
printf("draws swap exchange %d\n", ar->swinid);
|
|
}
|
|
else if(ar->swap == WIN_BACK_OK)
|
|
ar->swap= WIN_FRONT_OK;
|
|
else if(ar->swap == WIN_BOTH_OK)
|
|
ar->swap= WIN_BOTH_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
CTX_wm_area_set(C, NULL);
|
|
}
|
|
|
|
/* after area regions so we can do area 'overlay' drawing */
|
|
if(screen->do_draw) {
|
|
ED_screen_draw(win);
|
|
|
|
if(exchange)
|
|
screen->swap= WIN_FRONT_OK;
|
|
}
|
|
else if(exchange) {
|
|
if(screen->swap==WIN_FRONT_OK) {
|
|
ED_screen_draw(win);
|
|
screen->swap= WIN_BOTH_OK;
|
|
}
|
|
else if(screen->swap==WIN_BACK_OK)
|
|
screen->swap= WIN_FRONT_OK;
|
|
else if(screen->swap==WIN_BOTH_OK)
|
|
screen->swap= WIN_BOTH_OK;
|
|
}
|
|
|
|
ED_area_overdraw(C);
|
|
|
|
/* draw marked overlapping regions */
|
|
for(ar=screen->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid && ar->do_draw) {
|
|
CTX_wm_menu_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
CTX_wm_menu_set(C, NULL);
|
|
}
|
|
}
|
|
|
|
if(screen->do_draw_gesture)
|
|
wm_gesture_draw(win);
|
|
}
|
|
|
|
#if 0
|
|
/******************** draw damage ************************/
|
|
/* - not implemented */
|
|
|
|
static void wm_method_draw_damage(bContext *C, wmWindow *win)
|
|
{
|
|
wm_method_draw_all(C, win);
|
|
}
|
|
#endif
|
|
|
|
/****************** draw triple buffer ********************/
|
|
/* - area regions are written into a texture, without any */
|
|
/* of the overlapping menus, brushes, gestures. these */
|
|
/* are redrawn each time. */
|
|
/* */
|
|
/* - if non-power of two textures are supported, that is */
|
|
/* used. if not, multiple smaller ones are used, with */
|
|
/* worst case wasted space being 23.4% for 3x3 textures */
|
|
|
|
#define MAX_N_TEX 3
|
|
|
|
typedef struct wmDrawTriple {
|
|
GLuint bind[MAX_N_TEX*MAX_N_TEX];
|
|
int x[MAX_N_TEX], y[MAX_N_TEX];
|
|
int nx, ny;
|
|
GLenum target;
|
|
} wmDrawTriple;
|
|
|
|
static int is_pow2(int n)
|
|
{
|
|
return ((n)&(n-1))==0;
|
|
}
|
|
|
|
static int smaller_pow2(int n)
|
|
{
|
|
while (!is_pow2(n))
|
|
n= n&(n-1);
|
|
|
|
return n;
|
|
}
|
|
|
|
static int larger_pow2(int n)
|
|
{
|
|
if (is_pow2(n))
|
|
return n;
|
|
|
|
while(!is_pow2(n))
|
|
n= n&(n-1);
|
|
|
|
return n*2;
|
|
}
|
|
|
|
static void split_width(int x, int n, int *splitx, int *nx)
|
|
{
|
|
int a, newnx, waste;
|
|
|
|
/* if already power of two just use it */
|
|
if(is_pow2(x)) {
|
|
splitx[0]= x;
|
|
(*nx)++;
|
|
return;
|
|
}
|
|
|
|
if(n == 1) {
|
|
/* last part, we have to go larger */
|
|
splitx[0]= larger_pow2(x);
|
|
(*nx)++;
|
|
}
|
|
else {
|
|
/* two or more parts to go, use smaller part */
|
|
splitx[0]= smaller_pow2(x);
|
|
newnx= ++(*nx);
|
|
split_width(x-splitx[0], n-1, splitx+1, &newnx);
|
|
|
|
for(waste=0, a=0; a<n; a++)
|
|
waste += splitx[a];
|
|
|
|
/* if we waste more space or use the same amount,
|
|
* revert deeper splits and just use larger */
|
|
if(waste >= larger_pow2(x)) {
|
|
splitx[0]= larger_pow2(x);
|
|
memset(splitx+1, 0, sizeof(int)*(n-1));
|
|
}
|
|
else
|
|
*nx= newnx;
|
|
}
|
|
}
|
|
|
|
static void wm_draw_triple_free(wmWindow *win)
|
|
{
|
|
if(win->drawdata) {
|
|
wmDrawTriple *triple= win->drawdata;
|
|
|
|
glDeleteTextures(triple->nx*triple->ny, triple->bind);
|
|
MEM_freeN(triple);
|
|
|
|
win->drawdata= NULL;
|
|
}
|
|
}
|
|
|
|
static void wm_draw_triple_fail(bContext *C, wmWindow *win)
|
|
{
|
|
wm_draw_window_clear(win);
|
|
|
|
win->drawfail= 1;
|
|
wm_method_draw_overlap_all(C, win);
|
|
}
|
|
|
|
static int wm_triple_gen_textures(wmWindow *win, wmDrawTriple *triple)
|
|
{
|
|
GLint maxsize;
|
|
int x, y;
|
|
|
|
/* compute texture sizes */
|
|
if(GLEW_ARB_texture_rectangle || GLEW_NV_texture_rectangle || GLEW_EXT_texture_rectangle) {
|
|
triple->target= GL_TEXTURE_RECTANGLE_ARB;
|
|
triple->nx= 1;
|
|
triple->ny= 1;
|
|
triple->x[0]= win->sizex;
|
|
triple->y[0]= win->sizey;
|
|
}
|
|
else if(GLEW_ARB_texture_non_power_of_two) {
|
|
triple->target= GL_TEXTURE_2D;
|
|
triple->nx= 1;
|
|
triple->ny= 1;
|
|
triple->x[0]= win->sizex;
|
|
triple->y[0]= win->sizey;
|
|
}
|
|
else {
|
|
triple->target= GL_TEXTURE_2D;
|
|
triple->nx= 0;
|
|
triple->ny= 0;
|
|
split_width(win->sizex, MAX_N_TEX, triple->x, &triple->nx);
|
|
split_width(win->sizey, MAX_N_TEX, triple->y, &triple->ny);
|
|
}
|
|
|
|
/* generate texture names */
|
|
glGenTextures(triple->nx*triple->ny, triple->bind);
|
|
|
|
if(!triple->bind[0]) {
|
|
/* not the typical failure case but we handle it anyway */
|
|
printf("WM: failed to allocate texture for triple buffer drawing (glGenTextures).\n");
|
|
return 0;
|
|
}
|
|
|
|
for(y=0; y<triple->ny; y++) {
|
|
for(x=0; x<triple->nx; x++) {
|
|
/* proxy texture is only guaranteed to test for the cases that
|
|
* there is only one texture in use, which may not be the case */
|
|
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxsize);
|
|
|
|
if(triple->x[x] > maxsize || triple->y[y] > maxsize) {
|
|
glBindTexture(triple->target, 0);
|
|
printf("WM: failed to allocate texture for triple buffer drawing (texture too large for graphics card).\n");
|
|
return 0;
|
|
}
|
|
|
|
/* setup actual texture */
|
|
glBindTexture(triple->target, triple->bind[x + y*triple->nx]);
|
|
glTexImage2D(triple->target, 0, GL_RGB8, triple->x[x], triple->y[y], 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
|
|
glTexParameteri(triple->target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
|
|
glTexParameteri(triple->target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
|
|
// glColor still used with this enabled?
|
|
// glTexEnvi(triple->target, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
glBindTexture(triple->target, 0);
|
|
|
|
/* not sure if this works everywhere .. */
|
|
if(glGetError() == GL_OUT_OF_MEMORY) {
|
|
printf("WM: failed to allocate texture for triple buffer drawing (out of memory).\n");
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void wm_triple_draw_textures(wmWindow *win, wmDrawTriple *triple)
|
|
{
|
|
float halfx, halfy, ratiox, ratioy;
|
|
int x, y, sizex, sizey, offx, offy;
|
|
|
|
glEnable(triple->target);
|
|
|
|
for(y=0, offy=0; y<triple->ny; offy+=triple->y[y], y++) {
|
|
for(x=0, offx=0; x<triple->nx; offx+=triple->x[x], x++) {
|
|
sizex= (x == triple->nx-1)? win->sizex-offx: triple->x[x];
|
|
sizey= (y == triple->ny-1)? win->sizey-offy: triple->y[y];
|
|
|
|
/* wmOrtho for the screen has this same offset */
|
|
ratiox= sizex;
|
|
ratioy= sizey;
|
|
halfx= 0.375f;
|
|
halfy= 0.375f;
|
|
|
|
/* texture rectangle has unnormalized coordinates */
|
|
if(triple->target == GL_TEXTURE_2D) {
|
|
ratiox /= triple->x[x];
|
|
ratioy /= triple->y[y];
|
|
halfx /= triple->x[x];
|
|
halfy /= triple->y[y];
|
|
}
|
|
|
|
glBindTexture(triple->target, triple->bind[x + y*triple->nx]);
|
|
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2f(halfx, halfy);
|
|
glVertex2f(offx, offy);
|
|
|
|
glTexCoord2f(ratiox+halfx, halfy);
|
|
glVertex2f(offx+sizex, offy);
|
|
|
|
glTexCoord2f(ratiox+halfx, ratioy+halfy);
|
|
glVertex2f(offx+sizex, offy+sizey);
|
|
|
|
glTexCoord2f(halfx, ratioy+halfy);
|
|
glVertex2f(offx, offy+sizey);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
glBindTexture(triple->target, 0);
|
|
glDisable(triple->target);
|
|
}
|
|
|
|
static void wm_triple_copy_textures(wmWindow *win, wmDrawTriple *triple)
|
|
{
|
|
int x, y, sizex, sizey, offx, offy;
|
|
|
|
for(y=0, offy=0; y<triple->ny; offy+=triple->y[y], y++) {
|
|
for(x=0, offx=0; x<triple->nx; offx+=triple->x[x], x++) {
|
|
sizex= (x == triple->nx-1)? win->sizex-offx: triple->x[x];
|
|
sizey= (y == triple->ny-1)? win->sizey-offy: triple->y[y];
|
|
|
|
glBindTexture(triple->target, triple->bind[x + y*triple->nx]);
|
|
glCopyTexSubImage2D(triple->target, 0, 0, 0, offx, offy, sizex, sizey);
|
|
}
|
|
}
|
|
|
|
glBindTexture(triple->target, 0);
|
|
}
|
|
|
|
static void wm_method_draw_triple(bContext *C, wmWindow *win)
|
|
{
|
|
wmWindowManager *wm= CTX_wm_manager(C);
|
|
wmDrawTriple *triple;
|
|
bScreen *screen= win->screen;
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
int copytex= 0;
|
|
|
|
if(win->drawdata) {
|
|
glClearColor(0, 0, 0, 0);
|
|
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
|
|
|
|
wmSubWindowSet(win, screen->mainwin);
|
|
|
|
wm_triple_draw_textures(win, win->drawdata);
|
|
|
|
triple= win->drawdata;
|
|
}
|
|
else {
|
|
win->drawdata= MEM_callocN(sizeof(wmDrawTriple), "wmDrawTriple");
|
|
|
|
if(!wm_triple_gen_textures(win, win->drawdata)) {
|
|
wm_draw_triple_fail(C, win);
|
|
return;
|
|
}
|
|
}
|
|
|
|
triple= win->drawdata;
|
|
|
|
/* draw marked area regions */
|
|
for(sa= screen->areabase.first; sa; sa= sa->next) {
|
|
CTX_wm_area_set(C, sa);
|
|
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid && ar->do_draw) {
|
|
CTX_wm_region_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
ED_area_overdraw_flush(C, sa, ar);
|
|
CTX_wm_region_set(C, NULL);
|
|
copytex= 1;
|
|
}
|
|
}
|
|
|
|
CTX_wm_area_set(C, NULL);
|
|
}
|
|
|
|
if(copytex) {
|
|
wmSubWindowSet(win, screen->mainwin);
|
|
ED_area_overdraw(C);
|
|
|
|
wm_triple_copy_textures(win, triple);
|
|
}
|
|
|
|
/* after area regions so we can do area 'overlay' drawing */
|
|
ED_screen_draw(win);
|
|
|
|
/* draw overlapping regions */
|
|
for(ar=screen->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid) {
|
|
CTX_wm_menu_set(C, ar);
|
|
ED_region_do_draw(C, ar);
|
|
CTX_wm_menu_set(C, NULL);
|
|
}
|
|
}
|
|
|
|
if(win->screen->do_draw_gesture)
|
|
wm_gesture_draw(win);
|
|
|
|
if(wm->paintcursors.first) {
|
|
for(sa= screen->areabase.first; sa; sa= sa->next) {
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next) {
|
|
if(ar->swinid == screen->subwinactive) {
|
|
CTX_wm_area_set(C, sa);
|
|
CTX_wm_region_set(C, ar);
|
|
|
|
wmSubWindowSet(win, ar->swinid);
|
|
ED_region_pixelspace(ar);
|
|
wm_paintcursor_draw(C, ar);
|
|
|
|
CTX_wm_region_set(C, NULL);
|
|
CTX_wm_area_set(C, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
wmSubWindowSet(win, screen->mainwin);
|
|
}
|
|
}
|
|
|
|
/****************** main update call **********************/
|
|
|
|
/* quick test to prevent changing window drawable */
|
|
static int wm_draw_update_test_window(wmWindow *win)
|
|
{
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
|
|
if(win->screen->do_refresh)
|
|
return 1;
|
|
if(win->screen->do_draw)
|
|
return 1;
|
|
if(win->screen->do_draw_gesture)
|
|
return 1;
|
|
if(win->screen->do_draw_paintcursor)
|
|
return 1;
|
|
|
|
for(ar= win->screen->regionbase.first; ar; ar= ar->next)
|
|
if(ar->swinid && ar->do_draw)
|
|
return 1;
|
|
|
|
for(sa= win->screen->areabase.first; sa; sa= sa->next)
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next)
|
|
if(ar->swinid && ar->do_draw)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void wm_draw_update(bContext *C)
|
|
{
|
|
wmWindowManager *wm= CTX_wm_manager(C);
|
|
wmWindow *win;
|
|
|
|
for(win= wm->windows.first; win; win= win->next) {
|
|
if(win->drawmethod != U.wmdrawmethod) {
|
|
wm_draw_window_clear(win);
|
|
win->drawmethod= U.wmdrawmethod;
|
|
}
|
|
|
|
if(wm_draw_update_test_window(win)) {
|
|
CTX_wm_window_set(C, win);
|
|
|
|
/* sets context window+screen */
|
|
wm_window_make_drawable(C, win);
|
|
|
|
/* notifiers for screen redraw */
|
|
if(win->screen->do_refresh)
|
|
ED_screen_refresh(wm, win);
|
|
|
|
if(win->drawfail)
|
|
wm_method_draw_overlap_all(C, win);
|
|
else if(win->drawmethod == USER_DRAW_FULL)
|
|
wm_method_draw_full(C, win);
|
|
else if(win->drawmethod == USER_DRAW_OVERLAP)
|
|
wm_method_draw_overlap_all(C, win);
|
|
/*else if(win->drawmethod == USER_DRAW_DAMAGE)
|
|
wm_method_draw_damage(C, win);*/
|
|
else // if(win->drawmethod == USER_DRAW_TRIPLE)
|
|
wm_method_draw_triple(C, win);
|
|
|
|
win->screen->do_draw_gesture= 0;
|
|
win->screen->do_draw_paintcursor= 0;
|
|
|
|
wm_window_swap_buffers(win);
|
|
|
|
CTX_wm_window_set(C, NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
void wm_draw_window_clear(wmWindow *win)
|
|
{
|
|
bScreen *screen= win->screen;
|
|
ScrArea *sa;
|
|
ARegion *ar;
|
|
|
|
if(win->drawmethod == USER_DRAW_TRIPLE)
|
|
wm_draw_triple_free(win);
|
|
|
|
/* clear screen swap flags */
|
|
if(screen) {
|
|
for(sa= screen->areabase.first; sa; sa= sa->next)
|
|
for(ar=sa->regionbase.first; ar; ar= ar->next)
|
|
ar->swap= WIN_NONE_OK;
|
|
|
|
screen->swap= WIN_NONE_OK;
|
|
}
|
|
}
|
|
|
|
void wm_draw_region_clear(wmWindow *win, ARegion *ar)
|
|
{
|
|
if(win->drawmethod == USER_DRAW_OVERLAP)
|
|
wm_flush_regions_down(win->screen, &ar->winrct);
|
|
|
|
win->screen->do_draw= 1;
|
|
}
|
|
|