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
59147ad98391c0e15621c0c743b094bbf14bfe07
blender-archive/source/blender/windowmanager/intern/wm_keymap.c

554 lines
10 KiB
C
Raw Normal View History

Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <string.h>
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
#include "DNA_screen_types.h"
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
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"
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
#include "BKE_library.h"
#include "BKE_main.h"
2.5 Operator calls: extended WM_operator_name_call() with options whether to call the exec() (operate immediate) or invoke() (check user input) entry. This will allow python to use it more efficiently, but also solves the dreaded pulldown case that showed another menu for confirmation. New names to learn: :) WM_OP_EXEC_DEFAULT WM_OP_INVOKE_DEFAULT on todo still: allow hotkey definitions to do same.
2008-12-26 12:21:06 +00:00
#include "BKE_utildefines.h"
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
#include "RNA_access.h"
#include "RNA_types.h"
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
#include "WM_api.h"
#include "WM_types.h"
#include "wm_window.h"
#include "wm_event_system.h"
#include "wm_event_types.h"
/* ***************** generic call, exported **************** */
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
static void keymap_event_set(wmKeymapItem *kmi, short type, short val, int modifier, short keymodifier)
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
{
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
kmi->type= type;
kmi->val= val;
kmi->keymodifier= keymodifier;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Better implementation of own window timers, not using ghost. That makes blender's WM nice in control, and gives callers of timers the opportunitie to evaluate time passed since previous step. This system also only generates one timer event per main loop (events - handlers - notifiers - draw) Small fix: allow keymap modifier to give KM_ANY to ignore modifier keys, this to have TIMER keymap work.
2008-12-22 12:57:53 +00:00
if(modifier == KM_ANY) {
kmi->shift= kmi->ctrl= kmi->alt= kmi->oskey= KM_ANY;
}
else {
if(modifier & KM_SHIFT)
kmi->shift= 1;
else if(modifier & KM_SHIFT2)
kmi->shift= 2;
if(modifier & KM_CTRL)
kmi->ctrl= 1;
else if(modifier & KM_CTRL2)
kmi->ctrl= 2;
if(modifier & KM_ALT)
kmi->alt= 1;
else if(modifier & KM_ALT2)
kmi->alt= 2;
if(modifier & KM_OSKEY)
kmi->oskey= 1;
else if(modifier & KM_OSKEY2)
kmi->oskey= 2;
}
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
}
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
static void keymap_properties_set(wmKeymapItem *kmi)
{
if(!kmi->ptr) {
RNA * Object has some more properties wrapped, mostly game related. * Scene frame changes now send a notifier. * Added functions to create/free operator properties for calling operators. This also simplifies some duplicated code that did this. Ideally though this kind of thing should use the properties pointer provided by buttons and keymap items. Example code: PointerRNA ptr; WM_operator_properties_create(&ptr, "SOME_OT_name"); RNA_int_set(&ptr, "value", 42); WM_operator_name_call(C, "SOME_OT_name", WM_OP_EXEC_DEFAULT, &ptr); WM_operator_properties_free(&ptr);
2009-01-01 20:44:40 +00:00
kmi->ptr= MEM_callocN(sizeof(PointerRNA), "wmKeymapItemPtr");
WM_operator_properties_create(kmi->ptr, kmi->idname);
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +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
/* if item was added, then bail out */
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
wmKeymapItem *WM_keymap_verify_item(ListBase *lb, char *idname, short type, short val, int modifier, short keymodifier)
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
{
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
wmKeymapItem *kmi;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
for(kmi= lb->first; kmi; kmi= kmi->next)
if(strncmp(kmi->idname, idname, OP_MAX_TYPENAME)==0)
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
break;
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
if(kmi==NULL) {
kmi= MEM_callocN(sizeof(wmKeymapItem), "keymap entry");
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
BLI_addtail(lb, kmi);
BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
keymap_event_set(kmi, type, val, modifier, keymodifier);
keymap_properties_set(kmi);
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
}
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
return kmi;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
}
/* if item was added, then replace */
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
wmKeymapItem *WM_keymap_set_item(ListBase *lb, char *idname, short type, short val, int modifier, short keymodifier)
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
{
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
wmKeymapItem *kmi;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
for(kmi= lb->first; kmi; kmi= kmi->next)
if(strncmp(kmi->idname, idname, OP_MAX_TYPENAME)==0)
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
break;
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
if(kmi==NULL) {
kmi= MEM_callocN(sizeof(wmKeymapItem), "keymap entry");
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
BLI_addtail(lb, kmi);
BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
}
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
keymap_event_set(kmi, type, val, modifier, keymodifier);
keymap_properties_set(kmi);
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
return kmi;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
}
Blender 2.5 project: added first more complex handler + operator - on mouse-over edge, you can drag area borders around. - note it's a handerized system now, so it updates UI while you move mouse. Feedback needed: - read bottom part of the screen_edit.c file. It's the proposed method for adding tools and handlers. I think it's close, but might need some tweaks.
2008-01-10 17:38:17 +00:00
/* always add item */
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
wmKeymapItem *WM_keymap_add_item(ListBase *lb, char *idname, short type, short val, int modifier, short keymodifier)
Blender 2.5 project: added first more complex handler + operator - on mouse-over edge, you can drag area borders around. - note it's a handerized system now, so it updates UI while you move mouse. Feedback needed: - read bottom part of the screen_edit.c file. It's the proposed method for adding tools and handlers. I think it's close, but might need some tweaks.
2008-01-10 17:38:17 +00:00
{
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
wmKeymapItem *kmi= MEM_callocN(sizeof(wmKeymapItem), "keymap entry");
Blender 2.5 project: added first more complex handler + operator - on mouse-over edge, you can drag area borders around. - note it's a handerized system now, so it updates UI while you move mouse. Feedback needed: - read bottom part of the screen_edit.c file. It's the proposed method for adding tools and handlers. I think it's close, but might need some tweaks.
2008-01-10 17:38:17 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
BLI_addtail(lb, kmi);
BLI_strncpy(kmi->idname, idname, OP_MAX_TYPENAME);
Blender 2.5 project: added first more complex handler + operator - on mouse-over edge, you can drag area borders around. - note it's a handerized system now, so it updates UI while you move mouse. Feedback needed: - read bottom part of the screen_edit.c file. It's the proposed method for adding tools and handlers. I think it's close, but might need some tweaks.
2008-01-10 17:38:17 +00:00
2.5: added support for setting RNA properties in keymap item, which will then be set when the operator is called, example: kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, 0, 0); RNA_enum_set(kmi->ptr, "dir", 'h'); kmi= WM_keymap_add_item(keymap, "ED_SCR_OT_region_split", SKEY, KM_PRESS, KM_SHIFT, 0); RNA_enum_set(kmi->ptr, "dir", 'v'); There is a hack I had to do here, since properties are defined as member of wmOperator, will try to fix later, committing now so it can be used already.
2008-12-15 13:10:29 +00:00
keymap_event_set(kmi, type, val, modifier, keymodifier);
keymap_properties_set(kmi);
2.5 funtion WM_keymap_add_item() now returns keymap-item, so you can use it to set default properties for operators with WM_keymap_property_set(). Brecht will fill in this function, requires rna magic! Example: an operator ED_OB_OT_add_primitive can be configured with keymap like this: WM_keymap_property_set(keymapitem, "Primitivetype", "Sphere"); Similar conventions we can use later for button/menu calls. This will make creating operators easier, allowing a developer to group tools functionality nicely.
2008-12-15 11:45:17 +00:00
return kmi;
}
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
/* ****************** storage in WM ************ */
/* name id's are for storing general or multiple keymaps,
space/region ids are same as DNA_space_types.h */
/* gets free'd in wm.c */
ListBase *WM_keymap_listbase(wmWindowManager *wm, const char *nameid, int spaceid, int regionid)
{
wmKeyMap *km;
for(km= wm->keymaps.first; km; km= km->next)
if(km->spaceid==spaceid && km->regionid==regionid)
if(0==strncmp(nameid, km->nameid, KMAP_MAX_NAME))
break;
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
2.5 Part one of wrapping up area/region management. Read design doc here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This commit: - brings keymap storage to WM, based on names/types. This structure allows rna-ifying it too, so you can browse keymaps etc. - creating areas and regions works slightly different now, wich regiontypes stored in areatype. Todo: - better callbacks and structure for defining which handlers need to be added. - using region types to validate regions - proper implementation of local region data - code method for customizing keymaps. Current idea is that you have to indicate an entire keymap to be custom, to prevent too complicated merging problems of default and custom maps (like order, multiple keys for same operator, disabling options, etc).
2008-12-08 15:02:57 +00:00
if(km==NULL) {
km= MEM_callocN(sizeof(struct wmKeyMap), "keymap list");
BLI_strncpy(km->nameid, nameid, KMAP_MAX_NAME);
km->spaceid= spaceid;
km->regionid= regionid;
BLI_addtail(&wm->keymaps, km);
}
return &km->keymap;
}
Step 3 for the initial commits for 2.5: removing src/ and python, adding new windowmanager module, and the first bits of new editors module.
2007-12-24 18:27:28 +00:00
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
/* ***************** get string from key events **************** */
char *WM_key_event_string(short type)
{
/* not returned: CAPSLOCKKEY, UNKNOWNKEY, COMMANDKEY, GRLESSKEY */
switch(type) {
case AKEY:
return "A";
break;
case BKEY:
return "B";
break;
case CKEY:
return "C";
break;
case DKEY:
return "D";
break;
case EKEY:
return "E";
break;
case FKEY:
return "F";
break;
case GKEY:
return "G";
break;
case HKEY:
return "H";
break;
case IKEY:
return "I";
break;
case JKEY:
return "J";
break;
case KKEY:
return "K";
break;
case LKEY:
return "L";
break;
case MKEY:
return "M";
break;
case NKEY:
return "N";
break;
case OKEY:
return "O";
break;
case PKEY:
return "P";
break;
case QKEY:
return "Q";
break;
case RKEY:
return "R";
break;
case SKEY:
return "S";
break;
case TKEY:
return "T";
break;
case UKEY:
return "U";
break;
case VKEY:
return "V";
break;
case WKEY:
return "W";
break;
case XKEY:
return "X";
break;
case YKEY:
return "Y";
break;
case ZKEY:
return "Z";
break;
case ZEROKEY:
return "Zero";
break;
case ONEKEY:
return "One";
break;
case TWOKEY:
return "Two";
break;
case THREEKEY:
return "Three";
break;
case FOURKEY:
return "Four";
break;
case FIVEKEY:
return "Five";
break;
case SIXKEY:
return "Six";
break;
case SEVENKEY:
return "Seven";
break;
case EIGHTKEY:
return "Eight";
break;
case NINEKEY:
return "Nine";
break;
case LEFTCTRLKEY:
return "Leftctrl";
break;
case LEFTALTKEY:
return "Leftalt";
break;
case RIGHTALTKEY:
return "Rightalt";
break;
case RIGHTCTRLKEY:
return "Rightctrl";
break;
case RIGHTSHIFTKEY:
return "Rightshift";
break;
case LEFTSHIFTKEY:
return "Leftshift";
break;
case ESCKEY:
return "Esc";
break;
case TABKEY:
return "Tab";
break;
case RETKEY:
return "Ret";
break;
case SPACEKEY:
return "Space";
break;
case LINEFEEDKEY:
return "Linefeed";
break;
case BACKSPACEKEY:
return "Backspace";
break;
case DELKEY:
return "Del";
break;
case SEMICOLONKEY:
return "Semicolon";
break;
case PERIODKEY:
return "Period";
break;
case COMMAKEY:
return "Comma";
break;
case QUOTEKEY:
return "Quote";
break;
case ACCENTGRAVEKEY:
return "Accentgrave";
break;
case MINUSKEY:
return "Minus";
break;
case SLASHKEY:
return "Slash";
break;
case BACKSLASHKEY:
return "Backslash";
break;
case EQUALKEY:
return "Equal";
break;
case LEFTBRACKETKEY:
return "Leftbracket";
break;
case RIGHTBRACKETKEY:
return "Rightbracket";
break;
case LEFTARROWKEY:
return "Leftarrow";
break;
case DOWNARROWKEY:
return "Downarrow";
break;
case RIGHTARROWKEY:
return "Rightarrow";
break;
case UPARROWKEY:
return "Uparrow";
break;
case PAD2:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 2";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD4:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 4";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD6:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 6";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD8:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 8";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD1:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 1";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD3:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 3";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD5:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 5";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD7:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 7";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD9:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 9";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADPERIOD:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad .";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADSLASHKEY:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad /";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADASTERKEY:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad *";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PAD0:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad 0";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADMINUS:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad -";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADENTER:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad Enter";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case PADPLUSKEY:
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
return "Numpad +";
UI: bring back function to convert keyboard event to string, and make the key event button work again.
2008-12-16 07:32:12 +00:00
break;
case F1KEY:
return "F1";
break;
case F2KEY:
return "F2";
break;
case F3KEY:
return "F3";
break;
case F4KEY:
return "F4";
break;
case F5KEY:
return "F5";
break;
case F6KEY:
return "F6";
break;
case F7KEY:
return "F7";
break;
case F8KEY:
return "F8";
break;
case F9KEY:
return "F9";
break;
case F10KEY:
return "F10";
break;
case F11KEY:
return "F11";
break;
case F12KEY:
return "F12";
break;
case PAUSEKEY:
return "Pause";
break;
case INSERTKEY:
return "Insert";
break;
case HOMEKEY:
return "Home";
break;
case PAGEUPKEY:
return "Pageup";
break;
case PAGEDOWNKEY:
return "Pagedown";
break;
case ENDKEY:
return "End";
break;
}
return "";
}
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
static char *wm_keymap_item_to_string(wmKeymapItem *kmi, char *str, int len)
{
char buf[100];
buf[0]= 0;
if(kmi->shift)
strcat(buf, "Shift ");
if(kmi->ctrl)
strcat(buf, "Ctrl ");
UI: * Only open tooltip when the mouse is still over the button. * Remove an unnecessary redraw call, though the two mentioned in the previous commit seem to be working OK (it's for action buttons when you move the mouse away from the button, holding the mouse button down). * Fix missing alt key in key event strings.
2008-12-16 17:36:51 +00:00
if(kmi->alt)
strcat(buf, "Alt ");
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
if(kmi->oskey)
strcat(buf, "OS ");
strcat(buf, WM_key_event_string(kmi->type));
BLI_strncpy(str, buf, len);
return str;
}
UI: various changes * View2D to region now returns ints instead of shorts. * Use "Numpad" instead of "Pad" in automatic keymap menu info. * Menus can now use buttons other than BUTM and SEPR, in particular TOG and ROW are now supported instead of flipping bits manually. * Added a simpler uiDefMenu* api for making menus now, and it only supports Operator and RNA buttons at the moment, will be used in next commit. Not sure how this will evolve .. makes menu code look cleaner anyways. * Ensure that interface code doesn't crash when getting unknown Operators and RNA properties, and display their buttons grayed out in that case.
2009-01-15 04:13:38 +00:00
char *WM_key_event_operator_string(const bContext *C, const char *opname, int opcontext, char *str, int len)
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
{
wmEventHandler *handler;
wmKeymapItem *kmi;
ListBase *handlers= NULL;
/* find right handler list based on specified context */
2.5 Operator calls: extended WM_operator_name_call() with options whether to call the exec() (operate immediate) or invoke() (check user input) entry. This will allow python to use it more efficiently, but also solves the dreaded pulldown case that showed another menu for confirmation. New names to learn: :) WM_OP_EXEC_DEFAULT WM_OP_INVOKE_DEFAULT on todo still: allow hotkey definitions to do same.
2008-12-26 12:21:06 +00:00
if(ELEM(opcontext, WM_OP_EXEC_REGION_WIN, WM_OP_INVOKE_REGION_WIN)) {
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
if(CTX_wm_area(C)) {
ARegion *ar= CTX_wm_area(C)->regionbase.first;
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
for(; ar; ar= ar->next)
if(ar->regiontype==RGN_TYPE_WINDOW)
break;
if(ar)
handlers= &ar->handlers;
}
}
2.5 Operator calls: extended WM_operator_name_call() with options whether to call the exec() (operate immediate) or invoke() (check user input) entry. This will allow python to use it more efficiently, but also solves the dreaded pulldown case that showed another menu for confirmation. New names to learn: :) WM_OP_EXEC_DEFAULT WM_OP_INVOKE_DEFAULT on todo still: allow hotkey definitions to do same.
2008-12-26 12:21:06 +00:00
else if(ELEM(opcontext, WM_OP_EXEC_AREA, WM_OP_INVOKE_AREA)) {
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
if(CTX_wm_area(C))
handlers= &CTX_wm_area(C)->handlers;
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
}
2.5 Operator calls: extended WM_operator_name_call() with options whether to call the exec() (operate immediate) or invoke() (check user input) entry. This will allow python to use it more efficiently, but also solves the dreaded pulldown case that showed another menu for confirmation. New names to learn: :) WM_OP_EXEC_DEFAULT WM_OP_INVOKE_DEFAULT on todo still: allow hotkey definitions to do same.
2008-12-26 12:21:06 +00:00
else if(ELEM(opcontext, WM_OP_EXEC_SCREEN, WM_OP_INVOKE_SCREEN)) {
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
if(CTX_wm_window(C))
handlers= &CTX_wm_window(C)->handlers;
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
}
else {
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
if(CTX_wm_region(C))
handlers= &CTX_wm_region(C)->handlers;
WM: changed WM_operator_call to take an argument, which specifies in which context to run the operator: WM_OP_DEFAULT, WM_OP_REGION_WIN, WM_OP_AREA or WM_OP_SCREEN. This also replaces WM_operator_call_rwin since it is more general. This is useful for buttons and popup menus to run operators, and also used by a new function to lookup the keymap item for that operator in the right context.
2008-12-16 07:44:21 +00:00
}
if(!handlers)
return NULL;
/* find keymap item in handlers */
for(handler=handlers->first; handler; handler=handler->next)
if(handler->keymap)
for(kmi=handler->keymap->first; kmi; kmi=kmi->next)
if(strcmp(kmi->idname, opname) == 0 && WM_key_event_string(kmi->type)[0])
return wm_keymap_item_to_string(kmi, str, len);
return NULL;
}
Copy Permalink