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
6cd132b29c30f4f55e1a216bf9fc583becd41dd5
blender-archive/source/blender/windowmanager/intern/wm_gesture.c

389 lines
10 KiB
C
Raw Normal View History

doxygen: prevent GPL license block from being parsed as doxygen comment.
2011-02-23 10:52:22 +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
* ***** 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,
correct fsf address
2010-02-12 13:34:04 +00:00
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
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
*
* The Original Code is Copyright (C) 2008 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
doxygen: blender/windowmanager tagged.
2011-02-25 14:04:21 +00:00
/** \file blender/windowmanager/intern/wm_gesture.c
* \ingroup wm
*/
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"
Use #include "BLI_math.h" instead of _USE_MATH_DEFINES to get M_PI defined.
2010-01-26 11:25:39 +00:00
#include "BLI_math.h"
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
#include "BLI_scanfill.h" /* lasso tessellation */
split BKE_utildefines.h, now it only has blender specific defines like GS() MAKE_ID, FILE_MAXDIR, moved the generic defines to BLI_utildefines.h. no functional changes.
2011-01-07 18:36:47 +00:00
#include "BLI_utildefines.h"
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
#include "BLI_lasso.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
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"
remove references to BKE_utildefines where its not needed. - move GS() define into DNA_ID.h - add BLI_utildefines as an automatic include with makesrna generated files.
2011-01-07 19:18:31 +00:00
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"
Sculpt Mode Bugfixes: * #20833: layer brush doesn't work with multires. * #20946: sculpt mode partially removes parts of the mesh in the viewport. * #20420: grab brush stops after moving some distance. * #20906: sculpt grab tool moves in wrong direction. * #21132 and #21272: undo on object with subdivision surface modifier crashes. * #21115: subsurf + multires + sculpting + undo causes crash. * #20683: sculpt + multires apply + undo crash. * #19094: wrong outline in solid mode.
2010-03-22 11:59:36 +00:00
#include "wm_draw.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
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 */
code cleanup: use const events for modal and invoke operators.
2013-03-13 09:03:46 +00:00
wmGesture *WM_gesture_new(bContext *C, const 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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmGesture *gesture = MEM_callocN(sizeof(wmGesture), "new gesture");
wmWindow *window = CTX_wm_window(C);
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
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
gesture->type = type;
gesture->event_type = event->type;
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
style cleanyp: split > 120 width lines.
2012-02-19 06:00:20 +00:00
if (ELEM5(type, WM_GESTURE_RECT, WM_GESTURE_CROSS_RECT, WM_GESTURE_TWEAK,
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
WM_GESTURE_CIRCLE, WM_GESTURE_STRAIGHTLINE))
style cleanyp: split > 120 width lines.
2012-02-19 06:00:20 +00:00
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
rcti *rect = MEM_callocN(sizeof(rcti), "gesture rect new");
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
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
gesture->customdata = rect;
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
rect->xmin = event->x - sx;
rect->ymin = event->y - sy;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (type == WM_GESTURE_CIRCLE) {
- 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
#ifdef GESTURE_MEMORY
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
rect->xmax = circle_select_size;
- 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
#else
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +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
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
}
else {
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
rect->xmax = event->x - sx;
rect->ymax = event->y - sy;
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
}
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;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
gesture->customdata = lasso = MEM_callocN(2 * sizeof(short) * WM_LASSO_MIN_POINTS, "lasso points");
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
lasso[0] = event->x - sx;
lasso[1] = event->y - sy;
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
gesture->points = 1;
[#20581] Lasso tool ends unexpectedly Don't limit lasso to 1024 points, just realloc array with increased size when current limit is reached. Also silence two stupid warnings.
2010-01-10 20:16:56 +00:00
gesture->size = WM_LASSO_MIN_POINTS;
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
}
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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindow *win = CTX_wm_window(C);
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (win->tweak == gesture)
win->tweak = NULL;
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
BLI_remlink(&win->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);
code cleanup and minor changes - use DummyRNA_NULL_items to replace empty enums. - replace calloc with malloc in copy_dverts since its copied over after. - add wmGesture->userdata, so operators that use gestures have somewhere to store their own data (not used yet).
2012-12-22 01:08:42 +00:00
if (gesture->userdata) {
MEM_freeN(gesture->userdata);
}
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);
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
}
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
void WM_gestures_remove(bContext *C)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindow *win = CTX_wm_window(C);
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
while (win->gesture.first)
Drag and drop 2.5 integration! Finally, slashdot regulars can use Blender too now! :) ** Drag works as follows: - drag-able items are defined by the standard interface ui toolkit - each button can get this feature, via uiButSetDragXXX(but, ...). There are calls to define drag-able images, ID blocks, RNA paths, file paths, and so on. By default you drag an icon, exceptionally an ImBuf - Drag items are registered centrally in the WM, it allows more drag items simultaneous too, but not implemented ** Drop works as follows: - On mouse release, and if drag items exist in the WM, it converts the mouse event to an EVT_DROP type. This event then gets the full drag info as customdata - drop regions are defined with WM_dropbox_add(), similar to keymaps you can make a "drop map" this way, which become 'drop map handlers' in the queues. - next to that the UI kit handles some common button types (like accepting ID or names) to be catching a drop event too. - Every "drop box" has two callbacks: - poll() = check if the event drag data is relevant for this box - copy() = fill in custom properties in the dropbox to initialize an operator - The dropbox handler then calls its standard Operator with its dropbox properties. ** Currently implemented Drag items: - ID icons in browse buttons - ID icons in context menu of properties region - ID icons in outliner and rna viewer - FileBrowser icons - FileBrowser preview images Drag-able icons are subtly visualized by making them brighter a bit on mouse-over. In case the icon is a button or UI element too (most cases), the drag-able feature will make the item react to mouse-release instead of mouse-press. Drop options: - UI buttons: ID and text buttons (paste name) - View3d: Object ID drop copies object - View3d: Material ID drop assigns to object under cursor - View3d: Image ID drop assigns to object UV texture under cursor - Sequencer: Path drop will add either Image or Movie strip - Image window: Path drop will open image ** Drag and drop Notes: - Dropping into another Blender window (from same application) works too. I've added code that passes on mousemoves and clicks to other windows, without activating them though. This does make using multi-window Blender a bit friendler. - Dropping a file path to an image, is not the same as dropping an Image ID... keep this in mind. Sequencer for example wants paths to be dropped, textures in 3d window wants an Image ID. - Although drop boxes could be defined via Python, I suggest they're part of the UI and editor design (= how we want an editor to work), and not default offered configurable like keymaps. - At the moment only one item can be dragged at a time. This is for several reasons.... For one, Blender doesn't have a well defined uniform way to define "what is selected" (files, outliner items, etc). Secondly there's potential conflicts on what todo when you drop mixed drag sets on spots. All undefined stuff... nice for later. - Example to bypass the above: a collection of images that form a strip, should be represented in filewindow as a single sequence anyway. This then will fit well and gets handled neatly by design. - Another option to check is to allow multiple options per drop... it could show the operator as a sort of menu, allowing arrow or scrollwheel to choose. For time being I'd prefer to try to design a singular drop though, just offer only one drop action per data type on given spots. - What does work already, but a tad slow, is to use a function that detects an object (type) under cursor, so a drag item's option can be further refined (like drop object on object = parent). (disabled) ** More notes - Added saving for Region layouts (like split points for toolbar) - Label buttons now handle mouse over - File list: added full path entry for drop feature. - Filesel bugfix: wm_operator_exec() got called there and fully handled, while WM event code tried same. Added new OPERATOR_HANDLED flag for this. Maybe python needs it too? - Cocoa: added window move event, so multi-win setups work OK (didnt save). - Interface_handlers.c: removed win->active - Severe area copy bug: area handlers were not set to NULL - Filesel bugfix: next/prev folder list was not copied on area copies ** Leftover todos - Cocoa windows seem to hang on cases still... needs check - Cocoa 'draw overlap' swap doesn't work - Cocoa window loses focus permanently on using Spotlight (for these reasons, makefile building has Carbon as default atm) - ListView templates in UI cannot become dragged yet, needs review... it consists of two overlapping UI elements, preventing handling icon clicks. - There's already Ghost library code to handle dropping from OS into Blender window. I've noticed this code is unfinished for Macs, but seems to be complete for Windows. Needs test... currently, an external drop event will print in console when succesfully delivered to Blender's WM.
2010-01-26 18:18:21 +00:00
WM_gesture_end(C, win->gesture.first);
}
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 */
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
int wm_gesture_evaluate(wmGesture *gesture)
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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (gesture->type == WM_GESTURE_TWEAK) {
rcti *rect = gesture->customdata;
code cleanup: replace macro for BLI_rect size/center with inline functions.
2012-09-15 11:48:20 +00:00
int dx = BLI_rcti_size_x(rect);
int dy = BLI_rcti_size_y(rect);
Code Cleanup: use iroundf also increase precision of rctf print functions
2014-01-15 13:00:03 +11:00
if (abs(dx) + abs(dy) > U.tweak_threshold) {
int theta = iroundf(4.0f * atan2f((float)dy, (float)dx) / (float)M_PI);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +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;
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
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 */
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
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");
style cleanup: whitespace/indentation
2012-05-19 13:55:54 +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
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
static void wm_gesture_draw_rect(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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
rcti *rect = (rcti *)gt->customdata;
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
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
}
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
static void wm_gesture_draw_line(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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
rcti *rect = (rcti *)gt->customdata;
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);
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);
}
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
static void wm_gesture_draw_circle(wmGesture *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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
rcti *rect = (rcti *)gt->customdata;
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
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);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glutil_draw_filled_arc(0.0, M_PI * 2.0, rect->xmax, 40);
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);
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);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glutil_draw_lined_arc(0.0, M_PI * 2.0, rect->xmax, 40);
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
glColor3ub(255, 255, 255);
glLineStipple(1, 0x5555);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
glutil_draw_lined_arc(0.0, M_PI * 2.0, rect->xmax, 40);
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
glDisable(GL_LINE_STIPPLE);
style cleanup
2012-07-04 20:47:12 +00:00
glTranslatef(-rect->xmin, -rect->ymin, 0.0f);
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
}
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
struct LassoFillData {
unsigned int *px;
int width;
};
static void draw_filled_lasso_px_cb(int x, int y, void *user_data)
{
struct LassoFillData *data = user_data;
unsigned char *col = (unsigned char *)&(data->px[(y * data->width) + x]);
col[0] = col[1] = col[2] = 0xff;
col[3] = 0x10;
}
static void draw_filled_lasso(wmWindow *win, 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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
short *lasso = (short *)gt->customdata;
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
const int tot = gt->points;
int (*moves)[2] = MEM_mallocN(sizeof(*moves) * (tot + 1), __func__);
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
int i;
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
rcti rect;
rcti rect_win;
for (i = 0; i < tot; i++, lasso += 2) {
moves[i][0] = lasso[0];
moves[i][1] = lasso[1];
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
}
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
BLI_lasso_boundbox(&rect, (const int (*)[2])moves, tot);
wm_subwindow_getrect(win, gt->swinid, &rect_win);
BLI_rcti_translate(&rect, rect_win.xmin, rect_win.ymin);
BLI_rcti_isect(&rect_win, &rect, &rect);
BLI_rcti_translate(&rect, -rect_win.xmin, -rect_win.ymin);
/* highly unlikely this will fail, but could crash if (tot == 0) */
if (BLI_rcti_is_empty(&rect) == false) {
const int w = BLI_rcti_size_x(&rect);
const int h = BLI_rcti_size_y(&rect);
unsigned int *pixel_buf = MEM_callocN(sizeof(*pixel_buf) * w * h, __func__);
struct LassoFillData lasso_fill_data = {pixel_buf, w};
fill_poly_v2i_n(
rect.xmin, rect.ymin, rect.xmax, rect.ymax,
(const int (*)[2])moves, tot,
draw_filled_lasso_px_cb, &lasso_fill_data);
fix for compiler error, probably unlikely but if 'v' is NULL it could crash.
2010-01-15 17:19:01 +00:00
glEnable(GL_BLEND);
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
// glColor4f(1.0, 1.0, 1.0, 0.05);
glRasterPos2f(rect.xmin, rect.ymin);
glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixel_buf);
fix for compiler error, probably unlikely but if 'v' is NULL it could crash.
2010-01-15 17:19:01 +00:00
glDisable(GL_BLEND);
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
MEM_freeN(pixel_buf);
fix for compiler error, probably unlikely but if 'v' is NULL it could crash.
2010-01-15 17:19:01 +00:00
}
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
MEM_freeN(moves);
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
}
fix for lasso failing/glitches on overlapping lines, replace scanfill with 2d pixel filling for drawing and selection.
2013-10-04 15:02:05 +00:00
patch [#37217] Make WM_gesture_lines draw the lasso unfilled. (Adding reroute nodes, cutting node links) by Henrik Aarnio (hjaarnio)
2013-10-29 00:05:03 +00:00
static void wm_gesture_draw_lasso(wmWindow *win, wmGesture *gt, bool filled)
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
short *lasso = (short *)gt->customdata;
Replaced lasso gesture filling code with scanfill, not 100% as nice, but simpler and more compatible.
2010-01-07 01:27:10 +00:00
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
patch [#37217] Make WM_gesture_lines draw the lasso unfilled. (Adding reroute nodes, cutting node links) by Henrik Aarnio (hjaarnio)
2013-10-29 00:05:03 +00:00
if (filled) {
draw_filled_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
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);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (i = 0; i < gt->points; i++, lasso += 2)
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
glVertex2sv(lasso);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (gt->type == WM_GESTURE_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
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);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
lasso = (short *)gt->customdata;
for (i = 0; i < gt->points; i++, lasso += 2)
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
glVertex2sv(lasso);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (gt->type == WM_GESTURE_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
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)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
rcti *rect = (rcti *)gt->customdata;
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
const int winsize_x = WM_window_pixels_x(win);
const int winsize_y = WM_window_pixels_y(win);
Fix a few DPI / retina draw issues: * Color picker cursor was too small, and color cirle was not smooth enough. * Border select gesture cross before first click did not reach to the border of the window. * Buttons were not drawing emboss properly (also for non-retina actually). Note it doesn't draw entirely right for aligned buttons, but this was also the case before it got broken.
2013-02-10 18:03:01 +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
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);
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
sdrawline(rect->xmin - winsize_x, rect->ymin, rect->xmin + winsize_x, rect->ymin);
sdrawline(rect->xmin, rect->ymin - winsize_y, rect->xmin, rect->ymin + winsize_y);
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
glColor3ub(255, 255, 255);
glLineStipple(1, 0x3333);
Code cleanup: assign win size to const vars and some renaming
2013-12-11 12:42:04 +11:00
sdrawline(rect->xmin - winsize_x, rect->ymin, rect->xmin + winsize_x, rect->ymin);
sdrawline(rect->xmin, rect->ymin - winsize_y, rect->xmin, rect->ymin + winsize_y);
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
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
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmGesture *gt = (wmGesture *)win->gesture.first;
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
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
for (; gt; gt = gt->next) {
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
/* 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);
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
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
if (gt->type == WM_GESTURE_RECT)
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
wm_gesture_draw_rect(gt);
style cleanup
2012-05-27 19:40:36 +00:00
// else if (gt->type == WM_GESTURE_TWEAK)
Bug #25354 In some cases, a LMB-drag was drawing a stippled line. Leftover of WIP code for support of gestures in Blender. Disabled drawing for now, until gestures is back in control.
2010-12-23 10:34:37 +00:00
// wm_gesture_draw_line(gt);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (gt->type == WM_GESTURE_CIRCLE)
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
wm_gesture_draw_circle(gt);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (gt->type == WM_GESTURE_CROSS_RECT) {
if (gt->mode == 1)
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
wm_gesture_draw_rect(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
wm_gesture_draw_cross(win, gt);
}
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (gt->type == WM_GESTURE_LINES)
patch [#37217] Make WM_gesture_lines draw the lasso unfilled. (Adding reroute nodes, cutting node links) by Henrik Aarnio (hjaarnio)
2013-10-29 00:05:03 +00:00
wm_gesture_draw_lasso(win, gt, false);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (gt->type == WM_GESTURE_LASSO)
patch [#37217] Make WM_gesture_lines draw the lasso unfilled. (Adding reroute nodes, cutting node links) by Henrik Aarnio (hjaarnio)
2013-10-29 00:05:03 +00:00
wm_gesture_draw_lasso(win, gt, true);
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
else if (gt->type == WM_GESTURE_STRAIGHTLINE)
- UNUSED macro wasn't throwing an error with GCC if a var become used. - made interface, windowmanager, readfile build without unused warnings. - re-arranged CMake's source/blender build order so less changed libs are build later, eg: IK, avi
2010-10-16 02:40:31 +00:00
wm_gesture_draw_line(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)
{
style cleanup: wm, mosyly adding space around ops
2012-03-27 01:24:16 +00:00
wmWindow *win = CTX_wm_window(C);
bScreen *screen = CTX_wm_screen(C);
ARegion *ar = CTX_wm_region(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
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:24:53 +00:00
if (screen)
code cleanup: use TRUE/FALSE rather then 1/0 for better readability, also replace do prefix with do_ for bool vars.
2012-05-19 13:28:19 +00:00
screen->do_draw_gesture = TRUE;
Sculpt Mode Bugfixes: * #20833: layer brush doesn't work with multires. * #20946: sculpt mode partially removes parts of the mesh in the viewport. * #20420: grab brush stops after moving some distance. * #20906: sculpt grab tool moves in wrong direction. * #21132 and #21272: undo on object with subdivision surface modifier crashes. * #21115: subsurf + multires + sculpting + undo causes crash. * #20683: sculpt + multires apply + undo crash. * #19094: wrong outline in solid mode.
2010-03-22 11:59:36 +00:00
wm_tag_redraw_overlay(win, ar);
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
}
Copy Permalink