More work on restoring Blender;

- brining back subwindow management
- removing more bad level stuff

source/blender/windowmanager/intern/wm_files.c

@@ -46,18 +46,12 @@
 #include "MEM_guardedalloc.h"
 #include "MEM_CacheLimiterC-Api.h"
 
-#include "BIF_language.h"
-#ifdef INTERNATIONAL
-#include "FTF_Api.h"
-#endif
-
 #include "BLI_blenlib.h"
 #include "BLI_linklist.h"
 
 #include "DNA_object_types.h"
 #include "DNA_space_types.h"
 #include "DNA_userdef_types.h"
-#include "DNA_sound_types.h"
 #include "DNA_scene_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_windowmanager_types.h"
@@ -77,24 +71,6 @@
 #include "BKE_verse.h"
 #endif
 
-#include "BIF_fsmenu.h"
-#include "BIF_interface.h"
-#include "BIF_usiblender.h" /* XXX */
-
-#include "BIF_editsound.h"
-#include "BIF_editmode_undo.h"
-#include "BIF_filelist.h"
-#include "BIF_resources.h"
-#include "BIF_screen.h"
-#include "BIF_space.h"
-#include "BIF_toolbox.h"
-
-#ifdef WITH_VERSE
-#include "BIF_verse.h"
-#endif
-
-#include "BDR_editobject.h"
-
 #include "BLO_readfile.h"
 #include "BLO_writefile.h"
 
@@ -103,6 +79,7 @@
 #include "datatoc.h"
 
 #include "WM_api.h"
+#include "WM_types.h"
 #include "wm.h"
 
 /***/

source/blender/windowmanager/intern/wm_init_exit.c

@@ -54,44 +54,12 @@
 #include "BKE_packedFile.h"
 
 #include "BMF_Api.h"
-#include "BIF_language.h"
 #ifdef INTERNATIONAL
 #include "FTF_Api.h"
 #endif
 
 #include "BLI_blenlib.h"
 
-#include "BIF_cursors.h"
-#include "BIF_drawtext.h"
-#include "BIF_editaction.h"
-#include "BIF_editarmature.h"
-#include "BIF_editlattice.h"
-#include "BIF_editfont.h"
-#include "BIF_editmesh.h"
-#include "BIF_editmode_undo.h"
-#include "BIF_editsound.h"
-#include "BIF_filelist.h"
-#include "BIF_fsmenu.h"
-#include "BIF_interface.h"
-#include "BIF_gl.h"
-#include "BIF_poseobject.h"
-#include "BIF_previewrender.h"
-#include "BIF_resources.h"
-#include "BIF_usiblender.h" /* XXX */
-
-#include "BSE_drawview.h"
-#include "BSE_edit.h"
-#include "BSE_editipo.h"
-#include "BSE_filesel.h"
-#include "BSE_headerbuttons.h"
-#include "BSE_node.h"
-
-#include "BDR_drawobject.h"
-#include "BDR_editobject.h"
-#include "BDR_editcurve.h"
-#include "BDR_imagepaint.h"
-#include "BDR_vpaint.h"
-
 #include "RE_pipeline.h"		/* RE_ free stuff */
 
 #include "radio.h"
@@ -101,6 +69,7 @@
 #include "SYS_System.h"
 
 #include "WM_api.h"
+#include "WM_types.h"
 #include "wm.h"
 #include "wm_files.h"
 #include "wm_window.h"

source/blender/windowmanager/intern/wm_operators.c

@@ -39,8 +39,6 @@
 #include "BKE_library.h"
 #include "BKE_main.h"
 
-#include "BIF_toolbox.h"
-
 #include "WM_api.h"
 #include "WM_types.h"
 #include "wm_window.h"

source/blender/windowmanager/intern/wm_subwindow.c

@@ -0,0 +1,527 @@
+/**
+ * $Id: mywindow.c 9584 2007-01-03 13:45:03Z ton $
+ *
+ * ***** 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) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * Contributor(s): 2007 Blender Foundation (refactor)
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ *
+ *
+ * Subwindow opengl handling. 
+ * BTW: subwindows open/close in X11 are way too slow, tried it, and choose for my own system... (ton)
+ * 
+ */
+
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_windowmanager_types.h"
+#include "DNA_screen_types.h"
+
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+
+#include "BKE_global.h"
+
+#include "BIF_gl.h"
+#include "BIF_glutil.h"
+
+#include "WM_api.h"
+#include "wm_window.h"
+
+/* wmSubWindow stored in wmWindow... but not exposed outside this C file */
+/* it seems a bit redundant (area regions can store it too, but we keep it
+   because we can store all kind of future opengl fanciness here */
+
+/* we use indices and array because:
+   - index has safety, no pointers from this C file hanging around
+   - fast lookups of indices with array, list would give overhead
+   - old code used it this way...
+   - keep option open to have 2 screens using same window
+*/
+
+typedef struct wmSubWindow {
+	struct wmSubWindow *next, *prev;
+	
+	rcti winrct;
+	int swinid;
+	
+	float viewmat[4][4], winmat[4][4];
+} wmSubWindow;
+
+
+/* ******************* open, free, set, get data ******************** */
+
+/* not subwindow itself */
+static void wm_subwindow_free(wmSubWindow *swin)
+{
+	/* future fancy stuff */
+}
+
+void wm_subwindows_free(wmWindow *win)
+{
+	wmSubWindow *swin;
+	
+	for(swin= win->subwindows.first; swin; swin= swin->next)
+		wm_subwindow_free(swin);
+	
+	BLI_freelistN(&win->subwindows);
+}
+
+
+void wm_subwindow_getsize(wmWindow *win, int *x, int *y) 
+{
+	if(win->curswin) {
+		wmSubWindow *swin= win->curswin;
+		*x= swin->winrct.xmax - swin->winrct.xmin + 1;
+		*y= swin->winrct.ymax - swin->winrct.ymin + 1;
+	}
+}
+
+void wm_subwindow_getorigin(wmWindow *win, int *x, int *y)
+{
+	if(win->curswin) {
+		wmSubWindow *swin= win->curswin;
+		*x= swin->winrct.xmin;
+		*y= swin->winrct.ymin;
+	}
+}
+
+int wm_subwindow_get(wmWindow *win)	
+{
+	if(win->curswin)
+		return win->curswin->swinid;
+	return 0;
+}
+
+static wmSubWindow *swin_from_swinid(wmWindow *win, int swinid)
+{
+	wmSubWindow *swin;
+	
+	for(swin= win->subwindows.first; swin; swin= swin->next)
+		if(swin->swinid==swinid)
+			break;
+	return swin;
+}
+
+void wm_subwindow_set(wmWindow *win, int swinid)
+{
+	wmSubWindow *swin= swin_from_swinid(win, swinid);
+	int width, height;
+	
+	if(swin==NULL) {
+		printf("wm_subwindow_set %d: doesn't exist\n", swinid);
+		return;
+	}
+	
+	win->curswin= swin;
+	wm_subwindow_getsize(win, &width, &height);
+	
+	glViewport(swin->winrct.xmin, swin->winrct.ymin, width, height);
+	glScissor(swin->winrct.xmin, swin->winrct.ymin, width, height);
+	
+	glMatrixMode(GL_PROJECTION);
+	glLoadMatrixf(&swin->winmat[0][0]);
+	glMatrixMode(GL_MODELVIEW);
+	glLoadMatrixf(&swin->viewmat[0][0]);
+
+	glFlush();
+	
+}
+
+/* always sets pixel-precise 2D window/view matrices */
+/* coords is in whole pixels. xmin = 15, xmax= 16: means window is 2 pix big */
+int wm_subwindow_open(wmWindow *win, rcti *winrct)
+{
+	wmSubWindow *swin;
+	int width, height;
+	int freewinid= 1;
+	
+	for(swin= win->subwindows.first; swin; swin= swin->next)
+		if(freewinid <= swin->swinid)
+			freewinid= swin->swinid+1;
+
+	win->curswin= swin= MEM_callocN(sizeof(wmSubWindow), "swinopen");
+
+	swin->swinid= freewinid;
+	swin->winrct= *winrct;
+
+	Mat4One(swin->viewmat);
+	Mat4One(swin->winmat);
+	
+	/* extra service */
+	wm_subwindow_getsize(win, &width, &height);
+	wmOrtho2(win, -0.375, (float)width-0.375, -0.375, (float)height-0.375);
+	wmLoadIdentity(win);
+	
+	/* and we appy it all right away */
+	wm_subwindow_set(win, swin->swinid);
+
+	return swin->swinid;
+}
+
+
+void wm_subwindow_close(wmWindow *win, int swinid)
+{
+	wmSubWindow *swin= swin_from_swinid(win, swinid);
+
+	if (swin) {
+		if (swin==win->curswin)
+			win->curswin= NULL;
+		wm_subwindow_free(swin);
+		BLI_remlink(&win->subwindows, swin);
+		MEM_freeN(swin);
+	} 
+	else {
+		printf("wm_subwindow_close: Internal error, bad winid: %d\n", swinid);
+	}
+
+}
+
+/* pixels go from 0-99 for a 100 pixel window */
+void wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct)
+{
+	wmSubWindow *swin= swin_from_swinid(win, swinid);
+	
+	if(swin) {
+		swin->winrct= *winrct;
+		
+		/* CRITICAL, this clamping ensures that
+			* the viewport never goes outside the screen
+			* edges (assuming the x, y coords aren't
+					 * outside). This caused a hardware lock
+			* on Matrox cards if it happens.
+			* 
+			* Really Blender should never _ever_ try
+			* to do such a thing, but just to be safe
+			* clamp it anyway (or fix the bScreen
+		    * scaling routine, and be damn sure you
+		    * fixed it). - zr  (2001!)
+			*/
+		
+		if (swin->winrct.xmax >= win->sizex)
+			swin->winrct.xmax= win->sizex-1;
+		if (swin->winrct.ymax >= win->sizey)
+			swin->winrct.ymax= win->sizey-1;
+	}
+	else {
+		printf("wm_subwindow_position: Internal error, bad winid: %d\n", swinid);
+	}
+}
+
+/* ---------------- WM versions of OpenGL calls, using glBlah() syntax ------------------------ */
+/* ----------------- exported in WM_api.h ------------------------------------------------------ */
+
+static int glaGetOneInteger(int a)
+{
+	return 0; // XXX
+}
+
+void wmLoadMatrix(wmWindow *win, float mat[][4])
+{
+	if(win->curswin==NULL) return;
+	
+	glLoadMatrixf(mat);
+	
+	if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
+		Mat4CpyMat4(win->curswin->viewmat, mat);
+	else
+		Mat4CpyMat4(win->curswin->winmat, mat);
+}
+
+void wmGetMatrix(wmWindow *win, float mat[][4])
+{
+	if(win->curswin==NULL) return;
+	
+	if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW) {
+		Mat4CpyMat4(mat, win->curswin->viewmat);
+	} else {
+		Mat4CpyMat4(mat, win->curswin->winmat);
+	}
+}
+
+void wmMultMatrix(wmWindow *win, float mat[][4])
+{
+	if(win->curswin==NULL) return;
+	
+	glMultMatrixf((float*) mat);
+	
+	if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
+		glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->viewmat);
+	else
+		glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->winmat);
+}
+
+void wmGetSingleMatrix(wmWindow *win, float mat[][4])
+{
+	if(win->curswin)
+		Mat4MulMat4(mat, win->curswin->viewmat, win->curswin->winmat);
+}
+
+void wmScale(wmWindow *win, float x, float y, float z)
+{
+	if(win->curswin==NULL) return;
+	
+	glScalef(x, y, z);
+	
+	if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
+		glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->viewmat);
+	else
+		glGetFloatv(GL_MODELVIEW_MATRIX, (float *)win->curswin->winmat);
+	
+}
+
+void wmLoadIdentity(wmWindow *win)
+{
+	if(win->curswin==NULL) return;
+	
+	if (glaGetOneInteger(GL_MATRIX_MODE)==GL_MODELVIEW)
+		Mat4One(win->curswin->viewmat);
+	else
+		Mat4One(win->curswin->winmat);
+	
+	glLoadIdentity();
+}
+
+void wmFrustum(wmWindow *win, float x1, float x2, float y1, float y2, float n, float f)
+{
+	if(win->curswin) {
+
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		glFrustum(x1, x2, y1, y2, n, f);
+
+		glGetFloatv(GL_PROJECTION_MATRIX, (float *)win->curswin->winmat);
+		glMatrixMode(GL_MODELVIEW);
+	}
+}
+
+void wmOrtho(wmWindow *win, float x1, float x2, float y1, float y2, float n, float f)
+{
+	if(win->curswin) {
+		
+		glMatrixMode(GL_PROJECTION);
+		glLoadIdentity();
+		
+		glOrtho(x1, x2, y1, y2, n, f);
+		
+		glGetFloatv(GL_PROJECTION_MATRIX, (float *)win->curswin->winmat);
+		glMatrixMode(GL_MODELVIEW);
+	}
+}
+
+void wmOrtho2(wmWindow *win, float x1, float x2, float y1, float y2)
+{
+	/* prevent opengl from generating errors */
+	if(x1==x2) x2+=1.0;
+	if(y1==y2) y2+=1.0;
+	wmOrtho(win, x1, x2, y1, y2, -100, 100);
+}
+
+
+/* *************************** Framebuffer color depth, for selection codes ********************** */
+
+static int wm_get_colordepth(void)
+{
+	static int mainwin_color_depth= 0;	
+	
+	if(mainwin_color_depth==0) {
+		GLint r, g, b;
+		
+		glGetIntegerv(GL_RED_BITS, &r);
+		glGetIntegerv(GL_GREEN_BITS, &g);
+		glGetIntegerv(GL_BLUE_BITS, &b);
+		
+		mainwin_color_depth= r + g + b;
+		if(G.f & G_DEBUG) {
+			printf("Color depth r %d g %d b %d\n", (int)r, (int)g, (int)b);
+			glGetIntegerv(GL_AUX_BUFFERS, &r);
+			printf("Aux buffers: %d\n", (int)r);
+		}
+	}
+	return mainwin_color_depth;
+}
+
+
+#ifdef __APPLE__
+
+/* apple seems to round colors to below and up on some configs */
+
+static unsigned int index_to_framebuffer(int index)
+{
+	unsigned int i= index;
+
+	switch(wm_get_colordepth()) {
+	case 12:
+		i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
+		/* sometimes dithering subtracts! */
+		i |= 0x070707;
+		break;
+	case 15:
+	case 16:
+		i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
+		i |= 0x030303;
+		break;
+	case 24:
+		break;
+	default:	// 18 bits... 
+		i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
+		i |= 0x010101;
+		break;
+	}
+	
+	return i;
+}
+
+#else
+
+/* this is the old method as being in use for ages.... seems to work? colors are rounded to lower values */
+
+static unsigned int index_to_framebuffer(int index)
+{
+	unsigned int i= index;
+	
+	switch(wm_get_colordepth()) {
+		case 8:
+			i= ((i & 48)<<18) + ((i & 12)<<12) + ((i & 3)<<6);
+			i |= 0x3F3F3F;
+			break;
+		case 12:
+			i= ((i & 0xF00)<<12) + ((i & 0xF0)<<8) + ((i & 0xF)<<4);
+			/* sometimes dithering subtracts! */
+			i |= 0x0F0F0F;
+			break;
+		case 15:
+		case 16:
+			i= ((i & 0x7C00)<<9) + ((i & 0x3E0)<<6) + ((i & 0x1F)<<3);
+			i |= 0x070707;
+			break;
+		case 24:
+			break;
+		default:	// 18 bits... 
+			i= ((i & 0x3F000)<<6) + ((i & 0xFC0)<<4) + ((i & 0x3F)<<2);
+			i |= 0x030303;
+			break;
+	}
+	
+	return i;
+}
+
+#endif
+
+void set_framebuffer_index_color(int index)
+{
+	cpack(index_to_framebuffer(index));
+}
+
+int framebuffer_to_index(unsigned int col)
+{
+	if (col==0) return 0;
+
+	switch(wm_get_colordepth()) {
+	case 8:
+		return ((col & 0xC00000)>>18) + ((col & 0xC000)>>12) + ((col & 0xC0)>>6);
+	case 12:
+		return ((col & 0xF00000)>>12) + ((col & 0xF000)>>8) + ((col & 0xF0)>>4);
+	case 15:
+	case 16:
+		return ((col & 0xF80000)>>9) + ((col & 0xF800)>>6) + ((col & 0xF8)>>3);
+	case 24:
+		return col & 0xFFFFFF;
+	default: // 18 bits...
+		return ((col & 0xFC0000)>>6) + ((col & 0xFC00)>>4) + ((col & 0xFC)>>2);
+	}		
+}
+
+
+/* ********** END MY WINDOW ************** */
+
+#ifdef WIN32
+static int is_a_really_crappy_nvidia_card(void) {
+	static int well_is_it= -1;
+
+		/* Do you understand the implication? Do you? */
+	if (well_is_it==-1)
+		well_is_it= (strcmp((char*) glGetString(GL_VENDOR), "NVIDIA Corporation") == 0);
+
+	return well_is_it;
+}
+#endif
+
+void myswapbuffers(void)	/* XXX */
+{
+	ScrArea *sa;
+	
+	sa= G.curscreen->areabase.first;
+	while(sa) {
+		if(sa->win_swap==WIN_BACK_OK) sa->win_swap= WIN_FRONT_OK;
+		if(sa->head_swap==WIN_BACK_OK) sa->head_swap= WIN_FRONT_OK;
+		
+		sa= sa->next;
+	}
+
+	/* HACK, some windows drivers feel they should honor the scissor
+	 * test when swapping buffers, disable the test while swapping
+	 * on WIN32. (namely Matrox and NVidia's new drivers around Oct 1 2001)
+	 * - zr
+	 */
+
+#ifdef WIN32
+		/* HACK, in some NVidia driver release some kind of
+		 * fancy optimiziation (I presume) was put in which for
+		 * some reason causes parts of the buffer not to be
+		 * swapped. One way to defeat it is the following wierd
+		 * code (which we only do for nvidia cards). This should
+		 * be removed if NVidia fixes their drivers. - zr
+		 */
+	if (is_a_really_crappy_nvidia_card()) {
+		glDrawBuffer(GL_FRONT);
+
+		glBegin(GL_LINES);
+		glEnd();
+
+		glDrawBuffer(GL_BACK);
+	}
+
+	glDisable(GL_SCISSOR_TEST);
+//	window_swap_buffers(winlay_mainwindow);
+	glEnable(GL_SCISSOR_TEST);
+#else
+//	window_swap_buffers(winlay_mainwindow);
+#endif
+}
+
+
+/* *********************** PATTERNS ETC ***************** */
+
+void setlinestyle(int nr)	/* Move? XXX */
+{
+	if(nr==0) {
+		glDisable(GL_LINE_STIPPLE);
+	}
+	else {
+		
+		glEnable(GL_LINE_STIPPLE);
+		glLineStipple(nr, 0xAAAA);
+	}
+}
+

source/blender/windowmanager/intern/wm_window.c

@@ -48,6 +48,7 @@
 #include "WM_api.h"
 #include "wm.h"
 #include "wm_window.h"
+#include "wm_subwindow.h"
 #include "wm_event_system.h"
 
 /* the global to talk to ghost */
@@ -103,10 +104,10 @@ void wm_window_free(bContext *C, wmWindow *win)
 	
 	if(win->eventstate) MEM_freeN(win->eventstate);
 	
-	BLI_freelistN(&win->queue);
 	wm_event_free_handlers(&win->handlers);
-	
 	wm_event_free_all(win);
+	wm_subwindows_free(win);
+	
 	wm_ghostwindow_destroy(win);
 	
 	MEM_freeN(win);
@@ -238,9 +239,11 @@ void wm_window_add_ghostwindows(wmWindowManager *wm)
 		wm_get_screensize(&prefsizx, &prefsizy);
 		
 #ifdef __APPLE__
-		extern void wm_set_apple_prefsize(int, int);	/* wm_apple.c */
+		{
+			extern void wm_set_apple_prefsize(int, int);	/* wm_apple.c */
 		
-		wm_set_apple_prefsize(prefsizx, prefsizy);
+			wm_set_apple_prefsize(prefsizx, prefsizy);
+		}
 #else
 		prefstax= 0;
 		prefstay= 0;