archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
b36a05bb7e794335e3415594c41d3986cdc815e8
blender-archive/source/blender/windowmanager/intern/wm_gesture.c

339 lines
8.7 KiB
C
Raw Normal View History

New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
/**
* $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) 2008 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
* make sure this compiles with msvc too. - note: there is no round() in msvc math.h, so I used floor(val+0.5)
2008-11-24 14:16:04 +00:00
#define _USE_MATH_DEFINES
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
#include <math.h>
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
#include "DNA_screen_types.h"
#include "DNA_vec_types.h"
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
#include "DNA_userdef_types.h"
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
#include "BLI_editVert.h" /* lasso tessellation */
#include "BLI_scanfill.h" /* lasso tessellation */
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
#include "BKE_context.h"
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
#include "BKE_utildefines.h"
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
#include "WM_api.h"
#include "WM_types.h"
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
#include "wm.h"
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
#include "wm_event_system.h"
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
#include "wm_subwindow.h"
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
2.5 Notifier system upgrade, based on Brecht's doc. Implementation notes: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers#Implementation In short: let's try to strictly communicate in a notifier what happened. The listeners then can act themselves. It also means that a frame-changed notifier doesn't send out redraws, the editors themselves can decide.
2008-12-27 16:09:56 +00:00
#include "ED_screen.h"
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
#include "BIF_gl.h"
#include "BIF_glutil.h"
* make sure this compiles with msvc too. - note: there is no round() in msvc math.h, so I used floor(val+0.5)
2008-11-24 14:16:04 +00:00
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
/* context checked on having screen, window and area */
wmGesture *WM_gesture_new(bContext *C, wmEvent *event, int type)
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
{
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
wmGesture *gesture= MEM_callocN(sizeof(wmGesture), "new gesture");
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
wmWindow *window= CTX_wm_window(C);
2.5 Bugfix: WM gesture manager was not assigning gesture to the context-defined region, making border select calls from a header not work. This fixes Node header option "Border select".
2009-01-06 10:09:39 +00:00
ARegion *ar= CTX_wm_region(C);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
int sx, sy;
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
BLI_addtail(&window->gesture, gesture);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
gesture->type= type;
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
gesture->event_type= event->type;
2.5 Bugfix: WM gesture manager was not assigning gesture to the context-defined region, making border select calls from a header not work. This fixes Node header option "Border select".
2009-01-06 10:09:39 +00:00
gesture->swinid= ar->swinid; /* means only in area-region context! */
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
wm_subwindow_getorigin(window, gesture->swinid, &sx, &sy);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
if( ELEM4(type, WM_GESTURE_RECT, WM_GESTURE_CROSS_RECT, WM_GESTURE_TWEAK, WM_GESTURE_CIRCLE)) {
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
rcti *rect= MEM_callocN(sizeof(rcti), "gesture rect new");
gesture->customdata= rect;
rect->xmin= event->x - sx;
rect->ymin= event->y - sy;
- converted circle select use a modal map - now works exactly like 2.4x, except that its accessed from the CKey - hack to remember circle size, need some better way to do this
2009-11-05 17:32:06 +00:00
if(type==WM_GESTURE_CIRCLE) {
#ifdef GESTURE_MEMORY
rect->xmax= circle_select_size;
#else
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
rect->xmax= 25; // XXX temp
- converted circle select use a modal map - now works exactly like 2.4x, except that its accessed from the CKey - hack to remember circle size, need some better way to do this
2009-11-05 17:32:06 +00:00
#endif
} else {
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
rect->xmax= event->x - sx;
rect->ymax= event->y - sy;
}
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
}
2.5 - Node editor: link cut back, now under ALT+LMB, to prevent accidents. Note it now nicely intersects the real curved noodles with a line you draw! - To make above work, replaced ogl curve draw with own bezier code. - Added new WM standard operator callback for lines-gesture, the Lasso gesture now draws a closed line. - Both callbacks have optional property 'cursor' to make it give modal info. For future also linestyle or color can be defined. - Changed 'pin' icon in Image header to something that looks less scary... but there's no pin icon yet?
2009-02-07 14:03:34 +00:00
else if (ELEM(type, WM_GESTURE_LINES, WM_GESTURE_LASSO)) {
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
short *lasso;
gesture->customdata= lasso= MEM_callocN(2*sizeof(short)*WM_LASSO_MAX_POINTS, "lasso points");
lasso[0] = event->x - sx;
lasso[1] = event->y - sy;
gesture->points= 1;
}
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
return gesture;
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
}
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
void WM_gesture_end(bContext *C, wmGesture *gesture)
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
{
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
BLI_remlink(&CTX_wm_window(C)->gesture, gesture);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
MEM_freeN(gesture->customdata);
MEM_freeN(gesture);
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
}
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
/* tweak and line gestures */
#define TWEAK_THRESHOLD 10
int wm_gesture_evaluate(bContext *C, wmGesture *gesture)
{
if(gesture->type==WM_GESTURE_TWEAK) {
rcti *rect= gesture->customdata;
int dx= rect->xmax - rect->xmin;
int dy= rect->ymax - rect->ymin;
if(ABS(dx)+ABS(dy) > TWEAK_THRESHOLD) {
* make sure this compiles with msvc too. - note: there is no round() in msvc math.h, so I used floor(val+0.5)
2008-11-24 14:16:04 +00:00
int theta= (int)floor(4.0f*atan2((float)dy, (float)dx)/M_PI + 0.5);
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
int val= EVT_GESTURE_W;
if(theta==0) val= EVT_GESTURE_E;
else if(theta==1) val= EVT_GESTURE_NE;
else if(theta==2) val= EVT_GESTURE_N;
else if(theta==3) val= EVT_GESTURE_NW;
else if(theta==-1) val= EVT_GESTURE_SE;
else if(theta==-2) val= EVT_GESTURE_S;
else if(theta==-3) val= EVT_GESTURE_SW;
2.5: work on bringing back SpaceTime options - RMB select, also with SHIFT - RMB tweak for translate - SHIFT+D dupli - BKEY border select/deselect - AKEY (de)select all - XKEY delete - GKEY grab Added some XXX comments for future todos, especially for when other spaces come back with time markers. Also added ED_util for putting in all to-be-cleaned cruft Context conflict: input methods for Markers can conflict with other spacetypes. It was solved in pre-2.5 with manually tweaking it all over, but I would prefer one keymap for all marker stuff. Needs some thinking... could be solved with a boundbox check for bottom part of 2d window. Tweak issue: both tweak styles are possible: - Hold mouse button, move, operator ends on mouse release - Hold mouse button, move, operator ends on mouse click Problem is that modally handled operators use fixed keymaps... like ESC, SPACE, ENTER, or press/release mousebutton for 'assign'. There's a lot to say for making this all consistant, or become part of 1 general keymap? Should also be possibe to define 'tweak' defaults for Tablet different than for mouse...
2008-11-29 15:10:31 +00:00
#if 0
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
/* debug */
if(val==1) printf("tweak north\n");
if(val==2) printf("tweak north-east\n");
if(val==3) printf("tweak east\n");
if(val==4) printf("tweak south-east\n");
if(val==5) printf("tweak south\n");
if(val==6) printf("tweak south-west\n");
if(val==7) printf("tweak west\n");
if(val==8) printf("tweak north-west\n");
2.5: work on bringing back SpaceTime options - RMB select, also with SHIFT - RMB tweak for translate - SHIFT+D dupli - BKEY border select/deselect - AKEY (de)select all - XKEY delete - GKEY grab Added some XXX comments for future todos, especially for when other spaces come back with time markers. Also added ED_util for putting in all to-be-cleaned cruft Context conflict: input methods for Markers can conflict with other spacetypes. It was solved in pre-2.5 with manually tweaking it all over, but I would prefer one keymap for all marker stuff. Needs some thinking... could be solved with a boundbox check for bottom part of 2d window. Tweak issue: both tweak styles are possible: - Hold mouse button, move, operator ends on mouse release - Hold mouse button, move, operator ends on mouse click Problem is that modally handled operators use fixed keymaps... like ESC, SPACE, ENTER, or press/release mousebutton for 'assign'. There's a lot to say for making this all consistant, or become part of 1 general keymap? Should also be possibe to define 'tweak' defaults for Tablet different than for mouse...
2008-11-29 15:10:31 +00:00
#endif
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
return val;
}
}
return 0;
}
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
/* ******************* gesture draw ******************* */
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
static void wm_gesture_draw_rect(wmWindow *win, wmGesture *gt)
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
{
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
rcti *rect= (rcti *)gt->customdata;
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glEnable(GL_BLEND);
glColor4f(1.0, 1.0, 1.0, 0.05);
glBegin(GL_QUADS);
glVertex2s(rect->xmax, rect->ymin);
glVertex2s(rect->xmax, rect->ymax);
glVertex2s(rect->xmin, rect->ymax);
glVertex2s(rect->xmin, rect->ymin);
glEnd();
glDisable(GL_BLEND);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
glEnable(GL_LINE_STIPPLE);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glColor3ub(96, 96, 96);
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
glLineStipple(1, 0xCCCC);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
sdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
glColor3ub(255, 255, 255);
glLineStipple(1, 0x3333);
sdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
glDisable(GL_LINE_STIPPLE);
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
}
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
static void wm_gesture_draw_line(wmWindow *win, wmGesture *gt)
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
{
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
rcti *rect= (rcti *)gt->customdata;
glEnable(GL_LINE_STIPPLE);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glColor3ub(96, 96, 96);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
glLineStipple(1, 0xAAAA);
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
sdrawline(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
glColor3ub(255, 255, 255);
glLineStipple(1, 0x5555);
sdrawline(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
glDisable(GL_LINE_STIPPLE);
}
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
static void wm_gesture_draw_circle(wmWindow *win, wmGesture *gt)
{
rcti *rect= (rcti *)gt->customdata;
glTranslatef((float)rect->xmin, (float)rect->ymin, 0.0f);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glEnable(GL_BLEND);
glColor4f(1.0, 1.0, 1.0, 0.05);
glutil_draw_filled_arc(0.0, M_PI*2.0, rect->xmax, 40);
glDisable(GL_BLEND);
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
glEnable(GL_LINE_STIPPLE);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glColor3ub(96, 96, 96);
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
glLineStipple(1, 0xAAAA);
glutil_draw_lined_arc(0.0, M_PI*2.0, rect->xmax, 40);
glColor3ub(255, 255, 255);
glLineStipple(1, 0x5555);
glutil_draw_lined_arc(0.0, M_PI*2.0, rect->xmax, 40);
glDisable(GL_LINE_STIPPLE);
glTranslatef((float)-rect->xmin, (float)-rect->ymin, 0.0f);
}
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
static void draw_filled_lasso(wmGesture *gt)
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
{
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
EditVert *v, *lastv=NULL, *firstv=NULL;
EditEdge *e;
EditFace *efa;
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
short *lasso= (short *)gt->customdata;
int i;
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
for (i=0; i<gt->points; i++, lasso+=2) {
float co[3] = {(float)lasso[0], (float)lasso[1], 0.f};
v = BLI_addfillvert(co);
if (lastv)
e = BLI_addfilledge(lastv, v);
lastv = v;
if (firstv==NULL) firstv = v;
}
BLI_addfilledge(firstv, v);
BLI_edgefill(0, 0);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glEnable(GL_BLEND);
glColor4f(1.0, 1.0, 1.0, 0.05);
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
glBegin(GL_TRIANGLES);
for (efa = fillfacebase.first; efa; efa=efa->next) {
glVertex2f(efa->v1->co[0], efa->v1->co[1]);
glVertex2f(efa->v2->co[0], efa->v2->co[1]);
glVertex2f(efa->v3->co[0], efa->v3->co[1]);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
}
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
glEnd();
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glDisable(GL_BLEND);
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
BLI_end_edgefill();
}
static void wm_gesture_draw_lasso(wmWindow *win, wmGesture *gt)
{
short *lasso= (short *)gt->customdata;
int i;
*Disabled filled lasso drawing on Windows for now, was causing some strange problems, perhaps GLU incompatibilities? If any Windows GL guru can help here, it would be most appreciated!
2010-01-06 06:51:04 +00:00
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
draw_filled_lasso(gt);
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
glEnable(GL_LINE_STIPPLE);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glColor3ub(96, 96, 96);
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
glLineStipple(1, 0xAAAA);
glBegin(GL_LINE_STRIP);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
lasso= (short *)gt->customdata;
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
for(i=0; i<gt->points; i++, lasso+=2)
glVertex2sv(lasso);
2.5 - Node editor: link cut back, now under ALT+LMB, to prevent accidents. Note it now nicely intersects the real curved noodles with a line you draw! - To make above work, replaced ogl curve draw with own bezier code. - Added new WM standard operator callback for lines-gesture, the Lasso gesture now draws a closed line. - Both callbacks have optional property 'cursor' to make it give modal info. For future also linestyle or color can be defined. - Changed 'pin' icon in Image header to something that looks less scary... but there's no pin icon yet?
2009-02-07 14:03:34 +00:00
if(gt->type==WM_GESTURE_LASSO)
glVertex2sv((short *)gt->customdata);
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
glEnd();
glColor3ub(255, 255, 255);
glLineStipple(1, 0x5555);
glBegin(GL_LINE_STRIP);
lasso= (short *)gt->customdata;
for(i=0; i<gt->points; i++, lasso+=2)
glVertex2sv(lasso);
2.5 - Node editor: link cut back, now under ALT+LMB, to prevent accidents. Note it now nicely intersects the real curved noodles with a line you draw! - To make above work, replaced ogl curve draw with own bezier code. - Added new WM standard operator callback for lines-gesture, the Lasso gesture now draws a closed line. - Both callbacks have optional property 'cursor' to make it give modal info. For future also linestyle or color can be defined. - Changed 'pin' icon in Image header to something that looks less scary... but there's no pin icon yet?
2009-02-07 14:03:34 +00:00
if(gt->type==WM_GESTURE_LASSO)
glVertex2sv((short *)gt->customdata);
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
glEnd();
glDisable(GL_LINE_STIPPLE);
}
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
static void wm_gesture_draw_cross(wmWindow *win, wmGesture *gt)
{
rcti *rect= (rcti *)gt->customdata;
glEnable(GL_LINE_STIPPLE);
Small tweaks to gesture drawing to show the filled selectable area. Gives nice feedback for what will be selected, especially with lasso.
2010-01-06 04:52:13 +00:00
glColor3ub(96, 96, 96);
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
glLineStipple(1, 0xCCCC);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
sdrawline(rect->xmin - win->sizex, rect->ymin, rect->xmin + win->sizex, rect->ymin);
sdrawline(rect->xmin, rect->ymin - win->sizey, rect->xmin, rect->ymin + win->sizey);
glColor3ub(255, 255, 255);
glLineStipple(1, 0x3333);
sdrawline(rect->xmin - win->sizex, rect->ymin, rect->xmin + win->sizex, rect->ymin);
sdrawline(rect->xmin, rect->ymin - win->sizey, rect->xmin, rect->ymin + win->sizey);
glDisable(GL_LINE_STIPPLE);
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
}
2.5 Small fix: Triple Buffer mode didn't clip custom paint cursors correctly for overlapping regions (example, view3d paint circle drawing into toolbar)
2009-07-19 12:15:20 +00:00
/* called in wm_draw.c */
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
void wm_gesture_draw(wmWindow *win)
More change to the gesture manager. After check this a little more I make some changes to the API and now work on the following form: WM_gesture_init(C, type); while() { /* handler event, etc */ /* if something change. */ if(need_update) { /* update the gesture data and notify about it. */ WM_gesture_update(C, data); WM_event_add_notifier (.. WM_NOTE_GESTURE_CHANGE ..); } } WM_gesture_end(C, type); Another of the change is that now the gesture data is a link list in the window struct, so we can have multiples "gestures" (but of different type) at the same time. Also take care that the "gesture data" is reusable, that mean that only alloc it 1 time and use in all the place, that is why don't support multiple gesture of the same type, but of course that can be change.
2008-01-19 21:54:33 +00:00
{
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
wmGesture *gt= (wmGesture *)win->gesture.first;
for(; gt; gt= gt->next) {
/* all in subwindow space */
2.5 All of the view3d drawing code is now 'Context' free. The idea is: - ED_region_do_draw() sets and freezes drawing context - regiontype draw() callback then can pass on other relevant context stuff as function args. Also cleaned up the WM opengl wrappers, to mimic opengl state; no reason to give window pointer anymore.
2008-12-19 14:14:43 +00:00
wmSubWindowSet(win, gt->swinid);
Fix #19431: gestures would sometimes draw incorrect, now ensures they are always drawn in pixel space.
2009-12-17 19:55:08 +00:00
wmOrthoPixelSpace();
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
if(gt->type==WM_GESTURE_RECT)
wm_gesture_draw_rect(win, gt);
Work on gesture, some more cleaning. - Added standard "tweak" gesture operator, which can be set per region, to generate EVT_TWEAK events. You can configure tweaks for any mouse button and have handlers for such events check for modifiers etc. It even stores tweak direction (8 directions). Might be fun to experiment with tweak gestures N, S, etc. :) In general it can be used to replace the current tweak code in 2.48 (std_rmouse_transform). Test added: on screen level it now adds LMB tweaks, if tweak-South it splits the area. Will be removed of course. - Added to Border operator a property to store event used to end border with. - Moved the "AZone" triangle drawing to the right context (area). It was on screen level, not respecting area-redraws. Also cleaned up drawing for it, and moved the "swap buffers indicator" square to look nicer. Those squares are only for test! - event-match function had bad code for checking for event-value. Made a "KM_ANY" define so keymaps can be defined ignoring event values. - Gesture todo: lasso, "real gesture" (like blender now has)
2008-11-24 10:45:36 +00:00
else if(gt->type==WM_GESTURE_TWEAK)
wm_gesture_draw_line(win, gt);
2.5 - Added default Circle 'gesture' operator callbacks. As test, added in view3d window as Ckey, paint over object centers. - Fixed notifier for gesture, to only cause redraws in own region.
2008-12-21 16:24:19 +00:00
else if(gt->type==WM_GESTURE_CIRCLE)
wm_gesture_draw_circle(win, gt);
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
else if(gt->type==WM_GESTURE_CROSS_RECT) {
if(gt->mode==1)
wm_gesture_draw_rect(win, gt);
else
wm_gesture_draw_cross(win, gt);
}
2.5 - Node editor: link cut back, now under ALT+LMB, to prevent accidents. Note it now nicely intersects the real curved noodles with a line you draw! - To make above work, replaced ogl curve draw with own bezier code. - Added new WM standard operator callback for lines-gesture, the Lasso gesture now draws a closed line. - Both callbacks have optional property 'cursor' to make it give modal info. For future also linestyle or color can be defined. - Changed 'pin' icon in Image header to something that looks less scary... but there's no pin icon yet?
2009-02-07 14:03:34 +00:00
else if(gt->type==WM_GESTURE_LINES)
wm_gesture_draw_lasso(win, gt);
2.5 - Lasso select back (CTRL+LMB), object centers only, and for editmesh. See template in wm_operators.c - Circle select for editmode back. Currently it still uses Ckey, and is only a temporary mode, not persistant. Persistant circle select can be added later with tweak gesture keymap? We'll see. :) The old circle select was actually annoying that it was so sticky.
2009-01-02 14:11:18 +00:00
else if(gt->type==WM_GESTURE_LASSO)
wm_gesture_draw_lasso(win, gt);
New "Gesture Manager" system. This is a first implementation of the "gesture manager" system, the idea is put the WM in a automatic draw mode so we can implement different "Gesture types" to draw different class of data (lasso, bound box, etc). The gesture data is passed through the data field of the notifiers, i think that we can change this to something like: WM_gesture_init(C, data); /* put the data in the context. */ while() { /* send WM_NOTE_GESTURE_CHANGED to update screen */ } /* send event and free the data in the context. */ WM_gesture_end(C); Also i add a new operator and event to test the gesture manager. The new operator is the "border select" function, just press BKEY in the window and LMB or ESCKEY to exit. In the case of LMB you can see a print in the console about the BORDERSELECT event. All this still need a lot of work, comment are welcome.
2008-01-19 17:54:05 +00:00
}
}
2.5: gesture code in WM - Simplified and cleaned previous border code It was a bit too complex, too many data manipulations Original idea was to have WM API calls to manage border, circle, lines, lasso, etc. This now means that WM provides callbacks for custom operators, so it's very easy to make them. Check bottom of screen_edit.c for an example. Currently two borders were coded; with and without cross hair. Press Bkey in any area-region to test it (note: time window has wrong matrix!) Some specs to note: - gestures are in region space, and draw 'over'. That latter still needs some work when we do real composites. - only the active region is redrawn. - on todo is the generic gesture engine for 'tweak' or like how currently grab gestures in Blender work. These will be configurable per area-region, and WM then will send the proper "Gesture Event" with properties (N, S, E, W, etc) to which you then can assign operators. Such events will be generated with low priority, so other handlers who swallowed mouse events have preference.
2008-11-19 13:16:05 +00:00
2.5 Notifier system upgrade, based on Brecht's doc. Implementation notes: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers#Implementation In short: let's try to strictly communicate in a notifier what happened. The listeners then can act themselves. It also means that a frame-changed notifier doesn't send out redraws, the editors themselves can decide.
2008-12-27 16:09:56 +00:00
void wm_gesture_tag_redraw(bContext *C)
{
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
wmWindow *win= CTX_wm_window(C);
2.5 Notifier system upgrade, based on Brecht's doc. Implementation notes: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers#Implementation In short: let's try to strictly communicate in a notifier what happened. The listeners then can act themselves. It also means that a frame-changed notifier doesn't send out redraws, the editors themselves can decide.
2008-12-27 16:09:56 +00:00
bScreen *screen= CTX_wm_screen(C);
ARegion *ar= CTX_wm_region(C);
if(screen)
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
screen->do_draw_gesture= 1;
if(ar && win->drawmethod != USER_DRAW_TRIPLE)
2.5 Notifier system upgrade, based on Brecht's doc. Implementation notes: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers#Implementation In short: let's try to strictly communicate in a notifier what happened. The listeners then can act themselves. It also means that a frame-changed notifier doesn't send out redraws, the editors themselves can decide.
2008-12-27 16:09:56 +00:00
ED_region_tag_redraw(ar);
}
2.5: WM Compositing * Triple Buffer is now more complete: - Proper handling of window resize, duplicate, etc. - It now uses 3x3 textures (or less) if the power of two sizes do not match well. That still has a worst case wast of 23.4%, but better than 300%. - It can also use the ARB/NV/EXT_texture_rectangle extension now, which may be supported on hardware that does not support ARB_texture_non_power_of_two. - Gesture, menu and brushe redraws now require no redraws at all from the area regions. So even on a high poly scene just moving the paint cursor or opening a menu should be fast. * Testing can be done by setting the "Window Draw Method" in the User Preferences in the outliner. "Overlap" is still default, since "Triple Buffer" has not been tested on computers other than mine, would like to avoid crashing Blender on startup in case there is a common bug, but it's ready for testing now. - For reference "Full" draws the full window each time. - "Triple Buffer" should work for both swap copy and swap exchange systems, the latter still need the -E command line option for "Overlap". - Resizing and going fullscreen still gives flicker here but no more than "Full" drawing. * Partial Redraw was added. ED_region_tag_redraw_partial takes a rect in window coordinates to define a subarea of the region. On region draw it will then set glScissor to a smaller area, and ar->drawrct will always be set to either the partial or full window rect. The latter can then be used for clipping in the 3D view or clipping interface drawing. Neither is implemented yet.
2009-01-23 03:52:52 +00:00
Copy Permalink