2.5 Branch

==========

* Changed wmOperatorType, removing init/exit callbacks and adding cancel
  callback, removed default storage in favor of properties. Defined return
  values for exec/invoke/modal/cancel.
* Don't allocate operator on the stack, and removed operator copy for
  handlers. Now it frees based on return values from callbacks, and just
  keeps a wmOperator on the heap. Also it now registers after the operator
  is fully finished, to get the correct final properties.
* Changed OP_get_* functions to return 1 if the property is found and 0
  otherwise, gives more readable code in my opinion. Added OP_verify_*
  functions to quickly check if the property is available and set if it's
  not, that's common for exec/invoke.
* Removed WM_operatortypelist_append in favor of WM_operatortype_append
  which takes a function pointer instead of a list, avoids macro's and
  duplicating code.
* Fix a crash where the handler would still be used while it was freed by
  the operator.

* Spacetypes now have operatortypes() and keymap() callbacks to abstract
  them a bit more.
* Renamed C->curarea to C->area for consistency. Removed View3D/View2D/
  SpaceIpo from bContext, seems bad to keep these.
* Set context variables like window/screen/area/region to NULL again when
  leaving that context, instead of leaving the pointers there.

* Added if(G.f & G_DEBUG) for many of the prints, makes output a bit
  cleaner and easier to debug.
* Fixed priority of the editors/interface module in scons, would otherwise
  give link errors.

* Added start of generic view2d api.
* Added space_time with some basic drawing and a single operator to change
  the frame.

10 files changed, 321 insertions, 156 deletions

diff --git a/source/blender/windowmanager/WM_api.h b/source/blender/windowmanager/WM_api.h
index 64abda4a849..6b020a07fb9 100644
--- a/source/blender/windowmanager/WM_api.h
+++ b/source/blender/windowmanager/WM_api.h
@@ -65,6 +65,7 @@ void		WM_keymap_verify_item(ListBase *lb, char *idname, short type,
 void		WM_keymap_add_item	(ListBase *lb, char *idname, short type, 
 								 short val, int modifier, short keymodifier);
 struct wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers);
+void		WM_event_remove_keymap_handler(ListBase *keymap, ListBase *handlers);
 struct wmEventHandler *WM_event_add_modal_handler(ListBase *handlers, wmOperator *op);
 void		WM_event_remove_modal_handler(ListBase *handlers, wmOperator *op);
 
@@ -81,7 +82,7 @@ int			WM_operator_winactive	(struct bContext *C);
 
 			/* operator api */
 wmOperatorType *WM_operatortype_find(const char *idname);
-void		WM_operatortypelist_append(ListBase *lb);
+void		WM_operatortype_append(void (*opfunc)(wmOperatorType*));
 
 /* 
  * Operator property api
@@ -98,10 +99,13 @@ void		WM_operatortypelist_append(ListBase *lb);
  * I really think that is better duplicate the string, so we are
  * really sure that the property data don't change.
  *
- * OP_get_int/float/array return 0 on success (found the property)
- * or != 0 if can't found the property in the operator.
+ * OP_get_int/float/array return 1 on success (found the property)
+ * or 0 if can't find the property in the operator.
  * The property value are store in the "value" pointer.
  *
+ * OP_verify_* sets the value only if it wasn't set already, and
+ * returns the existing or new value.
+ *
  * Both array function copy the property data into the "array"
  * pointer, but you need init the len pointer to the "array" size.
  *
@@ -128,6 +132,12 @@ char *OP_get_string(wmOperator *op, char *name);
 int OP_get_int_array(wmOperator *op, char *name, int *array, short *len);
 int OP_get_float_array(wmOperator *op, char *name, float *array, short *len);
 
+void OP_verify_int(wmOperator *op, char *name, int value, int *result);
+void OP_verify_float(wmOperator *op, char *name, float value, int *result);
+char *OP_verify_string(wmOperator *op, char *name, char *str);
+void OP_verify_int_array(wmOperator *op, char *name, int *array, short len, int *resultarray, short *resultlen);
+void OP_verify_float_array(wmOperator *op, char *name, float *array, short len, float *resultarray, short *resultlen);
+
 /*
  * Need call this function in the "exit callback"
  * of the operator, but only if you use the property system.
@@ -135,9 +145,9 @@ int OP_get_float_array(wmOperator *op, char *name, float *array, short *len);
 void OP_free_property(wmOperator *op);
 
 			/* Gesture manager API */
-void WM_gesture_init(bContext *C, int type);
-void WM_gesture_update(bContext *C, struct wmGesture *from);
-void WM_gesture_end(bContext *C, int type);
+void WM_gesture_init(struct bContext *C, int type);
+void WM_gesture_update(struct bContext *C, struct wmGesture *from);
+void WM_gesture_end(struct bContext *C, int type);
 void WM_gesture_free(wmWindow *win);
 
 			/* OpenGL wrappers, mimicing opengl syntax */
diff --git a/source/blender/windowmanager/intern/wm.c b/source/blender/windowmanager/intern/wm.c
index bc24895874e..d40fd751162 100644
--- a/source/blender/windowmanager/intern/wm.c
+++ b/source/blender/windowmanager/intern/wm.c
@@ -47,24 +47,28 @@
 #include "ED_screen.h"
 
 /* ****************************************************** */
+
 #define MAX_OP_REGISTERED	32
 
+void wm_operator_free(wmOperator *op)
+{
+	OP_free_property(op);
+	MEM_freeN(op);
+}
+
 /* all operations get registered in the windowmanager here */
 /* called on event handling by event_system.c */
 void wm_operator_register(wmWindowManager *wm, wmOperator *op)
 {
-	wmOperator *opc= MEM_callocN(sizeof(wmOperator), "operator registry");
 	int tot;
 	
-	*opc= *op;
-	BLI_addtail(&wm->operators, opc);
-	
+	BLI_addtail(&wm->operators, op);
 	tot= BLI_countlist(&wm->operators);
 	
 	while(tot>MAX_OP_REGISTERED) {
 		wmOperator *opt= wm->operators.first;
 		BLI_remlink(&wm->operators, opt);
-		MEM_freeN(opt);
+		wm_operator_free(opt);
 		tot--;
 	}
 }
@@ -95,15 +99,11 @@ void wm_check(bContext *C)
 	/* case: no open windows at all, for old file reads */
 	wm_window_add_ghostwindows(C->wm);
 	
-	if(C->window==NULL) {
-		wm_window_make_drawable(C, C->wm->windrawable); 
-	}
-	
 	/* case: fileread */
 	if(C->wm->initialized==0) {
 		
 		wm_window_keymap(C->wm);
-		ed_screen_keymap(C->wm);
+		ED_spacetypes_keymap(C->wm);
 		
 		ED_screens_initialize(C->wm);
 		C->wm->initialized= 1;
@@ -119,7 +119,7 @@ void wm_add_default(bContext *C)
 	C->wm= wm;
 	
 	win= wm_window_new(C, C->screen);
-	wm->windrawable= win;
+	wm->winactive= win;
 	wm_window_make_drawable(C, win); 
 }
 
@@ -128,14 +128,19 @@ void wm_add_default(bContext *C)
 void wm_close_and_free(bContext *C, wmWindowManager *wm)
 {
 	wmWindow *win;
+	wmOperator *op;
 	
 	while((win= wm->windows.first)) {
 		BLI_remlink(&wm->windows, win);
 		wm_window_free(C, win);
 	}
 	
-	BLI_freelistN(&wm->operators);
-	
+	while((op= wm->operators.first)) {
+		BLI_remlink(&wm->operators, op);
+		wm_operator_free(op);
+	}
+
+	BLI_freelistN(&wm->timekeymap);
 	BLI_freelistN(&wm->windowkeymap);
 	BLI_freelistN(&wm->screenkeymap);
 	
diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index bb0ad54d967..af61b787462 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -121,23 +121,37 @@ void wm_event_do_notifiers(bContext *C)
 		
 		for(win= C->wm->windows.first; win; win= win->next) {
 			ScrArea *sa;
+
+			C->window= win;
+			C->screen= win->screen;
 			
 			if(note->window && note->window!=win)
 				continue;
 			if(win->screen==NULL)
 				continue;
+
 			printf("notifier win %d screen %s\n", win->winid, win->screen->id.name+2);
 			ED_screen_do_listen(win, note);
 			
 			for(sa= win->screen->areabase.first; sa; sa= sa->next) {
 				ARegion *ar= sa->regionbase.first;
 				
+				C->area= sa;
+
 				for(; ar; ar= ar->next) {
 					if(note->swinid && note->swinid!=ar->swinid)
 						continue;
+
+					C->region= ar;
 					ED_region_do_listen(ar, note);
+					C->region= NULL;
 				}
+
+				C->area= NULL;
 			}
+
+			C->window= NULL;
+			C->screen= NULL;
 		}
 		if(note->data)
 			MEM_freeN(note->data);
@@ -178,6 +192,9 @@ void wm_draw_update(bContext *C)
 	for(win= C->wm->windows.first; win; win= win->next) {
 		if(wm_draw_update_test_window(win)) {
 			ScrArea *sa;
+
+			C->window= win;
+			C->screen= win->screen;
 			
 			/* sets context window+screen */
 			wm_window_make_drawable(C, win);
@@ -189,9 +206,13 @@ void wm_draw_update(bContext *C)
 			for(sa= win->screen->areabase.first; sa; sa= sa->next) {
 				ARegion *ar= sa->regionbase.first;
 				int hasdrawn= 0;
+
+				C->area= sa;
 				
 				for(; ar; ar= ar->next) {
 					hasdrawn |= ar->do_draw;
+
+					C->region= ar;
 					
 					/* cached notifiers */
 					if(ar->do_refresh)
@@ -199,7 +220,11 @@ void wm_draw_update(bContext *C)
 					
 					if(ar->swinid && ar->do_draw)
 						ED_region_do_draw(C, ar);
+
+					C->region= NULL;
 				}
+
+				C->area = NULL;
 			}
 			
 			/* move this here so we can do area 'overlay' drawing */
@@ -210,6 +235,9 @@ void wm_draw_update(bContext *C)
 				ED_screen_gesture(win);
 
 			wm_window_swap_buffers(win);
+
+			C->window= NULL;
+			C->screen= NULL;
 		}
 	}
 }
@@ -219,8 +247,6 @@ void wm_draw_update(bContext *C)
 /* not handler itself */
 static void wm_event_free_handler(wmEventHandler *handler)
 {
-	if(handler->op)
-		MEM_freeN(handler->op);
 }
 
 void wm_event_free_handlers(ListBase *lb)
@@ -252,57 +278,77 @@ static int wm_eventmatch(wmEvent *winevent, wmKeymapItem *km)
 	return 1;
 }
 
+/* note: this might free the handler from the operator */
 static int wm_handler_operator_call(bContext *C, wmEventHandler *handler, wmEvent *event)
 {
-	int retval= 0;
+	int retval= OPERATOR_PASS_THROUGH;
 	
 	/* derived, modal or blocking operator */
 	if(handler->op) {
-		if(handler->op->type->modal)
-			retval= handler->op->type->modal(C, handler->op, event);
+		wmOperator *op= handler->op;
+		wmOperatorType *ot= op->type;
+
+		if(ot->modal) {
+
+			retval= ot->modal(C, op, event);
+
+			if(retval == OPERATOR_FINISHED && (ot->flag & OPTYPE_REGISTER))
+				wm_operator_register(C->wm, op);
+			else if(retval == OPERATOR_CANCELLED || retval == OPERATOR_FINISHED)
+				wm_operator_free(op);
+		}
 		else
 			printf("wm_handler_operator_call error\n");
 	}
 	else {
 		wmOperatorType *ot= WM_operatortype_find(event->keymap_idname);
+
 		if(ot) {
 			if(ot->poll==NULL || ot->poll(C)) {
-				/* operator on stack, register or new modal handle malloc-copies */
-				wmOperator op;
-				
-				memset(&op, 0, sizeof(wmOperator));
-				op.type= ot;
+				wmOperator *op= MEM_callocN(sizeof(wmOperator), "wmOperator");
 
-				if(op.type->invoke)
-					retval= (*op.type->invoke)(C, &op, event);
-				else if(&op.type->exec)
-					retval= op.type->exec(C, &op);
-				
-				if( ot->flag & OPTYPE_REGISTER)
-					wm_operator_register(C->wm, &op);
+				op->type= ot;
+
+				if(op->type->invoke)
+					retval= (*op->type->invoke)(C, op, event);
+				else if(op->type->exec)
+					retval= op->type->exec(C, op);
+
+				if(retval == OPERATOR_FINISHED && (ot->flag & OPTYPE_REGISTER))
+					wm_operator_register(C->wm, op);
+				else if(retval != OPERATOR_RUNNING_MODAL)
+					wm_operator_free(op);
 			}
 		}
 	}
-	if(retval)
-		return WM_HANDLER_BREAK;
-	
-	return WM_HANDLER_CONTINUE;
+
+	if(retval == OPERATOR_PASS_THROUGH)
+		return WM_HANDLER_CONTINUE;
+
+	return WM_HANDLER_BREAK;
 }
 
 static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
 {
-	wmEventHandler *handler;
+	wmEventHandler *handler, *nexthandler;
 	int action= WM_HANDLER_CONTINUE;
 	
 	if(handlers==NULL) return action;
 	
-	for(handler= handlers->first; handler; handler= handler->next) {
+	/* in this loop, the handler might be freed in wm_handler_operator_call,
+	 * and new handler might be added to the head of the list */
+	for(handler= handlers->first; handler; handler= nexthandler) {
+		nexthandler= handler->next;
+
+		/* modal+blocking handler */
+		if(handler->flag & WM_HANDLER_BLOCKING)
+			action= WM_HANDLER_BREAK;
+
 		if(handler->keymap) {
 			wmKeymapItem *km;
 			
 			for(km= handler->keymap->first; km; km= km->next) {
 				if(wm_eventmatch(event, km)) {
-					
 					if(event->type!=MOUSEMOVE)
 						printf("handle evt %d win %d op %s\n", event->type, C->window->winid, km->idname);
 					
@@ -319,10 +365,6 @@ static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
 			action= wm_handler_operator_call(C, handler, event);
 		}
 
-		/* modal+blocking handler */
-		if(handler->flag & WM_HANDLER_BLOCKING)
-			action= WM_HANDLER_BREAK;
-
 		if(action==WM_HANDLER_BREAK)
 			break;
 		
@@ -341,7 +383,7 @@ static int wm_event_inside_i(wmEvent *event, rcti *rect)
 void wm_event_do_handlers(bContext *C)
 {
 	wmWindow *win;
-	
+
 	for(win= C->wm->windows.first; win; win= win->next) {
 		wmEvent *event;
 		
@@ -350,12 +392,11 @@ void wm_event_do_handlers(bContext *C)
 		
 		while( (event=wm_event_next(win)) ) {
 			int action;
-			
-			if(event->type==BORDERSELECT)
-				printf("BORDERSELECT Event!!\n");
+
+			C->window= win;
+			C->screen= win->screen;
 
 			/* MVC demands to not draw in event handlers... for now we leave it */
-			/* it also updates context (win, screen) */
 			wm_window_make_drawable(C, win);
 			
 			action= wm_handlers_do(C, event, &win->handlers);
@@ -366,7 +407,7 @@ void wm_event_do_handlers(bContext *C)
 				for(; sa; sa= sa->next) {
 					if(wm_event_inside_i(event, &sa->totrct)) {
 						
-						C->curarea= sa;
+						C->area= sa;
 						action= wm_handlers_do(C, event, &sa->handlers);
 						if(action==WM_HANDLER_CONTINUE) {
 							ARegion *ar= sa->regionbase.first;
@@ -375,17 +416,22 @@ void wm_event_do_handlers(bContext *C)
 								if(wm_event_inside_i(event, &ar->winrct)) {
 									C->region= ar;
 									action= wm_handlers_do(C, event, &ar->handlers);
+									C->region= NULL;
 									if(action==WM_HANDLER_BREAK)
 										break;
 								}
 							}
 						}
+						C->area= NULL;
 						if(action==WM_HANDLER_BREAK)
 							break;
 					}
 				}
 			}
 			wm_event_free(event);
+
+			C->window= NULL;
+			C->screen= NULL;
 		}
 	}
 }
@@ -404,11 +450,8 @@ wmEventHandler *WM_event_add_modal_handler(ListBase *handlers, wmOperator *op)
 	}
 	else {
 		wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "event handler");
-		wmOperator *opc= MEM_mallocN(sizeof(wmOperator), "operator modal");
-		
+		handler->op= op;
 		BLI_addhead(handlers, handler);
-		*opc= *op;
-		handler->op= opc;
 		
 		return handler;
 	}
@@ -431,14 +474,33 @@ void WM_event_remove_modal_handler(ListBase *handlers, wmOperator *op)
 
 wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers)
 {
-	wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "event handler");
+	wmEventHandler *handler;
 	
+	/* only allow same keymap once */
+	for(handler= handlers->first; handler; handler= handler->next)
+		if(handler->keymap==keymap)
+			return;
+
+	handler= MEM_callocN(sizeof(wmEventHandler), "event handler");
 	BLI_addtail(handlers, handler);
 	handler->keymap= keymap;
 	
 	return handler;
 }
 
+void WM_event_remove_keymap_handler(ListBase *keymap, ListBase *handlers)
+{
+	wmEventHandler *handler;
+	
+	for(handler= handlers->first; handler; handler= handler->next) {
+		if(handler->keymap==keymap) {
+			BLI_remlink(handlers, handler);
+			wm_event_free_handler(handler);
+			MEM_freeN(handler);
+			break;
+		}
+	}
+}
 
 /* ********************* ghost stuff *************** */
 
diff --git a/source/blender/windowmanager/intern/wm_files.c b/source/blender/windowmanager/intern/wm_files.c
index 8dbe235d256..70bdb60eb48 100644
--- a/source/blender/windowmanager/intern/wm_files.c
+++ b/source/blender/windowmanager/intern/wm_files.c
@@ -370,7 +370,7 @@ return;
 	/* we take apart the used screens from non-active window */
 	for(win= wm->windows.first; win; win= win->next) {
 		BLI_strncpy(win->screenname, win->screen->id.name, MAX_ID_NAME);
-		if(win!=C->window) {
+		if(win!=C->wm->winactive) {
 			BLI_remlink(&G.main->screen, win->screen);
 			//BLI_addtail(screenbase, win->screen);
 		}
diff --git a/source/blender/windowmanager/intern/wm_gesture.c b/source/blender/windowmanager/intern/wm_gesture.c
index 283b269fdfc..02e4a0124c2 100644
--- a/source/blender/windowmanager/intern/wm_gesture.c
+++ b/source/blender/windowmanager/intern/wm_gesture.c
@@ -103,7 +103,6 @@ void WM_gesture_update(bContext *C, wmGesture *from)
 	if(!to)
 		return;
 
-	printf("found gesture!!\n");
 	if(to->type==GESTURE_RECT)
 		wm_gesture_rect_copy((wmGestureRect*)to, (wmGestureRect*)from);
 }
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 88408869aba..8b4a167365d 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -62,9 +62,13 @@ wmOperatorType *WM_operatortype_find(const char *idname)
 }
 
 /* all ops in 1 list (for time being... needs evaluation later) */
-void WM_operatortypelist_append(ListBase *lb)
+void WM_operatortype_append(void (*opfunc)(wmOperatorType*))
 {
-	addlisttolist(&global_ops, lb);
+	wmOperatorType *ot;
+	
+	ot= MEM_callocN(sizeof(wmOperatorType), "operatortype");
+	opfunc(ot);
+	BLI_addtail(&global_ops, ot);
 }
 
 /* ************ default ops, exported *********** */
@@ -133,89 +137,99 @@ static void WM_OT_exit_blender(wmOperatorType *ot)
  */
 static int border_select_init(bContext *C, wmOperator *op)
 {
-	OP_set_int(op, "start_x", op->veci.x);
-	OP_set_int(op, "start_y", op->veci.y);
+	int x, y;
+
+	if(!(OP_get_int(op, "start_x", &x) && OP_get_int(op, "start_y", &y)))
+		return 0;
+
 	WM_gesture_init(C, GESTURE_RECT);
 	return 1;
 }
 
-static int border_select_exec(bContext *C, wmOperator *op)
+static int border_select_apply(bContext *C, wmOperator *op)
 {
 	wmGestureRect rect;
-	int x, y;
+	int x, y, endx, endy;
 
 	OP_get_int(op, "start_x", &x);
 	OP_get_int(op, "start_y", &y);
+	OP_get_int(op, "end_x", &endx);
+	OP_get_int(op, "end_y", &endy);
 
 	rect.gesture.next= rect.gesture.prev= NULL;
 	rect.gesture.type= GESTURE_RECT;
 	rect.x1= x;
 	rect.y1= y;
-	rect.x2= op->veci.x;
-	rect.y2= op->veci.y;
+	rect.x2= endx;
+	rect.y2= endy;
 	WM_gesture_update(C, (wmGesture *) &rect);
 	WM_event_add_notifier(C->wm, C->window, 0, WM_NOTE_GESTURE_CHANGED, GESTURE_RECT, NULL);
+
 	return 1;
 }
 
+static int border_select_exit(bContext *C, wmOperator *op)
+{
+	WM_event_add_notifier(C->wm, C->window, 0, WM_NOTE_SCREEN_CHANGED, 0, NULL);
+	OP_free_property(op);
+	return 1;
+}
+
+static int border_select_exec(bContext *C, wmOperator *op)
+{
+	if(!border_select_init(C, op))
+		return OPERATOR_CANCELLED;
+	
+	border_select_apply(C, op);
+	border_select_exit(C, op);
+
+	return OPERATOR_FINISHED;
+}
+
 static int border_select_invoke(bContext *C, wmOperator *op, wmEvent *event)
 {
 	/* operator arguments and storage. */
-	op->properties= NULL;
-	op->veci.x= event->x;
-	op->veci.y= event->y;
+	OP_verify_int(op, "start_x", event->x, NULL);
+	OP_verify_int(op, "start_y", event->y, NULL);
 
-	if(0==border_select_init(C, op))
-		return 1;
+	if(!border_select_init(C, op))
+		return OPERATOR_CANCELLED;
 
 	/* add temp handler */
 	WM_event_add_modal_handler(&C->window->handlers, op);
-	return 0;
+	return OPERATOR_RUNNING_MODAL;
 }
 
-static int border_select_exit(bContext *C, wmOperator *op)
+static int border_select_cancel(bContext *C, wmOperator *op)
 {
-	WM_event_add_notifier(C->wm, C->window, 0, WM_NOTE_SCREEN_CHANGED, 0, NULL);
-	OP_free_property(op);
-	return 1;
+	WM_event_remove_modal_handler(&C->window->handlers, op);
+	border_select_exit(C, op);
+	return OPERATOR_CANCELLED;
 }
 
 static int border_select_modal(bContext *C, wmOperator *op, wmEvent *event)
 {
 	switch(event->type) {
 		case MOUSEMOVE:
-			op->veci.x= event->x;
-			op->veci.y= event->y;
-			border_select_exec(C, op);
+			OP_set_int(op, "end_x", event->x);
+			OP_set_int(op, "end_y", event->y);
+			border_select_apply(C, op);
+			WM_event_add_notifier(C->wm, C->window, 0, WM_NOTE_GESTURE_CHANGED, GESTURE_RECT, NULL);
 			WM_event_add_notifier(C->wm, C->window, 0, WM_NOTE_SCREEN_CHANGED, 0, NULL);
 			break;
 		case LEFTMOUSE:
 			if(event->val==0) {
-				wmGestureRect rect;
-				int x, y;
-
-				OP_get_int(op, "start_x", &x);
-				OP_get_int(op, "start_y", &y);
-
-				rect.gesture.next= rect.gesture.prev= NULL;
-				rect.gesture.type= GESTURE_RECT;
-				rect.x1= x;
-				rect.y1= y;
-				rect.x2= op->veci.x;
-				rect.y2= op->veci.y;
-				WM_gesture_update(C, (wmGesture*)&rect);
+				border_select_apply(C, op);
 				WM_gesture_end(C, GESTURE_RECT);
-
 				border_select_exit(C, op);
 				WM_event_remove_modal_handler(&C->window->handlers, op);
+				return OPERATOR_FINISHED;
 			}
 			break;
 		case ESCKEY:
-			WM_event_remove_modal_handler(&C->window->handlers, op);
-			border_select_exit(C, op);
-			break;
+			return border_select_cancel(C, op);
 	}
-	return 1;
+	return OPERATOR_RUNNING_MODAL;
 }
 
 void WM_OT_border_select(wmOperatorType *ot)
@@ -224,20 +238,14 @@ void WM_OT_border_select(wmOperatorType *ot)
 	ot->name= "Border select";
 	ot->idname= "WM_OT_border_select";
 
-	ot->init= border_select_init;
+	ot->exec= border_select_exec;
 	ot->invoke= border_select_invoke;
+	ot->cancel= border_select_cancel;
 	ot->modal= border_select_modal;
-	ot->exec= border_select_exec;
-	ot->exit= border_select_exit;
 
 	ot->poll= WM_operator_winactive;
 }
  
-#define ADD_OPTYPE(opfunc)	ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); \
-							opfunc(ot);  \
-							BLI_addtail(&global_ops, ot)
-
-
 /* called on initialize WM_exit() */
 void wm_operatortype_free(void)
 {
@@ -247,20 +255,23 @@ void wm_operatortype_free(void)
 /* called on initialize WM_init() */
 void wm_operatortype_init(void)
 {
-	wmOperatorType *ot;
-	
-	ADD_OPTYPE(WM_OT_window_duplicate);
-	ADD_OPTYPE(WM_OT_save_homefile);
-	ADD_OPTYPE(WM_OT_window_fullscreen_toggle);
-	ADD_OPTYPE(WM_OT_exit_blender);
-	ADD_OPTYPE(WM_OT_border_select);
+	WM_operatortype_append(WM_OT_window_duplicate);
+	WM_operatortype_append(WM_OT_save_homefile);
+	WM_operatortype_append(WM_OT_window_fullscreen_toggle);
+	WM_operatortype_append(WM_OT_exit_blender);
+	WM_operatortype_append(WM_OT_border_select);
 }
 
 /* wrapped to get property from a operator. */
 IDProperty *op_get_property(wmOperator *op, char *name)
 {
-	IDProperty *prop= IDP_GetPropertyFromGroup(op->properties, name);
-	return(prop);
+	IDProperty *prop;
+	
+	if(!op->properties)
+		return NULL;
+
+	prop= IDP_GetPropertyFromGroup(op->properties, name);
+	return prop;
 }
 
 /*
@@ -279,13 +290,15 @@ void op_init_property(wmOperator *op)
 /* ***** Property API, exported ***** */
 void OP_free_property(wmOperator *op)
 {
-	IDP_FreeProperty(op->properties);
-	/*
-	 * This need change, when the idprop code only
-	 * need call IDP_FreeProperty. (check BKE_idprop.h)
-	 */
-	MEM_freeN(op->properties);
-	op->properties= NULL;
+	if(op->properties) {
+		IDP_FreeProperty(op->properties);
+		/*
+		 * This need change, when the idprop code only
+		 * need call IDP_FreeProperty. (check BKE_idprop.h)
+		 */
+		MEM_freeN(op->properties);
+		op->properties= NULL;
+	}
 }
 
 void OP_set_int(wmOperator *op, char *name, int value)
@@ -370,11 +383,11 @@ void OP_set_string(wmOperator *op, char *name, char *str)
 int OP_get_int(wmOperator *op, char *name, int *value)
 {
 	IDProperty *prop= op_get_property(op, name);
-	int status= 1;
+	int status= 0;
 
 	if ((prop) && (prop->type == IDP_INT)) {
 		(*value)= prop->data.val;
-		status= 0;
+		status= 1;
 	}
 	return (status);
 }
@@ -382,11 +395,11 @@ int OP_get_int(wmOperator *op, char *name, int *value)
 int OP_get_float(wmOperator *op, char *name, float *value)
 {
 	IDProperty *prop= op_get_property(op, name);
-	int status= 1;
+	int status= 0;
 
 	if ((prop) && (prop->type == IDP_FLOAT)) {
 		(*value)= *(float*)&prop->data.val;
-		status= 0;
+		status= 1;
 	}
 	return (status);
 }
@@ -395,7 +408,7 @@ int OP_get_int_array(wmOperator *op, char *name, int *array, short *len)
 {
 	IDProperty *prop= op_get_property(op, name);
 	short i;
-	int status= 1;
+	int status= 0;
 	int *pointer;
 
 	if ((prop) && (prop->type == IDP_ARRAY)) {
@@ -405,7 +418,7 @@ int OP_get_int_array(wmOperator *op, char *name, int *array, short *len)
 			array[i]= pointer[i];
 
 		(*len)= i;
-		status= 0;
+		status= 1;
 	}
 	return (status);
 }
@@ -415,7 +428,7 @@ int OP_get_float_array(wmOperator *op, char *name, float *array, short *len)
 	IDProperty *prop= op_get_property(op, name);
 	short i;
 	float *pointer;
-	int status= 1;
+	int status= 0;
 
 	if ((prop) && (prop->type == IDP_ARRAY)) {
 		pointer= (float *) prop->data.pointer;
@@ -424,7 +437,7 @@ int OP_get_float_array(wmOperator *op, char *name, float *array, short *len)
 			array[i]= pointer[i];
 
 		(*len)= i;
-		status= 0;
+		status= 1;
 	}
 	return (status);
 }
@@ -436,3 +449,76 @@ char *OP_get_string(wmOperator *op, char *name)
 		return ((char *) prop->data.pointer);
 	return (NULL);
 }
+
+void OP_verify_int(wmOperator *op, char *name, int value, int *result)
+{
+	int rvalue;
+
+	if(OP_get_int(op, name, &rvalue))
+		value= rvalue;
+	else
+		OP_set_int(op, name, value);
+
+	if(result)
+		*result= value;
+}
+
+void OP_verify_float(wmOperator *op, char *name, float value, int *result)
+{
+	float rvalue;
+
+	if(OP_get_float(op, name, &rvalue))
+		value= rvalue;
+	else
+		OP_set_float(op, name, value);
+	
+	if(result)
+		*result= value;
+}
+
+char *OP_verify_string(wmOperator *op, char *name, char *str)
+{
+	char *result= OP_get_string(op, name);
+
+	if(!result) {
+		OP_set_string(op, name, str);
+		result= OP_get_string(op, name);
+	}
+
+	return result;
+}
+
+void OP_verify_int_array(wmOperator *op, char *name, int *array, short len, int *resultarray, short *resultlen)
+{
+	int rarray[1];
+	short rlen= 1;
+
+	if(resultarray && resultlen) {
+		if(!OP_get_int_array(op, name, resultarray, &rlen)) {
+			OP_set_int_array(op, name, array, len);
+			OP_get_int_array(op, name, resultarray, resultlen);
+		}
+	}
+	else {
+		if(!OP_get_int_array(op, name, rarray, &rlen))
+			OP_set_int_array(op, name, array, len);
+	}
+}
+
+void OP_verify_float_array(wmOperator *op, char *name, float *array, short len, float *resultarray, short *resultlen)
+{
+	float rarray[1];
+	short rlen= 1;
+
+	if(resultarray && resultlen) {
+		if(!OP_get_float_array(op, name, resultarray, &rlen)) {
+			OP_set_float_array(op, name, array, len);
+			OP_get_float_array(op, name, resultarray, resultlen);
+		}
+	}
+	else {
+		if(!OP_get_float_array(op, name, rarray, &rlen))
+			OP_set_float_array(op, name, array, len);
+	}
+}
+
diff --git a/source/blender/windowmanager/intern/wm_subwindow.c b/source/blender/windowmanager/intern/wm_subwindow.c
index 23fbba7a054..b0789ba08ed 100644
--- a/source/blender/windowmanager/intern/wm_subwindow.c
+++ b/source/blender/windowmanager/intern/wm_subwindow.c
@@ -163,7 +163,7 @@ int wm_subwindow_open(wmWindow *win, rcti *winrct)
 	win->curswin= swin= MEM_callocN(sizeof(wmSubWindow), "swinopen");
 	BLI_addtail(&win->subwindows, swin);
 	
-	printf("swin %d added\n", freewinid);
+	if(G.f & G_DEBUG) printf("swin %d added\n", freewinid);
 	swin->swinid= freewinid;
 	swin->winrct= *winrct;
 
diff --git a/source/blender/windowmanager/intern/wm_window.c b/source/blender/windowmanager/intern/wm_window.c
index 214d10a4109..dd481cef1c0 100644
--- a/source/blender/windowmanager/intern/wm_window.c
+++ b/source/blender/windowmanager/intern/wm_window.c
@@ -161,11 +161,10 @@ wmWindow *wm_window_copy(bContext *C, wmWindow *winorig)
 /* operator callback */
 int wm_window_duplicate_op(bContext *C, wmOperator *op)
 {
-	
 	wm_window_copy(C, C->window);
 	wm_check(C);
 	
-	return 1;
+	return OPERATOR_FINISHED;
 }
 
 /* fullscreen operator callback */
@@ -177,7 +176,7 @@ int wm_window_fullscreen_toggle_op(bContext *C, wmOperator *op)
 	else
 		GHOST_SetWindowState(C->window->ghostwin, GHOST_kWindowStateNormal);
 
-	return 1;
+	return OPERATOR_FINISHED;
 	
 }
 
@@ -186,7 +185,7 @@ static void wm_window_close(bContext *C, wmWindow *win)
 {
 	BLI_remlink(&C->wm->windows, win);
 	wm_window_free(C, win);
-	
+
 	if(C->wm->windows.first==NULL)
 		WM_exit(C);
 }
@@ -200,7 +199,7 @@ int wm_exit_blender_op(bContext *C, wmOperator *op)
 		win= win->next;
 	}
 
-	return 1;
+	return OPERATOR_FINISHED;
 }
 
 static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
@@ -316,13 +315,11 @@ static int query_qual(char qual)
 
 void wm_window_make_drawable(bContext *C, wmWindow *win) 
 {
-	if (win != C->window && win->ghostwin) {
+	if (win != C->wm->windrawable && win->ghostwin) {
 //		win->lmbut= 0;	/* keeps hanging when mousepressed while other window opened */
 		
 		C->wm->windrawable= win;
-		C->window= win;
-		C->screen= win->screen;
-		printf("set drawable %d\n", win->winid);
+		if(G.f & G_DEBUG) printf("set drawable %d\n", win->winid);
 		GHOST_ActivateWindowDrawingContext(win->ghostwin);
 	}
 }
@@ -363,7 +360,7 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
 				GHOST_TEventKeyData kdata;
 				int cx, cy, wx, wy;
 				
-				C->wm->winactive= win; /* no context change! c->window is drawable, or for area queues */
+				C->wm->winactive= win; /* no context change! c->wm->windrawable is drawable, or for area queues */
 				
 				win->active= 1;
 //				window_handle(win, INPUTCHANGE, win->active);
@@ -404,7 +401,7 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
 				break;
 			}
 			case GHOST_kEventWindowUpdate: {
-				printf("ghost redraw\n");
+				if(G.f & G_DEBUG) printf("ghost redraw\n");
 				
 				wm_window_make_drawable(C, win);
 				WM_event_add_notifier(C->wm, win, 0, WM_NOTE_WINDOW_REDRAW, 0, NULL);
@@ -432,17 +429,22 @@ static int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
 					GHOST_TWindowState state;
 					state = GHOST_GetWindowState(win->ghostwin);
 
-					if(state==GHOST_kWindowStateNormal)
-						printf("window state: normal\n");
-					else if(state==GHOST_kWindowStateMinimized)
-						printf("window state: minimized\n");
-					else if(state==GHOST_kWindowStateMaximized)
-						printf("window state: maximized\n");
-					else if(state==GHOST_kWindowStateFullScreen)
-						printf("window state: fullscreen\n");
+					if(state==GHOST_kWindowStateNormal) {
+						if(G.f & G_DEBUG) printf("window state: normal\n");
+					}
+					else if(state==GHOST_kWindowStateMinimized) {
+						if(G.f & G_DEBUG) printf("window state: minimized\n");
+					}
+					else if(state==GHOST_kWindowStateMaximized) {
+						if(G.f & G_DEBUG) printf("window state: maximized\n");
+					}
+					else if(state==GHOST_kWindowStateFullScreen) {
+						if(G.f & G_DEBUG) printf("window state: fullscreen\n");
+					}
 					
-					if(type!=GHOST_kEventWindowSize)
-						printf("win move event pos %d %d size %d %d\n", win->posx, win->posy, win->sizex, win->sizey);
+					if(type!=GHOST_kEventWindowSize) {
+						if(G.f & G_DEBUG) printf("win move event pos %d %d size %d %d\n", win->posx, win->posy, win->sizex, win->sizey);
+					}
 					
 				}
 				
diff --git a/source/blender/windowmanager/wm.h b/source/blender/windowmanager/wm.h
index 8269dd48533..c381ac269d9 100644
--- a/source/blender/windowmanager/wm.h
+++ b/source/blender/windowmanager/wm.h
@@ -34,8 +34,9 @@ extern void wm_close_and_free_all(bContext *C, ListBase *);
 extern void wm_add_default(bContext *C);
 extern void wm_check(bContext *C);
 			
+void		wm_operator_free(wmOperator *op);
 			/* register to windowmanager for redo or macro */
-void		wm_operator_register(wmWindowManager *wm, wmOperator *ot);
+void		wm_operator_register(wmWindowManager *wm, wmOperator *op);
 
 /* wm_operator.c, for init/exit */
 void wm_operatortype_free(void);
diff --git a/source/blender/windowmanager/wm_subwindow.h b/source/blender/windowmanager/wm_subwindow.h
index 93079deb633..b4d12d1358c 100644
--- a/source/blender/windowmanager/wm_subwindow.h
+++ b/source/blender/windowmanager/wm_subwindow.h
@@ -1,5 +1,5 @@
 /**
- * $Id: wm_window.h
+ * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
@@ -43,7 +43,7 @@ int		wm_subwindow_get(wmWindow *win);				/* returns id */
 void	wm_subwindow_position(wmWindow *win, int swinid, rcti *winrct);
 
 
-void	wm_subwindow_getsize(wmWindow *win, int *x, int *y) ;
+void	wm_subwindow_getsize(wmWindow *win, int *x, int *y);
 void	wm_subwindow_getorigin(wmWindow *win, int *x, int *y);