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
33ae33bd109d43cedc901bbe40b02aec777e8f37
blender-archive/source/blender/editors/space_time/space_time.c

703 lines
18 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
/*
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +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.
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
*
* The Original Code is Copyright (C) 2008 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
doxygen: blender/editors tagged.
2011-02-27 20:29:51 +00:00
/** \file blender/editors/space_time/space_time.c
* \ingroup sptime
*/
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
#include <string.h>
#include <stdio.h>
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
#include "DNA_object_types.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
#include "DNA_scene_types.h"
#include "MEM_guardedalloc.h"
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
#include "BLI_blenlib.h"
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
#include "BLI_dlrbTree.h"
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"
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
2.5 Context API This adds the context API as described here. The main practical change now is that C is not longer directly accessible but has to be accessed through accessor functions. This basically adds the implementation of the API and adaption of existing code with some minor changes. The next task of course is to actually use this design to cleanup of bad level calls and global access, in blenkernel, blenloader. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Context Error, Warning and Debug Info Reporting This adds the error reporting API as described here. It should help clean up error() calls in non-ui code, but eventually can become used for gathering messages for a console window, and throwing exceptions in python scripts when an error happens executing something. http://wiki.blender.org/index.php/BlenderDev/Blender2.5/Reports
2008-12-18 02:56:48 +00:00
#include "BKE_context.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
#include "BKE_global.h"
#include "BKE_screen.h"
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
#include "BKE_pointcache.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
Timeline Drawing Tweaks: * Made the TimeLine current frame indicator get drawn using the standard frame-indicator code. Also, it is now possible to show the frame indicator box beside the line as in the other animation editors, although this is disabled in the timeline due to the closeness of the frame number field. * Removed some old (unnecessary) code -> "Continue Physics" option in TimeLine, which is now obsolete with the current physics options. Feel free to restore if this is not the case. -> Already commented out hacks to create "speed ipo" for curves. There are easy alternatives that are better integrated. -> Unused init/exit callbacks for scrubbing time, since those were only used to set an obsolete flag for timeline drawing that is now used for the indicator. * Switched long-keyframe optimisation code to use constants instead of some magic numbers + fancy trickery...
2009-12-11 11:18:55 +00:00
#include "ED_anim_api.h"
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
#include "ED_keyframes_draw.h"
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
#include "ED_screen.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
#include "WM_api.h"
#include "WM_types.h"
#include "BIF_gl.h"
#include "BIF_glutil.h"
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
#include "UI_resources.h"
#include "UI_view2d.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
made most variables which are only used in a single file and not defined in header static for blenlib, blenkernel and editors.
2011-02-14 17:55:27 +00:00
#include "ED_space_api.h"
More testing with new system: - Added markers (partially) back, ed_markers.c (temporary in spacetime, where to put general stuff like this?), and added ED_markers.h for api. - Mkey in timewindow shows marker (no icon, doesnt work yet). (Adding operators gets easy :) - Noted some conflict for operator storage... with markers being used all over, added it to the screen level. - More todos: view2d is stored in space, for time, etc. With regions we could move this over, but better todo as post 2.5 project. Multiple 2d views in area would be cool though.
2008-11-24 18:59:59 +00:00
#include "ED_markers.h"
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
#include "time_intern.h"
/* ************************ main time area region *********************** */
editors/space_* build without unused args warnings
2010-10-16 08:03:28 +00:00
static void time_draw_sfra_efra(Scene *scene, View2D *v2d)
{
View2D - Some more tweaks... * Improved scrollbar drawing a bit more - only cosmetic lines * Added new view2d view-matrix api method to only use 'cur' coordinates on one axis, for use when drawing markers, etc. that need to be glued to a certain time but stay fixed in space in another dimension. This should improve the sitation for drawing markers * To aid testing, adding markers now sets the marker to have frame number as it's "name". This will need to be removed later...
2008-12-02 09:43:23 +00:00
/* draw darkened area outside of active timeline
Bugfix [#27548] Timeline view - 2D drawing issues * Keyframe lines were being drawn too short when frame number box was enabled. The code for drawing this was modifying the View2D view-space to get it's stuff in the right place, but the timeline code was not accounting for this. * In order to make the time ticks more visible outside the frame range, I've moved the start/end frame drawing stuff in timeline to occur after the grid drawing, and to draw semi-transparent, just like the preview range curtains in the other animation editors
2011-07-12 12:04:27 +00:00
* frame range used is preview range or scene range
*/
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
glColor4f(0.0f, 0.0f, 0.0f, 0.4f);
Bugfix [#27548] Timeline view - 2D drawing issues * Keyframe lines were being drawn too short when frame number box was enabled. The code for drawing this was modifying the View2D view-space to get it's stuff in the right place, but the timeline code was not accounting for this. * In order to make the time ticks more visible outside the frame range, I've moved the start/end frame drawing stuff in timeline to occur after the grid drawing, and to draw semi-transparent, just like the preview range curtains in the other animation editors
2011-07-12 12:04:27 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (PSFRA < PEFRA) {
glRectf(v2d->cur.xmin, v2d->cur.ymin, (float)PSFRA, v2d->cur.ymax);
glRectf((float)PEFRA, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
}
else {
glRectf(v2d->cur.xmin, v2d->cur.ymin, v2d->cur.xmax, v2d->cur.ymax);
}
Bugfix [#27548] Timeline view - 2D drawing issues * Keyframe lines were being drawn too short when frame number box was enabled. The code for drawing this was modifying the View2D view-space to get it's stuff in the right place, but the timeline code was not accounting for this. * In order to make the time ticks more visible outside the frame range, I've moved the start/end frame drawing stuff in timeline to occur after the grid drawing, and to draw semi-transparent, just like the preview range curtains in the other animation editors
2011-07-12 12:04:27 +00:00
glDisable(GL_BLEND);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
UI_ThemeColorShade(TH_BACK, -60);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
/* thin lines where the actual frames are */
2.5: Silencing MSVC warnings in a few files (many files still have many to clean out some other day).
2009-02-10 09:18:04 +00:00
fdrawline((float)PSFRA, v2d->cur.ymin, (float)PSFRA, v2d->cur.ymax);
fdrawline((float)PEFRA, v2d->cur.ymin, (float)PEFRA, v2d->cur.ymax);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
#define CACHE_DRAW_HEIGHT 3.0f
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
static void time_draw_cache(SpaceTime *stime, Object *ob)
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
{
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
PTCacheID *pid;
ListBase pidlist;
SpaceTimeCache *stc = stime->caches.first;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
float yoffs = 0.f;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
if (!(stime->cache_display & TIME_CACHE_DISPLAY) || (!ob))
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
return;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
BKE_ptcache_ids_from_object(&pidlist, ob, NULL, 0);
/* iterate over pointcaches on the active object,
* add spacetimecache and vertex array for each */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
for (pid = pidlist.first; pid; pid = pid->next) {
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
float col[4], *fp;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
int i, sta = pid->cache->startframe, end = pid->cache->endframe;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
int len = (end - sta + 1) * 4;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (pid->type) {
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
case PTCACHE_TYPE_SOFTBODY:
if (!(stime->cache_display & TIME_CACHE_SOFTBODY)) continue;
break;
case PTCACHE_TYPE_PARTICLES:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (!(stime->cache_display & TIME_CACHE_PARTICLES)) continue;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
break;
case PTCACHE_TYPE_CLOTH:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (!(stime->cache_display & TIME_CACHE_CLOTH)) continue;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
break;
case PTCACHE_TYPE_SMOKE_DOMAIN:
case PTCACHE_TYPE_SMOKE_HIGHRES:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (!(stime->cache_display & TIME_CACHE_SMOKE)) continue;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
break;
Dynamic Paint: Committed changes from previous weeks, biggest changes are: * Canvas can now have multiple "surfaces" that each can have specific format, type and settings. * Renewed UI to support this new system. * Aside from old "image sequence" output format, Dynamic Paint can now work on vertex level as well. Currently vertex paint and displace are supported. * Integrated vertex level painting with Point Cache. * Added viewport preview for Point Cache surfaces. Due to massive amount of changes, old Dynamic Paint saves are no longer supported. Also some features are temporarily missing or may not work properly.
2011-06-16 10:41:00 +00:00
case PTCACHE_TYPE_DYNAMICPAINT:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (!(stime->cache_display & TIME_CACHE_DYNAMICPAINT)) continue;
Dynamic Paint: Committed changes from previous weeks, biggest changes are: * Canvas can now have multiple "surfaces" that each can have specific format, type and settings. * Renewed UI to support this new system. * Aside from old "image sequence" output format, Dynamic Paint can now work on vertex level as well. Currently vertex paint and displace are supported. * Integrated vertex level painting with Point Cache. * Added viewport preview for Point Cache surfaces. Due to massive amount of changes, old Dynamic Paint saves are no longer supported. Also some features are temporarily missing or may not work properly.
2011-06-16 10:41:00 +00:00
break;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
}
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (pid->cache->cached_frames == NULL)
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
continue;
/* make sure we have stc with correct array length */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (stc == NULL || MEM_allocN_len(stc->array) != len * 2 * sizeof(float)) {
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (stc) {
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
MEM_freeN(stc->array);
}
else {
stc = MEM_callocN(sizeof(SpaceTimeCache), "spacetimecache");
BLI_addtail(&stime->caches, stc);
}
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
stc->array = MEM_callocN(len * 2 * sizeof(float), "SpaceTimeCache array");
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
}
/* fill the vertex array with a quad for each cached frame */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
for (i = sta, fp = stc->array; i <= end; i++) {
if (pid->cache->cached_frames[i - sta]) {
fp[0] = (float)i - 0.5f;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
fp[1] = 0.0;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp += 2;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp[0] = (float)i - 0.5f;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
fp[1] = 1.0;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp += 2;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp[0] = (float)i + 0.5f;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
fp[1] = 1.0;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp += 2;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp[0] = (float)i + 0.5f;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
fp[1] = 0.0;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
fp += 2;
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
}
}
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
glPushMatrix();
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
glTranslatef(0.0, (float)V2D_SCROLL_HEIGHT + yoffs, 0.0);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
glScalef(1.0, CACHE_DRAW_HEIGHT, 0.0);
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (pid->type) {
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
case PTCACHE_TYPE_SOFTBODY:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 1.0; col[1] = 0.4; col[2] = 0.02;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
col[3] = 0.1;
break;
case PTCACHE_TYPE_PARTICLES:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 1.0; col[1] = 0.1; col[2] = 0.02;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
col[3] = 0.1;
break;
case PTCACHE_TYPE_CLOTH:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 0.1; col[1] = 0.1; col[2] = 0.75;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
col[3] = 0.1;
break;
case PTCACHE_TYPE_SMOKE_DOMAIN:
case PTCACHE_TYPE_SMOKE_HIGHRES:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 0.2; col[1] = 0.2; col[2] = 0.2;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
col[3] = 0.1;
break;
Dynamic Paint: Committed changes from previous weeks, biggest changes are: * Canvas can now have multiple "surfaces" that each can have specific format, type and settings. * Renewed UI to support this new system. * Aside from old "image sequence" output format, Dynamic Paint can now work on vertex level as well. Currently vertex paint and displace are supported. * Integrated vertex level painting with Point Cache. * Added viewport preview for Point Cache surfaces. Due to massive amount of changes, old Dynamic Paint saves are no longer supported. Also some features are temporarily missing or may not work properly.
2011-06-16 10:41:00 +00:00
case PTCACHE_TYPE_DYNAMICPAINT:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 1.0; col[1] = 0.1; col[2] = 0.75;
Dynamic Paint: Committed changes from previous weeks, biggest changes are: * Canvas can now have multiple "surfaces" that each can have specific format, type and settings. * Renewed UI to support this new system. * Aside from old "image sequence" output format, Dynamic Paint can now work on vertex level as well. Currently vertex paint and displace are supported. * Integrated vertex level painting with Point Cache. * Added viewport preview for Point Cache surfaces. Due to massive amount of changes, old Dynamic Paint saves are no longer supported. Also some features are temporarily missing or may not work properly.
2011-06-16 10:41:00 +00:00
col[3] = 0.1;
break;
quiet some warnings & (possible/unlikely error)
2012-01-24 15:37:50 +00:00
default:
BLI_assert(0);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] = 1.0; col[1] = 0.0; col[2] = 1.0;
quiet some warnings & (possible/unlikely error)
2012-01-24 15:37:50 +00:00
col[3] = 0.1;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
glColor4fv(col);
glEnable(GL_BLEND);
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
glRectf((float)sta, 0.0, (float)end, 1.0);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
object/paint/misc-files: floats were being implicitly promoted to doubles, adjust to use floats. - also UV angle stretching was using radians->deg which wasn't needed.
2011-03-27 14:59:55 +00:00
col[3] = 0.4f;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
if (pid->cache->flag & PTCACHE_BAKED) {
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
col[0] -= 0.4f; col[1] -= 0.4f; col[2] -= 0.4f;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
glColor4fv(col);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, stc->array);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
glDrawArrays(GL_QUADS, 0, (fp - stc->array) / 2);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_BLEND);
glPopMatrix();
yoffs += CACHE_DRAW_HEIGHT;
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
stc = stc->next;
}
BLI_freelistN(&pidlist);
/* free excessive caches */
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
while (stc) {
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
SpaceTimeCache *tmp = stc->next;
BLI_remlink(&stime->caches, stc);
MEM_freeN(stc->array);
MEM_freeN(stc);
stc = tmp;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
}
static void time_cache_free(SpaceTime *stime)
{
SpaceTimeCache *stc;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
for (stc = stime->caches.first; stc; stc = stc->next) {
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
if (stc->array) {
MEM_freeN(stc->array);
stc->array = NULL;
}
}
BLI_freelistN(&stime->caches);
}
Quiet warnings from last commit. Janne: could you check if ptcache_file_pointers_seek() & ptcache_read_init() can be removed?
2011-01-02 10:13:17 +00:00
static void time_cache_refresh(SpaceTime *stime)
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
{
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
/* Free previous caches to indicate full refresh */
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
time_cache_free(stime);
}
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* helper function - find actkeycolumn that occurs on cframe, or the nearest one if not found */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
static ActKeyColumn *time_cfra_find_ak(ActKeyColumn *ak, float cframe)
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ActKeyColumn *akn = NULL;
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* sanity checks */
if (ak == NULL)
return NULL;
/* check if this is a match, or whether it is in some subtree */
if (cframe < ak->cfra)
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
akn = time_cfra_find_ak(ak->left, cframe);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
else if (cframe > ak->cfra)
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
akn = time_cfra_find_ak(ak->right, cframe);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* if no match found (or found match), just use the current one */
if (akn == NULL)
return ak;
else
return akn;
}
/* helper for time_draw_keyframes() */
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
static void time_draw_idblock_keyframes(View2D *v2d, ID *id, short onlysel)
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
bDopeSheet ads = {NULL};
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
DLRBT_Tree keys;
ActKeyColumn *ak;
/* init binarytree-list for getting keyframes */
BLI_dlrbTree_init(&keys);
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
/* init dopesheet settings */
if (onlysel)
ads.filterflag |= ADS_FILTER_ONLYSEL;
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* populate tree with keyframe nodes */
switch (GS(id->name)) {
case ID_SCE:
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
scene_to_keylist(&ads, (Scene *)id, &keys, NULL);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
break;
case ID_OB:
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
ob_to_keylist(&ads, (Object *)id, &keys, NULL);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
break;
}
/* build linked-list for searching */
BLI_dlrbTree_linkedlist_sync(&keys);
/* start drawing keyframes
* - we use the binary-search capabilities of the tree to only start from
* the first visible keyframe (last one can then be easily checked)
* - draw within a single GL block to be faster
*/
glBegin(GL_LINES);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
for (ak = time_cfra_find_ak(keys.root, v2d->cur.xmin);
(ak) && (ak->cfra <= v2d->cur.xmax);
ak = ak->next)
{
glVertex2f(ak->cfra, v2d->tot.ymin);
glVertex2f(ak->cfra, v2d->tot.ymax);
}
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
glEnd(); // GL_LINES
/* free temp stuff */
BLI_dlrbTree_free(&keys);
}
/* draw keyframe lines for timeline */
static void time_draw_keyframes(const bContext *C, SpaceTime *stime, ARegion *ar)
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
Scene *scene = CTX_data_scene(C);
Object *ob = CTX_data_active_object(C);
View2D *v2d = &ar->v2d;
short onlysel = (stime->flag & TIME_ONLYACTSEL);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* draw scene keyframes first
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
* - don't try to do this when only drawing active/selected data keyframes,
* since this can become quite slow
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
*/
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (scene && onlysel == 0) {
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
/* set draw color */
glColor3ub(0xDD, 0xA7, 0x00);
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
time_draw_idblock_keyframes(v2d, (ID *)scene, onlysel);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
}
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
/* draw keyframes from selected objects
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
* - only do the active object if in posemode (i.e. showing only keyframes for the bones)
* OR the onlysel flag was set, which means that only active object's keyframes should
* be considered
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
*/
glColor3ub(0xDD, 0xD7, 0x00);
if (ob && ((ob->mode == OB_MODE_POSE) || onlysel)) {
/* draw keyframes for active object only */
time_draw_idblock_keyframes(v2d, (ID *)ob, onlysel);
}
else {
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
short active_done = FALSE;
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
/* draw keyframes from all selected objects */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
CTX_DATA_BEGIN (C, Object *, obsel, selected_objects)
style cleanup: re - http://wiki.blender.org/index.php/Dev:Doc/CodeStyle#Braces_with_Macros
2012-04-30 16:22:40 +00:00
{
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
/* last arg is 0, since onlysel doesn't apply here... */
time_draw_idblock_keyframes(v2d, (ID *)obsel, 0);
/* if this object is the active one, set flag so that we don't draw again */
if (obsel == ob)
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
active_done = TRUE;
Timeline: Keyframe Drawing for All Selected Objects When 'Only Selected' is ON, or the Active Object is in PoseMode, only the keyframes for the active Object are drawn (*). Otherwise, the keyframes for the scene (sequence+nodes+world), and the selected Objects (including the Active Object) are drawn. (*) I've also made some changes here to try and get only the selected bones showing here, but some further changes are still needed for that to be able to work. --- Also, fixed bug in makesrna caused by missing newlines for error prints. This resulted in all error-output from makesrna appearing on a single line.
2010-01-18 23:31:46 +00:00
}
CTX_DATA_END;
/* if active object hasn't been done yet, draw it... */
if (ob && (active_done == 0))
time_draw_idblock_keyframes(v2d, (ID *)ob, 0);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
}
}
/* ---------------- */
Quiet warnings from last commit. Janne: could you check if ptcache_file_pointers_seek() & ptcache_read_init() can be removed?
2011-01-02 10:13:17 +00:00
static void time_refresh(const bContext *UNUSED(C), ScrArea *sa)
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
{
/* find the main timeline region and refresh cache display*/
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ARegion *ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (ar) {
use BKE_area_find_region_type in place of inline loops (no functional changes).
2011-05-20 05:27:31 +00:00
SpaceTime *stime = (SpaceTime *)sa->spacedata.first;
time_cache_refresh(stime);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
}
/* editor level listener */
static void time_listener(ScrArea *sa, wmNotifier *wmn)
{
/* mainly for updating cache display */
switch (wmn->category) {
case NC_OBJECT:
switch (wmn->data) {
Bugfix: Timeline did not refresh when changing selecting a bone This happened/was most noticeable when clicking on a bone of an armature in posemode but not active (i.e. some object other than the armature is active when trying to select the bone).
2010-09-13 00:47:12 +00:00
case ND_BONE_ACTIVE:
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
case ND_POINTCACHE:
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
case ND_MODIFIER:
case ND_PARTICLE:
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
ED_area_tag_refresh(sa);
ED_area_tag_redraw(sa);
break;
}
break;
case NC_SCENE:
Fix [#24046] Keyframe display in Timeline isn't updated Reported by Alex Glawion Add necessary object selecction notifier handling to redraw timeline properly.
2010-09-29 12:34:32 +00:00
switch (wmn->data) {
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
case ND_OB_ACTIVE:
case ND_FRAME:
ED_area_tag_refresh(sa);
break;
new notifier for FRAME_RANGE, use to recalculate the timeline scrollbar range.
2010-06-26 19:17:48 +00:00
case ND_FRAME_RANGE:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
{
ARegion *ar;
Scene *scene = wmn->reference;
for (ar = sa->regionbase.first; ar; ar = ar->next) {
if (ar->regiontype == RGN_TYPE_WINDOW) {
ar->v2d.tot.xmin = (float)(SFRA - 4);
ar->v2d.tot.xmax = (float)(EFRA + 4);
break;
new notifier for FRAME_RANGE, use to recalculate the timeline scrollbar range.
2010-06-26 19:17:48 +00:00
}
}
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
}
break;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
case NC_SPACE:
Fix [#24046] Keyframe display in Timeline isn't updated Reported by Alex Glawion Add necessary object selecction notifier handling to redraw timeline properly.
2010-09-29 12:34:32 +00:00
switch (wmn->data) {
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
case ND_SPACE_CHANGED:
ED_area_tag_refresh(sa);
break;
}
Fix for [#25325] Timeline doesn't show status of baked psys until frame is advanced * Timeline didn't listen to file read notifier, so the pointcache frames indicator didn't get updated. * Also added listens to particle & modifier (cloth, sb & smoke) notifiers as changes that cleared a pointcache weren't shown directly in the timeline either. * The timeline display was also always one frame behind the actual state, since the notifiers are handled before the actual dynamics are calculated. ** This is now fixed too, by creating the actual drawn data always at drawtime.
2010-12-21 20:18:43 +00:00
case NC_WM:
switch (wmn->data) {
case ND_FILEREAD:
ED_area_tag_refresh(sa);
break;
}
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
}
}
/* ---------------- */
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
/* add handlers, stuff you only do once or on area/region changes */
static void time_main_area_init(wmWindowManager *wm, ARegion *ar)
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
{
Keymaps now have a poll() function, rather than adding/removing their handlers based on notifiers, which is simpler and more reliable. This fixes for example editmode or uv edit keymaps not working when creating a new 3dview or image space.
2009-09-17 21:36:02 +00:00
wmKeyMap *keymap;
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_CUSTOM, ar->winx, ar->winy);
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
/* own keymap */
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
keymap = WM_keymap_find(wm->defaultconf, "Timeline", SPACE_TIME, 0);
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
static void time_main_area_draw(const bContext *C, ARegion *ar)
{
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
/* draw entirely, view changes should be handled here */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
Scene *scene = CTX_data_scene(C);
SpaceTime *stime = CTX_wm_space_time(C);
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
Object *obact = CTX_data_active_object(C);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
View2D *v2d = &ar->v2d;
2.5 Branch: use themes for drawing the time space, and make view2d grid code a bit nicer.
2008-10-08 18:07:56 +00:00
View2DGrid *grid;
View2D - Zoom + More Scrollbar work * Added basic (non-modal) zoom operators that use a uniform scale factor, with zoom centered using the view center as scaling point. Use Scrollwheel up/down and Pad +/- to use this. * Added back the 'button'/bubble for the scrollbars. I've added dark lines on either end of it for some later work on zooming widgets. This is not the final form they'll take. I still need to decide how to handle those scrollbars which act as grid-markers too (showing timescale, etc.), before trying to integrate that with some fancy scrollbar drawing (rounded, etc.) Assorted changes: * Moved vertical scrollbar for Outliner to right hand side * Made Timeline use standard scrollbars, and turned on various clamping options * Fixed ortho-matrix corrections for scrollbars, and added pixel offsets * Made Timeline markers sit more snugly on the scrollbar. They were a bit far out... * Fixed memory leak with view2d keymaps not being freed when Blender exited
2008-12-01 11:37:05 +00:00
View2DScrollers *scrollers;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
int unit, flag = 0;
View2D - Another WIP commit * Start of basic scrollbar drawing. This will be improved. Only Outliner shows these for now, as although the Timeline should show them, the old files didn't have them turned on. * Tidied up the view-panning operator - Fixed naming convention - Added user-adjustable properties (deltax, deltay in screenspace) * Added ctrl-scrollwheel (horizontal) and shift-scrollwheel (vertical) scroll operators. These use the view-panning code too. Unfortunately, I haven't been able to figure out why the WHEELMOUSEDOWN events don't seem to be triggering the operators!
2008-12-01 00:20:19 +00:00
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
/* clear and setup matrix */
Fix [#21516] UI artifacts in array modifier Modify the glClearColor used to draw disabled buttons, when creating a ROUNDBOX ui element. Made a convenience function and rippled it though, too.
2010-04-06 07:02:16 +00:00
UI_ThemeClearColor(TH_BACK);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
glClear(GL_COLOR_BUFFER_BIT);
View2D - Another WIP commit * Start of basic scrollbar drawing. This will be improved. Only Outliner shows these for now, as although the Timeline should show them, the old files didn't have them turned on. * Tidied up the view-panning operator - Fixed naming convention - Added user-adjustable properties (deltax, deltay in screenspace) * Added ctrl-scrollwheel (horizontal) and shift-scrollwheel (vertical) scroll operators. These use the view-panning code too. Unfortunately, I haven't been able to figure out why the WHEELMOUSEDOWN events don't seem to be triggering the operators!
2008-12-01 00:20:19 +00:00
remove unused args in draw*.c and some in view*.c, tag some as UNUSED().
2010-10-14 01:22:14 +00:00
UI_view2d_view_ortho(v2d);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
/* grid */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
unit = (stime->flag & TIME_DRAWFRAMES) ? V2D_UNIT_FRAMES : V2D_UNIT_SECONDS;
grid = UI_view2d_grid_calc(scene, v2d, unit, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY, ar->winx, ar->winy);
UI_view2d_grid_draw(v2d, grid, (V2D_VERTICAL_LINES | V2D_VERTICAL_AXIS));
View2D: Renamed a few API methods to follow standard naming conventions, and added define to use when an argument to these methods is irrelevant.
2008-12-07 06:21:06 +00:00
UI_view2d_grid_free(grid);
2.5 - Timeline window now displays keyframe lines again * Keyframes for scene-linked animdata is drawn first (if 'Only Selected Data Keys' is off) * Keyframes are also drawn for the active object
2009-07-24 08:05:56 +00:00
Bugfix [#27548] Timeline view - 2D drawing issues * Keyframe lines were being drawn too short when frame number box was enabled. The code for drawing this was modifying the View2D view-space to get it's stuff in the right place, but the timeline code was not accounting for this. * In order to make the time ticks more visible outside the frame range, I've moved the start/end frame drawing stuff in timeline to occur after the grid drawing, and to draw semi-transparent, just like the preview range curtains in the other animation editors
2011-07-12 12:04:27 +00:00
/* start and end frame */
time_draw_sfra_efra(scene, v2d);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
/* current frame */
Timeline Drawing - Time cursor draws extra wide in timeline so that keyframe lines are wrapped up nicely by it Ideally it could be made so that it only became wide when it is on a frame with a keyframe, though that could end up causing performance problems, so this will have to do (if a bit "chunky" looking at times).
2011-07-12 12:13:23 +00:00
flag = DRAWCFRA_WIDE; /* this is only really needed on frames where there's a keyframe, but this will do... */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if ((stime->flag & TIME_DRAWFRAMES) == 0) flag |= DRAWCFRA_UNIT_SECONDS;
if (stime->flag & TIME_CFRA_NUM) flag |= DRAWCFRA_SHOW_NUMBOX;
Timeline Drawing Tweaks: * Made the TimeLine current frame indicator get drawn using the standard frame-indicator code. Also, it is now possible to show the frame indicator box beside the line as in the other animation editors, although this is disabled in the timeline due to the closeness of the frame number field. * Removed some old (unnecessary) code -> "Continue Physics" option in TimeLine, which is now obsolete with the current physics options. Feel free to restore if this is not the case. -> Already commented out hacks to create "speed ipo" for curves. There are easy alternatives that are better integrated. -> Unused init/exit callbacks for scrubbing time, since those were only used to set an obsolete flag for timeline drawing that is now used for the indicator. * Switched long-keyframe optimisation code to use constants instead of some magic numbers + fancy trickery...
2009-12-11 11:18:55 +00:00
ANIM_draw_cfra(C, v2d, flag);
More testing with new system: - Added markers (partially) back, ed_markers.c (temporary in spacetime, where to put general stuff like this?), and added ED_markers.h for api. - Mkey in timewindow shows marker (no icon, doesnt work yet). (Adding operators gets easy :) - Noted some conflict for operator storage... with markers being used all over, added it to the screen level. - More todos: view2d is stored in space, for time, etc. With regions we could move this over, but better todo as post 2.5 project. Multiple 2d views in area would be cool though.
2008-11-24 18:59:59 +00:00
Bugfix [#27548] Timeline view - 2D drawing issues * Keyframe lines were being drawn too short when frame number box was enabled. The code for drawing this was modifying the View2D view-space to get it's stuff in the right place, but the timeline code was not accounting for this. * In order to make the time ticks more visible outside the frame range, I've moved the start/end frame drawing stuff in timeline to occur after the grid drawing, and to draw semi-transparent, just like the preview range curtains in the other animation editors
2011-07-12 12:04:27 +00:00
UI_view2d_view_ortho(v2d);
In the Timeline, keyframe lines are now drawn in front of the frame indicator. This is so that it will be possible to see if there is a keyframe on the current frame by just looking in the timeline.
2011-01-28 00:52:31 +00:00
/* keyframes */
Attempted bugfix: don't perform any keyframe remapping stuff if rendering, to prevent any race condition problems I've noticed some weird and random crashes recently while rendering, which I suspect have been arising from having an Action Editor open while rendering. Previously only the timeline was patched against these problems, though the issues may be more widespread. Hence, solving this problem at the root cause instead.
2011-07-21 00:07:07 +00:00
time_draw_keyframes(C, stime, ar);
In the Timeline, keyframe lines are now drawn in front of the frame indicator. This is so that it will be possible to see if there is a keyframe on the current frame by just looking in the timeline.
2011-01-28 00:52:31 +00:00
More testing with new system: - Added markers (partially) back, ed_markers.c (temporary in spacetime, where to put general stuff like this?), and added ED_markers.h for api. - Mkey in timewindow shows marker (no icon, doesnt work yet). (Adding operators gets easy :) - Noted some conflict for operator storage... with markers being used all over, added it to the screen level. - More todos: view2d is stored in space, for time, etc. With regions we could move this over, but better todo as post 2.5 project. Multiple 2d views in area would be cool though.
2008-11-24 18:59:59 +00:00
/* markers */
remove unused args in draw*.c and some in view*.c, tag some as UNUSED().
2010-10-14 01:22:14 +00:00
UI_view2d_view_orthoSpecial(ar, v2d, 1);
More testing with new system: - Added markers (partially) back, ed_markers.c (temporary in spacetime, where to put general stuff like this?), and added ED_markers.h for api. - Mkey in timewindow shows marker (no icon, doesnt work yet). (Adding operators gets easy :) - Noted some conflict for operator storage... with markers being used all over, added it to the screen level. - More todos: view2d is stored in space, for time, etc. With regions we could move this over, but better todo as post 2.5 project. Multiple 2d views in area would be cool though.
2008-11-24 18:59:59 +00:00
draw_markers_time(C, 0);
View2D - Another WIP commit * Start of basic scrollbar drawing. This will be improved. Only Outliner shows these for now, as although the Timeline should show them, the old files didn't have them turned on. * Tidied up the view-panning operator - Fixed naming convention - Added user-adjustable properties (deltax, deltay in screenspace) * Added ctrl-scrollwheel (horizontal) and shift-scrollwheel (vertical) scroll operators. These use the view-panning code too. Unfortunately, I haven't been able to figure out why the WHEELMOUSEDOWN events don't seem to be triggering the operators!
2008-12-01 00:20:19 +00:00
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
/* caches */
Fix for [#25427] cloth or soft body crash un Undo * Argh my bad, sorry about this! * Now only the actual data array is saved to avoid constant re-allocations, but no relations to active data are kept. * Also reverted Ton's quick fix for the crash as it's not needed anymore.
2011-01-02 03:55:26 +00:00
time_draw_cache(stime, obact);
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
View2D - Another WIP commit * Start of basic scrollbar drawing. This will be improved. Only Outliner shows these for now, as although the Timeline should show them, the old files didn't have them turned on. * Tidied up the view-panning operator - Fixed naming convention - Added user-adjustable properties (deltax, deltay in screenspace) * Added ctrl-scrollwheel (horizontal) and shift-scrollwheel (vertical) scroll operators. These use the view-panning code too. Unfortunately, I haven't been able to figure out why the WHEELMOUSEDOWN events don't seem to be triggering the operators!
2008-12-01 00:20:19 +00:00
/* reset view matrix */
UI_view2d_view_restore(C);
/* scrollers */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
scrollers = UI_view2d_scrollers_calc(C, v2d, unit, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
View2D: Renamed a few API methods to follow standard naming conventions, and added define to use when an argument to these methods is irrelevant.
2008-12-07 06:21:06 +00:00
UI_view2d_scrollers_draw(C, v2d, scrollers);
UI_view2d_scrollers_free(scrollers);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
static void time_main_area_listener(ARegion *ar, wmNotifier *wmn)
{
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
/* context changes */
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (wmn->category) {
2.5 Notifiers --------- Various fixes for wrong use of notifiers, and some new notifiers to make things a bit more clear and consistent, with two notable changes: * Geometry changes are now done with NC_GEOM, rather than NC_OBJECT|ND_GEOM_, so an object does need to be available. * Space data now use NC_SPACE|ND_SPACE_*, instead of data notifiers or even NC_WINDOW in some cases. Note that NC_SPACE should only be used for notifying about changes in space data, we don't want to go back to allqueue(REDRAW..). Depsgraph --------- The dependency graph now has a different flush call: DAG_object_flush_update(scene, ob, flag) is replaced by: DAG_id_flush_update(id, flag) It still works basically the same, one difference is that it now also accepts object data (e.g. Mesh), again to avoid requiring an Object to be available. Other ID types will simply do nothing at the moment. Docs ---- I made some guidelines for how/when to do which kinds of updates and notifiers. I can't specify totally exact how to make these decisions, but these are basically the guidelines I use. So, new and updated docs are here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/NotifiersUpdates http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers
2009-09-04 20:51:09 +00:00
case NC_SPACE:
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (wmn->data == ND_SPACE_TIME)
2.5 Notifiers --------- Various fixes for wrong use of notifiers, and some new notifiers to make things a bit more clear and consistent, with two notable changes: * Geometry changes are now done with NC_GEOM, rather than NC_OBJECT|ND_GEOM_, so an object does need to be available. * Space data now use NC_SPACE|ND_SPACE_*, instead of data notifiers or even NC_WINDOW in some cases. Note that NC_SPACE should only be used for notifying about changes in space data, we don't want to go back to allqueue(REDRAW..). Depsgraph --------- The dependency graph now has a different flush call: DAG_object_flush_update(scene, ob, flag) is replaced by: DAG_id_flush_update(id, flag) It still works basically the same, one difference is that it now also accepts object data (e.g. Mesh), again to avoid requiring an Object to be available. Other ID types will simply do nothing at the moment. Docs ---- I made some guidelines for how/when to do which kinds of updates and notifiers. I can't specify totally exact how to make these decisions, but these are basically the guidelines I use. So, new and updated docs are here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/NotifiersUpdates http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers
2009-09-04 20:51:09 +00:00
ED_region_tag_redraw(ar);
break;
2.5 - Timeline now updates correctly after keyframes have been edited
2009-08-22 03:10:52 +00:00
case NC_ANIMATION:
ED_region_tag_redraw(ar);
break;
2.5 More notifier and redraw cleanup - notifiers are not filtered anymore, apart from window/screen notifiers, they get to all regions. - fixed drawing of 'action zones' in areas. - added support for basic multilayer draw, like for action zones now, and future other area decorations (tabs, region handlers) check: ED_area_overdraw_flush() ED_area_overdraw() - bugfix in UI redraw tags, it was calling region pointer in free'd data - added notifier for marker-changed - added keymap for markers to ipo window
2008-12-16 18:42:12 +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
case NC_SCENE:
Timeline Notifier Listener: * Added ND_FRAME_RANGE to the header listener, changing frame range in Properties Window didn't update it in the timeline, reported by Hardworker in IRC. Thanks! * Main Area Listener doesn't listen to all NC_SCENE Notifiers now, only selected ND Notifiers, like the header does. This is more efficient. If there is a reason to let it listen to all NC_SCENE notifiers, please tell me. :)
2010-08-28 15:04:42 +00:00
switch (wmn->data) {
Fix [#24046] Keyframe display in Timeline isn't updated Reported by Alex Glawion Add necessary object selecction notifier handling to redraw timeline properly.
2010-09-29 12:34:32 +00:00
case ND_OB_SELECT:
Fix #24167: Timeline keyframes don't update when selecting objects from outliner Based on patch from Alexander Kuznetsov. Own changes: - Keyframes in timelime depends on active object, so timelime better be listeing to ND_OB_ACTIVE notifier rather than ND_OB_SELECT - When scene is changing in this operator NC_WINDOW notifier would be send and the whole interface would be redrawed, so no need in ND_OB_ACTIVE in this case
2010-10-07 16:41:42 +00:00
case ND_OB_ACTIVE:
Timeline Notifier Listener: * Added ND_FRAME_RANGE to the header listener, changing frame range in Properties Window didn't update it in the timeline, reported by Hardworker in IRC. Thanks! * Main Area Listener doesn't listen to all NC_SCENE Notifiers now, only selected ND Notifiers, like the header does. This is more efficient. If there is a reason to let it listen to all NC_SCENE notifiers, please tell me. :)
2010-08-28 15:04:42 +00:00
case ND_FRAME:
case ND_FRAME_RANGE:
case ND_KEYINGSET:
case ND_RENDER_OPTIONS:
ED_region_tag_redraw(ar);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
break;
Timeline Notifier Listener: * Added ND_FRAME_RANGE to the header listener, changing frame range in Properties Window didn't update it in the timeline, reported by Hardworker in IRC. Thanks! * Main Area Listener doesn't listen to all NC_SCENE Notifiers now, only selected ND Notifiers, like the header does. This is more efficient. If there is a reason to let it listen to all NC_SCENE notifiers, please tell me. :)
2010-08-28 15:04:42 +00:00
}
2.5 Added notifiers for timeline syncing. Works for Timeline window only now. Note that I've removed the malloc-free in a Notifier... notifier system is still under probabtion :)
2008-12-15 18:09:55 +00:00
}
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
/* ************************ header time area region *********************** */
View2D: Various Fixes + Header Support Added support for panning headers using View2D of the header regions (only done for TimeLine, as only that one has buttons on it). Currently, this uses some do_versions magic to initialise the View2D rects required, however, I'm not sure if all the information was safely ported over yet (notably height and position of rects due to alignment issues). In the process, I noticed a few bugs with the current View2D code: * UI_view2d_curRect_validate() is now called after UI_view2d_size_update(), as the size of the 'mask' rect is closely related to the size of the 'cur' rect (especially when zooming is locked). * Fixed a bug in UI_view2d_curRect_validate() which meant that if the 'cur' rect was slightly larger than the 'tot' rect, and keeptot was set, the view would flicker between the two closely related positions.
2008-12-11 03:50:50 +00:00
/* add handlers, stuff you only do once or on area/region changes */
editors/space_* build without unused args warnings
2010-10-16 08:03:28 +00:00
static void time_header_area_init(wmWindowManager *UNUSED(wm), ARegion *ar)
View2D: Various Fixes + Header Support Added support for panning headers using View2D of the header regions (only done for TimeLine, as only that one has buttons on it). Currently, this uses some do_versions magic to initialise the View2D rects required, however, I'm not sure if all the information was safely ported over yet (notably height and position of rects due to alignment issues). In the process, I noticed a few bugs with the current View2D code: * UI_view2d_curRect_validate() is now called after UI_view2d_size_update(), as the size of the 'mask' rect is closely related to the size of the 'cur' rect (especially when zooming is locked). * Fixed a bug in UI_view2d_curRect_validate() which meant that if the 'cur' rect was slightly larger than the 'tot' rect, and keeptot was set, the view would flicker between the two closely related positions.
2008-12-11 03:50:50 +00:00
{
2.5 Timeline: WIP Commit, still uncommented. * Adeed some RNA properties for Playback. * Start of Python File.
2009-08-13 16:59:52 +00:00
ED_region_header_init(ar);
View2D: Various Fixes + Header Support Added support for panning headers using View2D of the header regions (only done for TimeLine, as only that one has buttons on it). Currently, this uses some do_versions magic to initialise the View2D rects required, however, I'm not sure if all the information was safely ported over yet (notably height and position of rects due to alignment issues). In the process, I noticed a few bugs with the current View2D code: * UI_view2d_curRect_validate() is now called after UI_view2d_size_update(), as the size of the 'mask' rect is closely related to the size of the 'cur' rect (especially when zooming is locked). * Fixed a bug in UI_view2d_curRect_validate() which meant that if the 'cur' rect was slightly larger than the 'tot' rect, and keeptot was set, the view would flicker between the two closely related positions.
2008-12-11 03:50:50 +00:00
}
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
static void time_header_area_draw(const bContext *C, ARegion *ar)
{
2.5 Timeline: WIP Commit, still uncommented. * Adeed some RNA properties for Playback. * Start of Python File.
2009-08-13 16:59:52 +00:00
ED_region_header(C, ar);
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
}
2.5 Anim playback part 1 (needs more test, will do after commit) - added the update_for_new_frame() back - proper evaluation of time change notifier in WM level - fixed redraw flushes for menus while animation plays.
2008-12-27 17:43:05 +00:00
static void time_header_area_listener(ARegion *ar, wmNotifier *wmn)
{
/* context changes */
style cleanup: changes to brace placement / newlines - for/while/if/switch
2012-04-28 06:31:57 +00:00
switch (wmn->category) {
2.5 Animation playback back in control. And non-blocking still! - Play follows the "Playback" options in TimeLine menu. Only the region 'windows' are drawn, not headers, toolbars, channel views, etc. The option "Buttons Window" also redraws property regions. - The Timeline header always redraws, this to denote at least progressing frame numbers - For now: if you choose to play 3D views, it also redraws the TimeLine. Seems to be good convention, but probably better to add menu option for it? - Fun test: while playback, change Playback options, works OK! - New: top header button shows animation play status, and allows to stop playback - New: Animation stop/start operator. Assigned to ALT+A. It has no options yet; just plays active region + all 3D windows now. Options will follow, based on reviews. Also ESC won't work for now, just press ALT+A again.
2009-05-21 13:33:04 +00:00
case NC_SCREEN:
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
if (wmn->data == ND_ANIMPLAY)
2.5 Animation playback back in control. And non-blocking still! - Play follows the "Playback" options in TimeLine menu. Only the region 'windows' are drawn, not headers, toolbars, channel views, etc. The option "Buttons Window" also redraws property regions. - The Timeline header always redraws, this to denote at least progressing frame numbers - For now: if you choose to play 3D views, it also redraws the TimeLine. Seems to be good convention, but probably better to add menu option for it? - Fun test: while playback, change Playback options, works OK! - New: top header button shows animation play status, and allows to stop playback - New: Animation stop/start operator. Assigned to ALT+A. It has no options yet; just plays active region + all 3D windows now. Options will follow, based on reviews. Also ESC won't work for now, just press ALT+A again.
2009-05-21 13:33:04 +00:00
ED_region_tag_redraw(ar);
break;
2.5 Notifiers --------- Various fixes for wrong use of notifiers, and some new notifiers to make things a bit more clear and consistent, with two notable changes: * Geometry changes are now done with NC_GEOM, rather than NC_OBJECT|ND_GEOM_, so an object does need to be available. * Space data now use NC_SPACE|ND_SPACE_*, instead of data notifiers or even NC_WINDOW in some cases. Note that NC_SPACE should only be used for notifying about changes in space data, we don't want to go back to allqueue(REDRAW..). Depsgraph --------- The dependency graph now has a different flush call: DAG_object_flush_update(scene, ob, flag) is replaced by: DAG_id_flush_update(id, flag) It still works basically the same, one difference is that it now also accepts object data (e.g. Mesh), again to avoid requiring an Object to be available. Other ID types will simply do nothing at the moment. Docs ---- I made some guidelines for how/when to do which kinds of updates and notifiers. I can't specify totally exact how to make these decisions, but these are basically the guidelines I use. So, new and updated docs are here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/NotifiersUpdates http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers
2009-09-04 20:51:09 +00:00
2.5 Anim playback part 1 (needs more test, will do after commit) - added the update_for_new_frame() back - proper evaluation of time change notifier in WM level - fixed redraw flushes for menus while animation plays.
2008-12-27 17:43:05 +00:00
case NC_SCENE:
KeyingSets: More work on preparing the UI KeyingSets can now be added/removed. Next up, the code for the operators to add items to Keying Sets.
2009-02-12 01:11:29 +00:00
switch (wmn->data) {
Fix [#24046] Keyframe display in Timeline isn't updated Reported by Alex Glawion Add necessary object selecction notifier handling to redraw timeline properly.
2010-09-29 12:34:32 +00:00
case ND_OB_SELECT:
KeyingSets: More work on preparing the UI KeyingSets can now be added/removed. Next up, the code for the operators to add items to Keying Sets.
2009-02-12 01:11:29 +00:00
case ND_FRAME:
Timeline Notifier Listener: * Added ND_FRAME_RANGE to the header listener, changing frame range in Properties Window didn't update it in the timeline, reported by Hardworker in IRC. Thanks! * Main Area Listener doesn't listen to all NC_SCENE Notifiers now, only selected ND Notifiers, like the header does. This is more efficient. If there is a reason to let it listen to all NC_SCENE notifiers, please tell me. :)
2010-08-28 15:04:42 +00:00
case ND_FRAME_RANGE:
KeyingSets: More work on preparing the UI KeyingSets can now be added/removed. Next up, the code for the operators to add items to Keying Sets.
2009-02-12 01:11:29 +00:00
case ND_KEYINGSET:
Fix #21214 Changing frame range on render panel doesn't update on timeline... Was missing notifier Also made a description slightly more consistent
2010-02-21 20:27:13 +00:00
case ND_RENDER_OPTIONS:
KeyingSets: More work on preparing the UI KeyingSets can now be added/removed. Next up, the code for the operators to add items to Keying Sets.
2009-02-12 01:11:29 +00:00
ED_region_tag_redraw(ar);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
break;
KeyingSets: More work on preparing the UI KeyingSets can now be added/removed. Next up, the code for the operators to add items to Keying Sets.
2009-02-12 01:11:29 +00:00
}
2.5 Notifiers --------- Various fixes for wrong use of notifiers, and some new notifiers to make things a bit more clear and consistent, with two notable changes: * Geometry changes are now done with NC_GEOM, rather than NC_OBJECT|ND_GEOM_, so an object does need to be available. * Space data now use NC_SPACE|ND_SPACE_*, instead of data notifiers or even NC_WINDOW in some cases. Note that NC_SPACE should only be used for notifying about changes in space data, we don't want to go back to allqueue(REDRAW..). Depsgraph --------- The dependency graph now has a different flush call: DAG_object_flush_update(scene, ob, flag) is replaced by: DAG_id_flush_update(id, flag) It still works basically the same, one difference is that it now also accepts object data (e.g. Mesh), again to avoid requiring an Object to be available. Other ID types will simply do nothing at the moment. Docs ---- I made some guidelines for how/when to do which kinds of updates and notifiers. I can't specify totally exact how to make these decisions, but these are basically the guidelines I use. So, new and updated docs are here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/NotifiersUpdates http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers
2009-09-04 20:51:09 +00:00
case NC_SPACE:
style cleanup: follow style guide for formatting of if/for/while loops, and else if's
2012-03-24 06:38:07 +00:00
if (wmn->data == ND_SPACE_TIME)
2.5 Notifiers --------- Various fixes for wrong use of notifiers, and some new notifiers to make things a bit more clear and consistent, with two notable changes: * Geometry changes are now done with NC_GEOM, rather than NC_OBJECT|ND_GEOM_, so an object does need to be available. * Space data now use NC_SPACE|ND_SPACE_*, instead of data notifiers or even NC_WINDOW in some cases. Note that NC_SPACE should only be used for notifying about changes in space data, we don't want to go back to allqueue(REDRAW..). Depsgraph --------- The dependency graph now has a different flush call: DAG_object_flush_update(scene, ob, flag) is replaced by: DAG_id_flush_update(id, flag) It still works basically the same, one difference is that it now also accepts object data (e.g. Mesh), again to avoid requiring an Object to be available. Other ID types will simply do nothing at the moment. Docs ---- I made some guidelines for how/when to do which kinds of updates and notifiers. I can't specify totally exact how to make these decisions, but these are basically the guidelines I use. So, new and updated docs are here: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/NotifiersUpdates http://wiki.blender.org/index.php/BlenderDev/Blender2.5/DataNotifiers
2009-09-04 20:51:09 +00:00
ED_region_tag_redraw(ar);
break;
2.5 Anim playback part 1 (needs more test, will do after commit) - added the update_for_new_frame() back - proper evaluation of time change notifier in WM level - fixed redraw flushes for menus while animation plays.
2008-12-27 17:43:05 +00:00
}
}
Port of part of the Interface code to 2.50. This is based on the current trunk version, so these files should not need merges. There's two things (clipboard and intptr_t) that are missing in 2.50 and commented out with XXX 2.48, these can be enabled again once trunk is merged into this branch. Further this is not all interface code, there are many parts commented out: * interface.c: nearly all button types, missing: links, chartab, keyevent. * interface_draw.c: almost all code, with some small exceptions. * interface_ops.c: this replaces ui_do_but and uiDoBlocks with two operators, making it non-blocking. * interface_regions: this is a part of interface.c, split off, contains code to create regions for tooltips, menus, pupmenu (that one is crashing currently), color chooser, basically regions with buttons which is fairly independent of core interface code. * interface_panel.c and interface_icons.c: not ported over, so no panels and icons yet. Panels should probably become (free floating) regions? * text.c: (formerly language.c) for drawing text and translation. this works but is using bad globals still and could be cleaned up. Header Files: * ED_datafiles.h now has declarations for datatoc_ files, so those extern declarations can be #included instead of repeated. * The user interface code is in UI_interface.h and other UI_* files. Core: * The API for creating blocks, buttons, etc is nearly the same still. Blocks are now created per region instead of per area. * The code was made non-blocking, which means that any changes and redraws should be possible while editing a button. That means though that we need some sort of persistence even though the blender model is to recreate buttons for each redraw. So when a new block is created, some matching happens to find out which buttons correspond to buttons in the previously created block, and for activated buttons some data is then copied over to the new button. * Added UI_init/UI_init_userdef/UI_exit functions that should initialize code in this module, instead of multiple function calls in the windowmanager. * Removed most static/globals from interface.c. * Removed UIafterfunc_ I don't think it's needed anymore, and not sure how it would integrate here? * Currently only full window redraws are used, this should become per region and maybe per button later. Operators: * Events are currently handled through two operators: button activate and menu handle. Operators may not be the best way to implement this, since there are currently some issues with events being missed, but they can become a special handler type instead, this should not be a big change. * The button activate operator runs as long as a button is active, and will handle all interaction with that button until the button is not activated anymore. This means clicking, text editing, number dragging, opening menu blocks, etc. * Since this operator has to be non-blocking, the ui_do_but code needed to made non-blocking. That means variables that were previously on the stack, now need to be stored away in a struct such that they can be accessed again when the operator receives more events. * Additionally the place in the ui_do_but code indicated the state, now that needs to be set explicit in order to handle the right events in the right state. So an activated button can be in one of these states: init, highlight, wait_flash, wait_release, wait_key_event, num_editing, text_editing, text_selecting, block_open, exit. * For each button type an ui_apply_but_* function has also been separated out from ui_do_but. This makes it possible to continuously apply the button as text is being typed for example, and there is an option in the code to enable this. Since the code non-blocking and can deal with the button being deleted even, it should be safe to do this. * When editing text, dragging numbers, etc, the actual data (but->poin) is not being edited, since that would mean data is being edited without correct updates happening, while some other part of blender may be accessing that data in the meantime. So data values, strings, vectors are written to a temporary location and only flush in the apply function. Regions: * Menus, color chooser, tooltips etc all create screen level regions. Such menu blocks give a handle to the button that creates it, which will contain the results of the menu block once a MESSAGE event is received from that menu block. * For this type of menu block the coordinates used to be in window space. They are still created that way and ui_positionblock still works with window coordinates, but after that the block and buttons are brought back to region coordinates since these are now contained in a region. * The flush/overdraw frontbuffer drawing code was removed, the windowmanager should have enough information with these screen level regions to have full control over what gets drawn when and to then do correct compositing. Testing: * The header in the time space currently has some buttons to test the UI code.
2008-11-11 18:31:32 +00:00
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
/* ******************** default callbacks for time space ***************** */
2.5 Small area/space api fix: space->new() callbacks now require Context pointer. Too many cases you want to initialize stuff... Also: added dummy draw function for NLA channel region, was too ugly.
2008-12-22 10:09:56 +00:00
static SpaceLink *time_new(const bContext *C)
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
Scene *scene = CTX_data_scene(C);
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
ARegion *ar;
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
SpaceTime *stime;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
stime = MEM_callocN(sizeof(SpaceTime), "inittime");
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
stime->spacetype = SPACE_TIME;
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
stime->flag |= TIME_DRAWFRAMES;
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
/* header */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar = MEM_callocN(sizeof(ARegion), "header for time");
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
BLI_addtail(&stime->regionbase, ar);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->regiontype = RGN_TYPE_HEADER;
ar->alignment = RGN_ALIGN_BOTTOM;
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
/* main area */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar = MEM_callocN(sizeof(ARegion), "main area for time");
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
BLI_addtail(&stime->regionbase, ar);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->regiontype = RGN_TYPE_WINDOW;
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
style cleanup: mainly for mesh code, also some WM function use.
2012-03-24 02:51:46 +00:00
ar->v2d.tot.xmin = (float)(SFRA - 4);
ar->v2d.tot.ymin = 0.0f;
ar->v2d.tot.xmax = (float)(EFRA + 4);
ar->v2d.tot.ymax = 50.0f;
View2D: Bugfixes... * Headers were twitching when moved again due to a hack I had made for the TimeLine * Properly fixed TimeLine init so that grid will start in the right place.
2008-12-14 10:57:52 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->v2d.cur = ar->v2d.tot;
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->v2d.min[0] = 1.0f;
ar->v2d.min[1] = 50.0f;
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->v2d.max[0] = MAXFRAMEF;
ar->v2d.max[1] = 50.0;
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->v2d.minzoom = 0.1f;
ar->v2d.maxzoom = 10.0;
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
ar->v2d.scroll |= (V2D_SCROLL_BOTTOM | V2D_SCROLL_SCALE_HORIZONTAL);
View2D: Cleanup of presets and fixed errors in various views Now, preset view configurations are only to be used if they define all (scrollers not included) relevant settings for the view they are set for. This should be less confusing than in the previous situation with V2D_COMMONVIEW_TIMELINE stuff. One implication of this though, is that all Animation Editors (for example), will have to define their own version of the relatively commonly shared info. However, given the great diversity in the range of settings each have, this should not be too much of an issue. Also, added a 'standard' view config for main 'window' regions. At this stage, it is recommended that this view config should be used only as a placeholder template on which a set of custom settings could be based. I've put it into use for the buttons window/scripts window/info window so far.
2008-12-17 10:25:02 +00:00
ar->v2d.align |= V2D_ALIGN_NO_NEG_Y;
ar->v2d.keepofs |= V2D_LOCKOFS_Y;
ar->v2d.keepzoom |= V2D_LOCKZOOM_Y;
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
return (SpaceLink *)stime;
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
/* not spacelink itself */
static void time_free(SpaceLink *sl)
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
SpaceTime *stime = (SpaceTime *)sl;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
time_cache_free(stime);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
2.5 Area Manager: revised how an area subdivision gets managed. Originally the 'spacedata' would store regiondata too, but this already became impractical (like having view2d data in region is useful). So I left that part how it is. See new diagram: http://wiki.blender.org/index.php/BlenderDev/Blender2.5/AreaManager This means that regions in an Area define location/size or constraints for how they get arranged. The "RegionType" which is linked to this defines its functionality. For fun, test, and code validation: two temporary hotkeys added. SKEY: splits current region horizontally SHIFT+S: splits vertically Note - in outliner - that "context" sticks to the Area as whole, the region here only defines view. That's the purpose. :) For two outliners with different context you open 2 areas. Also note that dragging screen-edges shows the region-alignment type (split with percentage).
2008-12-09 15:59:43 +00:00
/* spacetype; init callback in ED_area_initialize() */
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
/* init is called to (re)initialize an existing editor (file read, screen changes) */
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
/* validate spacedata, add own area level handlers */
editors/space_* build without unused args warnings
2010-10-16 08:03:28 +00:00
static void time_init(wmWindowManager *UNUSED(wm), ScrArea *sa)
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
SpaceTime *stime = (SpaceTime *)sa->spacedata.first;
2.5 Today's progress; half working, but i better commit to prevent conflicts tomorrow :) - added storage for regions in spacedata - added space switching (unfinished, gives mem-free errors) - bugfix: icon of timewindow gave error on split-area - cleaned interface_icons.c a bit, no warnings - first work on space new() callbacks, they have to make regions too NOTE: probably files saved with 2.5 crash now. Have to look at patching this. NOTE2: the Makefiles required libeditor screen twice... scons too?
2008-12-11 19:35:27 +00:00
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
time_cache_free(stime);
/* enable all cache display */
stime->cache_display |= TIME_CACHE_DISPLAY;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
stime->cache_display |= (TIME_CACHE_SOFTBODY | TIME_CACHE_PARTICLES);
stime->cache_display |= (TIME_CACHE_CLOTH | TIME_CACHE_SMOKE | TIME_CACHE_DYNAMICPAINT);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
static SpaceLink *time_duplicate(SpaceLink *sl)
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
SpaceTime *stime = (SpaceTime *)sl;
SpaceTime *stimen = MEM_dupallocN(stime);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
Fix for [#26205] Crash when duplicating window * Timeline duplication code freed the original time caches too.
2011-02-25 08:40:57 +00:00
stimen->caches.first = stimen->caches.last = NULL;
Timeline addition: Display cached frames This started off doing pointcache debugging but it's also very useful for users too. Previously it was very hard to see the state of the system when you're working caches such as physics point cache - is it baked? which frames are cached? is it out of date? Now, for better feedback, cached frames are drawn for the active object at the bottom of the timeline - a semitransparent area shows the entire cache extents, and more solid blocks on top show the frames that are cached. Darker versions indicate it's using a disk cache. It can be disabled in general in the timeline View -> Caches menu, or by each individual system that can be shown. There's still a bit to do on this, behaviour needs to be clarified still eg. deciding what shows when it's out of date, or when it's been played back but not cached, etc. etc. Part of this is due to a lack of definition in the point cache system itself, so we should try and clean up/clarify this behaviour and what it means to users, at the same time. Also would be interested in extending this to other caches such as fluid cache, sequencer memory cache etc. in the future, too.
2010-06-22 02:29:52 +00:00
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
return (SpaceLink *)stimen;
}
2.5 Fixes in view2d: - mask/slider rects were calculated wrong 1 pixel (was overlapping) - found bug with outliner stretching on area-edge-dragging. It required an extra mapping of the 'cur view' via mask to actual region. - added v2d sanity check for uninitialized v2d's - removed cruft in do_versions for headers (gets catched with above) - added header-view2d-initialize function, for new-space calls Fixes in areamanager: - fixes in 'new space' for time/outliner/view2d (unfinished) For Joshua: - Making time window higher shows it doesn't update 'cur'. Not sure what kind of v2d flag should be checked or set?
2008-12-12 16:29:33 +00:00
/* only called once, from space_api/spacetypes.c */
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
/* it defines all callbacks to maintain spaces */
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
void ED_spacetype_time(void)
{
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype time");
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
ARegionType *art;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
st->spaceid = SPACE_TIME;
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
strncpy(st->name, "Timeline", BKE_ST_MAXNAME);
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
st->new = time_new;
st->free = time_free;
st->init = time_init;
st->duplicate = time_duplicate;
st->operatortypes = time_operatortypes;
st->keymap = NULL;
st->listener = time_listener;
st->refresh = time_refresh;
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
/* regions: main window */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art = MEM_callocN(sizeof(ARegionType), "spacetype time region");
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
art->regionid = RGN_TYPE_WINDOW;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art->keymapflag = ED_KEYMAP_VIEW2D | ED_KEYMAP_MARKERS | ED_KEYMAP_ANIMATION | ED_KEYMAP_FRAMES;
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art->init = time_main_area_init;
art->draw = time_main_area_draw;
art->listener = time_main_area_listener;
art->keymap = time_keymap;
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_addhead(&st->regiontypes, art);
/* regions: header */
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art = MEM_callocN(sizeof(ARegionType), "spacetype time region");
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
art->regionid = RGN_TYPE_HEADER;
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art->prefsizey = HEADERY;
art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
style cleanup: gpencil & metaball
2012-05-08 18:29:02 +00:00
art->init = time_header_area_init;
art->draw = time_header_area_draw;
art->listener = time_header_area_listener;
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_addhead(&st->regiontypes, art);
2.5 Cleanup in area/region management - more intelligence in area management for adding handlers and setting data correct. Space/Region type callbacks only have to do own things. - added option for adding default handlers to areas/regions. (flag in type definition) - ensured that region-types store the minsizes for regions. - added boundbox check for handlers; note that it accepts pointer to boundbox, because handlers don't get reset on area-resizing or view changes. Example: view2d handlers use mask rect. - handlers get now added on correct context levels (example frame change also worked in header) - removed ->refresh() callback. Context refreshing is Listener. - the ->init() is being called on all WM level actions, also after a file read, moving areas, re-opening areas etc. - fixed bug: crash on exit was caused by cleaning up Screen too late. - UI_view2d_size_update() removed from draw callback, is init() - regions now store (winx, winy) subwindow size.
2008-12-10 13:56:54 +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
BKE_spacetype_register(st);
2.5 Branch ========== * Changed wmOperatorType, removing init/exit callbacks and adding cancel callback, removed default storage in favor of properties. Defined return values for exec/invoke/modal/cancel. * Don't allocate operator on the stack, and removed operator copy for handlers. Now it frees based on return values from callbacks, and just keeps a wmOperator on the heap. Also it now registers after the operator is fully finished, to get the correct final properties. * Changed OP_get_* functions to return 1 if the property is found and 0 otherwise, gives more readable code in my opinion. Added OP_verify_* functions to quickly check if the property is available and set if it's not, that's common for exec/invoke. * Removed WM_operatortypelist_append in favor of WM_operatortype_append which takes a function pointer instead of a list, avoids macro's and duplicating code. * Fix a crash where the handler would still be used while it was freed by the operator. * Spacetypes now have operatortypes() and keymap() callbacks to abstract them a bit more. * Renamed C->curarea to C->area for consistency. Removed View3D/View2D/ SpaceIpo from bContext, seems bad to keep these. * Set context variables like window/screen/area/region to NULL again when leaving that context, instead of leaving the pointers there. * Added if(G.f & G_DEBUG) for many of the prints, makes output a bit cleaner and easier to debug. * Fixed priority of the editors/interface module in scons, would otherwise give link errors. * Added start of generic view2d api. * Added space_time with some basic drawing and a single operator to change the frame.
2008-06-11 10:10:31 +00:00
}
Copy Permalink