2008-11-28 04:01:35 +00:00
|
|
|
/**
|
|
|
|
|
* $Id$
|
|
|
|
|
*
|
|
|
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
|
*
|
|
|
|
|
* The Original Code is Copyright (C) 2008 Blender Foundation.
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Contributor(s): Blender Foundation, Joshua Leung
|
|
|
|
|
*
|
|
|
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
|
|
|
*/
|
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
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
#include <string.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 <math.h>
|
|
|
|
|
|
2008-10-08 18:07:56 +00:00
|
|
|
#include "MEM_guardedalloc.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 "DNA_screen_types.h"
|
|
|
|
|
#include "DNA_space_types.h"
|
|
|
|
|
#include "DNA_view2d_types.h"
|
|
|
|
|
|
2008-12-12 16:29:33 +00:00
|
|
|
#include "BLI_blenlib.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"
|
2008-11-30 06:15:33 +00:00
|
|
|
#include "BKE_utildefines.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 "BIF_gl.h"
|
2008-12-01 00:20:19 +00:00
|
|
|
#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
|
|
|
|
2008-12-03 22:35:38 +00:00
|
|
|
#include "ED_screen.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"
|
2008-12-04 02:01:42 +00:00
|
|
|
#include "UI_text.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_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
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
#include "UI_interface.h"
|
|
|
|
|
#include "interface.h"
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* *********************************************************************** */
|
2008-12-02 09:43:23 +00:00
|
|
|
/* Refresh and Validation */
|
2008-12-01 00:20:19 +00:00
|
|
|
|
2008-12-14 08:32:21 +00:00
|
|
|
#if 0 // experimental code - not ready to be used yet!
|
|
|
|
|
/* common View2D view types */
|
|
|
|
|
// XXX move this to header as part of API
|
|
|
|
|
enum {
|
|
|
|
|
/* 4 quadrants, centered at (0,0), zoomable and pannable, best for flexible sized data with precision needed */
|
|
|
|
|
V2D_VIEWTYPE_CANVAS = 0,
|
|
|
|
|
V2D_VIEWTYPE_LIST,
|
|
|
|
|
V2D_VIEWTYPE_PANEL,
|
|
|
|
|
/* same as canvas, except aspect ratio is important */
|
|
|
|
|
// XXX is this more of the sort tweaks that region should do to its view2d data first?
|
|
|
|
|
V2D_VIEWTYPE_IMAGE,
|
|
|
|
|
} eView2D_CommonViewTypes;
|
|
|
|
|
|
|
|
|
|
/* Initialise all View2D data for a given region */
|
|
|
|
|
void UI_view2d_regiondata_init(View2D *v2d, short type, int winx, int winy)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2008-12-05 02:03:37 +00:00
|
|
|
/* Adjust mask size in response to view size changes
|
2008-12-11 03:50:50 +00:00
|
|
|
* - This should only be called in region init() callbacks, which are
|
|
|
|
|
* called when the region is resized or area changes...
|
2008-12-05 02:03:37 +00:00
|
|
|
*/
|
2008-11-28 04:01:35 +00:00
|
|
|
// XXX pre2.5 -> this used to be called calc_scrollrcts()
|
2008-12-05 02:03:37 +00:00
|
|
|
void UI_view2d_size_update(View2D *v2d, int winx, int winy)
|
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
|
|
|
{
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->winx= winx;
|
|
|
|
|
v2d->winy= winy;
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* mask - view frame */
|
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
|
|
|
v2d->mask.xmin= v2d->mask.ymin= 0;
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->mask.xmax= winx - 1; /* -1 yes! masks are pixels */
|
|
|
|
|
v2d->mask.ymax= winy - 1;
|
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
|
|
|
|
2008-11-30 06:15:33 +00:00
|
|
|
/* scrollbars shrink mask area, but should be based off regionsize
|
|
|
|
|
* - they can only be on one edge of the region they define
|
|
|
|
|
*/
|
|
|
|
|
if (v2d->scroll) {
|
2008-11-28 04:01:35 +00:00
|
|
|
/* vertical scrollbar */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & V2D_SCROLL_LEFT) {
|
2008-11-28 04:01:35 +00:00
|
|
|
/* on left-hand edge of region */
|
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
|
|
|
v2d->vert= v2d->mask;
|
2008-12-04 20:28:59 +00:00
|
|
|
v2d->vert.xmax= V2D_SCROLL_WIDTH;
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->mask.xmin= v2d->vert.xmax + 1;
|
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
|
|
|
}
|
2008-12-04 20:28:59 +00:00
|
|
|
else if (v2d->scroll & V2D_SCROLL_RIGHT) {
|
2008-11-28 04:01:35 +00:00
|
|
|
/* on right-hand edge of region */
|
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
|
|
|
v2d->vert= v2d->mask;
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->vert.xmin= v2d->vert.xmax - V2D_SCROLL_WIDTH;
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->mask.xmax= v2d->vert.xmin - 1;
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* horizontal scrollbar */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & (V2D_SCROLL_BOTTOM|V2D_SCROLL_BOTTOM_O)) {
|
|
|
|
|
/* on bottom edge of region (V2D_SCROLL_BOTTOM_O is outliner, the ohter is for standard) */
|
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
|
|
|
v2d->hor= v2d->mask;
|
2008-12-04 20:28:59 +00:00
|
|
|
v2d->hor.ymax= V2D_SCROLL_HEIGHT;
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->mask.ymin= v2d->hor.ymax + 1;
|
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
|
|
|
}
|
2008-12-04 20:28:59 +00:00
|
|
|
else if (v2d->scroll & V2D_SCROLL_TOP) {
|
2008-11-28 04:01:35 +00:00
|
|
|
/* on upper edge of region */
|
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
|
|
|
v2d->hor= v2d->mask;
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->hor.ymin= v2d->hor.ymax - V2D_SCROLL_HEIGHT;
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->mask.ymax= v2d->hor.ymin - 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* cope with unitialized veriables for simple cases, like header or outliner */
|
2008-12-14 08:32:21 +00:00
|
|
|
// XXX er... this shouldn't be here??? or at least some extra checks are needed for some things...
|
2008-12-12 16:29:33 +00:00
|
|
|
if(v2d->tot.xmin==v2d->tot.xmax || v2d->cur.xmin==v2d->cur.xmax) {
|
|
|
|
|
if(v2d->keepzoom) {
|
|
|
|
|
BLI_init_rctf(&v2d->tot, v2d->mask.xmin, v2d->mask.xmax, v2d->mask.ymin, v2d->mask.ymax);
|
|
|
|
|
BLI_init_rctf(&v2d->cur, v2d->mask.xmin, v2d->mask.xmax, v2d->mask.ymin, v2d->mask.ymax);
|
|
|
|
|
|
|
|
|
|
v2d->min[0]= v2d->max[0]= winx;
|
|
|
|
|
v2d->min[1]= v2d->max[1]= winy;
|
|
|
|
|
v2d->minzoom= 1.0f;
|
|
|
|
|
v2d->maxzoom= 1.0f;
|
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
|
|
|
}
|
|
|
|
|
}
|
2008-12-11 03:50:50 +00:00
|
|
|
|
|
|
|
|
/* make sure that 'cur' rect is in a valid state as a result of these changes */
|
|
|
|
|
UI_view2d_curRect_validate(v2d);
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-30 06:15:33 +00:00
|
|
|
/* Ensure View2D rects remain in a viable configuration
|
|
|
|
|
* - cur is not allowed to be: larger than max, smaller than min, or outside of tot
|
|
|
|
|
*/
|
|
|
|
|
// XXX pre2.5 -> this used to be called test_view2d()
|
2008-12-10 09:07:15 +00:00
|
|
|
void UI_view2d_curRect_validate(View2D *v2d)
|
2008-11-30 06:15:33 +00:00
|
|
|
{
|
2008-12-06 09:25:42 +00:00
|
|
|
float totwidth, totheight, curwidth, curheight, width, height;
|
2008-12-10 09:07:15 +00:00
|
|
|
float winx, winy;
|
2008-11-30 06:15:33 +00:00
|
|
|
rctf *cur, *tot;
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* use mask as size of region that View2D resides in, as it takes into account scrollbars already */
|
2008-12-10 09:07:15 +00:00
|
|
|
winx= (float)(v2d->mask.xmax - v2d->mask.xmin + 1);
|
|
|
|
|
winy= (float)(v2d->mask.ymax - v2d->mask.ymin + 1);
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* get pointers to rcts for less typing */
|
2008-11-30 06:15:33 +00:00
|
|
|
cur= &v2d->cur;
|
2008-12-05 18:41:28 +00:00
|
|
|
tot= &v2d->tot;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* we must satisfy the following constraints (in decreasing order of importance):
|
|
|
|
|
* - cur must not fall outside of tot
|
|
|
|
|
* - axis locks (zoom and offset) must be maintained
|
|
|
|
|
* - zoom must not be excessive (check either sizes or zoom values)
|
2008-12-10 09:07:15 +00:00
|
|
|
* - aspect ratio should be respected (NOTE: this is quite closely realted to zoom too)
|
2008-12-06 09:25:42 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* Step 1: if keepzoom, adjust the sizes of the rects only
|
|
|
|
|
* - firstly, we calculate the sizes of the rects
|
|
|
|
|
* - curwidth and curheight are saved as reference... modify width and height values here
|
|
|
|
|
*/
|
|
|
|
|
totwidth= tot->xmax - tot->xmin;
|
|
|
|
|
totheight= tot->ymax - tot->ymin;
|
|
|
|
|
curwidth= width= cur->xmax - cur->xmin;
|
|
|
|
|
curheight= height= cur->ymax - cur->ymin;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* if zoom is locked, size on the appropriate axis is reset to mask size */
|
2008-12-14 08:32:21 +00:00
|
|
|
if (v2d->keepzoom & V2D_LOCKZOOM_X) {
|
|
|
|
|
cur->xmax= cur->xmin + winx;
|
|
|
|
|
curwidth= width= winx;
|
|
|
|
|
}
|
|
|
|
|
if (v2d->keepzoom & V2D_LOCKZOOM_Y) {
|
|
|
|
|
cur->ymax= cur->ymin + winy;
|
|
|
|
|
curheight= height= winy;
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* keepzoom (V2D_KEEPZOOM set), indicates that zoom level on each axis must not exceed limits
|
|
|
|
|
* NOTE: in general, it is not expected that the lock-zoom will be used in conjunction with this
|
|
|
|
|
*/
|
|
|
|
|
if (v2d->keepzoom & V2D_KEEPZOOM) {
|
|
|
|
|
float zoom, fac;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* check if excessive zoom on x-axis */
|
2008-12-11 03:50:50 +00:00
|
|
|
if ((v2d->keepzoom & V2D_LOCKZOOM_X)==0) {
|
|
|
|
|
zoom= winx / width;
|
|
|
|
|
if ((zoom < v2d->minzoom) || (zoom > v2d->maxzoom)) {
|
|
|
|
|
fac= (zoom < v2d->minzoom) ? (zoom / v2d->minzoom) : (zoom / v2d->maxzoom);
|
|
|
|
|
width *= fac;
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* check if excessive zoom on y-axis */
|
2008-12-11 03:50:50 +00:00
|
|
|
if ((v2d->keepzoom & V2D_LOCKZOOM_Y)==0) {
|
|
|
|
|
zoom= winy / height;
|
|
|
|
|
if ((zoom < v2d->minzoom) || (zoom > v2d->maxzoom)) {
|
|
|
|
|
fac= (zoom < v2d->minzoom) ? (zoom / v2d->minzoom) : (zoom / v2d->maxzoom);
|
|
|
|
|
height *= fac;
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* make sure sizes don't exceed that of the min/max sizes (even though we're not doing zoom clamping) */
|
|
|
|
|
CLAMP(width, v2d->min[0], v2d->max[0]);
|
|
|
|
|
CLAMP(height, v2d->min[1], v2d->max[1]);
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* check if we should restore aspect ratio (if view size changed) */
|
2008-12-14 08:32:21 +00:00
|
|
|
if (v2d->keepzoom & V2D_KEEPASPECT) {
|
2008-12-06 09:25:42 +00:00
|
|
|
short do_x=0, do_y=0, do_cur, do_win;
|
|
|
|
|
float curRatio, winRatio;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
|
|
|
|
/* when a window edge changes, the aspect ratio can't be used to
|
|
|
|
|
* find which is the best new 'cur' rect. thats why it stores 'old'
|
|
|
|
|
*/
|
|
|
|
|
if (winx != v2d->oldwinx) do_x= 1;
|
|
|
|
|
if (winy != v2d->oldwiny) do_y= 1;
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
curRatio= height / width;
|
2008-12-10 09:07:15 +00:00
|
|
|
winRatio= winy / winx;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
|
|
|
|
/* both sizes change (area/region maximised) */
|
|
|
|
|
if (do_x == do_y) {
|
2008-12-06 09:25:42 +00:00
|
|
|
if (do_x && do_y) {
|
|
|
|
|
/* here is 1,1 case, so all others must be 0,0 */
|
2008-11-30 06:15:33 +00:00
|
|
|
if (ABS(winx - v2d->oldwinx) > ABS(winy - v2d->oldwiny)) do_y= 0;
|
|
|
|
|
else do_x= 0;
|
|
|
|
|
}
|
2008-12-06 09:25:42 +00:00
|
|
|
else if (winRatio > 1.0f) do_x= 0;
|
2008-11-30 06:15:33 +00:00
|
|
|
else do_x= 1;
|
|
|
|
|
}
|
2008-12-06 09:25:42 +00:00
|
|
|
do_cur= do_x;
|
|
|
|
|
do_win= do_y;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
if (do_cur) {
|
2008-12-05 02:03:37 +00:00
|
|
|
if ((v2d->keeptot == 2) && (winx != v2d->oldwinx)) {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* special exception for Outliner (and later channel-lists):
|
|
|
|
|
* - The view may be moved left to avoid contents being pushed out of view when view shrinks.
|
|
|
|
|
* - The keeptot code will make sure cur->xmin will not be less than tot->xmin (which cannot be allowed)
|
|
|
|
|
* - width is not adjusted for changed ratios here...
|
2008-11-30 06:15:33 +00:00
|
|
|
*/
|
2008-12-06 09:25:42 +00:00
|
|
|
if (winx < v2d->oldwinx) {
|
|
|
|
|
float temp = v2d->oldwinx - winx;
|
|
|
|
|
|
|
|
|
|
cur->xmin -= temp;
|
|
|
|
|
cur->xmax -= temp;
|
|
|
|
|
|
|
|
|
|
/* width does not get modified, as keepaspect here is just set to make
|
|
|
|
|
* sure visible area adjusts to changing view shape!
|
|
|
|
|
*/
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
else {
|
|
|
|
|
/* portrait window: correct for x */
|
2008-12-06 09:25:42 +00:00
|
|
|
width= height / winRatio;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* landscape window: correct for y */
|
|
|
|
|
height = width * winRatio;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* store region size for next time */
|
|
|
|
|
v2d->oldwinx= winx;
|
|
|
|
|
v2d->oldwiny= winy;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* Step 2: apply new sizes of cur rect to cur rect */
|
|
|
|
|
if ((width != curwidth) || (height != curheight)) {
|
|
|
|
|
float temp, dh;
|
|
|
|
|
|
|
|
|
|
/* resize around 'center' of frame */
|
|
|
|
|
if (width != curwidth) {
|
2008-12-10 09:07:15 +00:00
|
|
|
temp= (cur->xmax + cur->xmin) * 0.5f;
|
|
|
|
|
dh= width * 0.5f;
|
2008-12-06 09:25:42 +00:00
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
cur->xmin = temp - dh;
|
|
|
|
|
cur->xmax = temp + dh;
|
2008-12-06 09:25:42 +00:00
|
|
|
}
|
|
|
|
|
if (height != curheight) {
|
2008-12-10 09:07:15 +00:00
|
|
|
temp= (cur->ymax + cur->ymin) * 0.5f;
|
|
|
|
|
dh= height * 0.5f;
|
2008-12-06 09:25:42 +00:00
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
cur->ymin = temp - dh;
|
|
|
|
|
cur->ymax = temp + dh;
|
2008-12-06 09:25:42 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Step 3: adjust so that it doesn't fall outside of bounds of tot */
|
2008-11-30 06:15:33 +00:00
|
|
|
if (v2d->keeptot) {
|
2008-12-11 03:50:50 +00:00
|
|
|
float temp, diff;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* recalculate extents of cur */
|
|
|
|
|
curwidth= cur->xmax - cur->xmin;
|
|
|
|
|
curheight= cur->ymax - cur->ymin;
|
|
|
|
|
|
|
|
|
|
/* width */
|
2008-12-11 03:50:50 +00:00
|
|
|
if ( (curwidth > totwidth) && !(v2d->keepzoom & (V2D_KEEPZOOM|V2D_LOCKZOOM_X)) ) {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* if zoom doesn't have to be maintained, just clamp edges */
|
|
|
|
|
if (cur->xmin < tot->xmin) cur->xmin= tot->xmin;
|
|
|
|
|
if (cur->xmax > tot->xmax) cur->xmax= tot->xmax;
|
|
|
|
|
}
|
|
|
|
|
else if (v2d->keeptot == 2) {
|
|
|
|
|
/* This is an exception for the outliner (and later channel-lists)
|
|
|
|
|
* - must clamp within tot rect (absolutely no excuses)
|
|
|
|
|
* --> therefore, cur->xmin must not be less than tot->xmin
|
|
|
|
|
*/
|
|
|
|
|
if (cur->xmin < tot->xmin) {
|
|
|
|
|
/* move cur across so that it sits at minimum of tot */
|
|
|
|
|
temp= tot->xmin - cur->xmin;
|
|
|
|
|
|
|
|
|
|
cur->xmin += temp;
|
|
|
|
|
cur->xmax += temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
2008-12-06 09:25:42 +00:00
|
|
|
else if (cur->xmax > tot->xmax) {
|
|
|
|
|
/* - only offset by difference of cur-xmax and tot-xmax if that would not move
|
|
|
|
|
* cur-xmin to lie past tot-xmin
|
|
|
|
|
* - otherwise, simply shift to tot-xmin???
|
|
|
|
|
*/
|
|
|
|
|
temp= cur->xmax - tot->xmax;
|
|
|
|
|
|
|
|
|
|
if ((cur->xmin - temp) < tot->xmin) {
|
2008-12-10 09:07:15 +00:00
|
|
|
/* only offset by difference from cur-min and tot-min */
|
2008-12-06 09:25:42 +00:00
|
|
|
temp= cur->xmin - tot->xmin;
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
cur->xmin -= temp;
|
|
|
|
|
cur->xmax -= temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
2008-12-06 09:25:42 +00:00
|
|
|
else {
|
|
|
|
|
cur->xmin -= temp;
|
|
|
|
|
cur->xmax -= temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* This here occurs when:
|
|
|
|
|
* - width too big, but maintaining zoom (i.e. widths cannot be changed)
|
|
|
|
|
* - width is OK, but need to check if outside of boundaries
|
|
|
|
|
*
|
|
|
|
|
* So, resolution is to just shift view by the gap between the extremities.
|
|
|
|
|
* We favour moving the 'minimum' across, as that's origin for most things
|
|
|
|
|
* (XXX - in the past, max was favoured... if there are bugs, swap!)
|
|
|
|
|
*/
|
2008-12-11 03:50:50 +00:00
|
|
|
if ((cur->ymin < tot->ymin) && (cur->ymax > tot->ymax)) {
|
|
|
|
|
/* outside boundaries on both sides, so take middle-point of tot, and place in balanced way */
|
|
|
|
|
temp= (tot->ymax + tot->ymin) * 0.5f;
|
|
|
|
|
diff= curheight * 0.5f;
|
|
|
|
|
|
|
|
|
|
cur->ymin= temp - diff;
|
|
|
|
|
cur->ymax= temp + diff;
|
|
|
|
|
}
|
2008-12-14 08:32:21 +00:00
|
|
|
else if (cur->xmin < tot->xmin) {
|
|
|
|
|
/* move cur across so that it sits at minimum of tot */
|
|
|
|
|
temp= tot->xmin - cur->xmin;
|
2008-12-06 09:25:42 +00:00
|
|
|
|
|
|
|
|
cur->xmin += temp;
|
|
|
|
|
cur->xmax += temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
2008-12-14 08:32:21 +00:00
|
|
|
else if (cur->xmax > tot->xmax) {
|
|
|
|
|
/* - only offset by difference of cur-xmax and tot-xmax if that would not move
|
|
|
|
|
* cur-xmin to lie past tot-xmin
|
|
|
|
|
* - otherwise, simply shift to tot-xmin???
|
|
|
|
|
*/
|
|
|
|
|
temp= cur->xmax - tot->xmax;
|
|
|
|
|
|
|
|
|
|
if ((cur->xmin - temp) < tot->xmin) {
|
|
|
|
|
/* only offset by difference from cur-min and tot-min */
|
|
|
|
|
temp= cur->xmin - tot->xmin;
|
|
|
|
|
|
|
|
|
|
cur->xmin -= temp;
|
|
|
|
|
cur->xmax -= temp;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
cur->xmin -= temp;
|
|
|
|
|
cur->xmax -= temp;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-06 09:25:42 +00:00
|
|
|
/* height */
|
2008-12-11 03:50:50 +00:00
|
|
|
if ( (curheight > totheight) && !(v2d->keepzoom & (V2D_KEEPZOOM|V2D_LOCKZOOM_Y)) ) {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* if zoom doesn't have to be maintained, just clamp edges */
|
|
|
|
|
if (cur->ymin < tot->ymin) cur->ymin= tot->ymin;
|
|
|
|
|
if (cur->ymax > tot->ymax) cur->ymax= tot->ymax;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
else {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* This here occurs when:
|
|
|
|
|
* - height too big, but maintaining zoom (i.e. heights cannot be changed)
|
|
|
|
|
* - height is OK, but need to check if outside of boundaries
|
|
|
|
|
*
|
|
|
|
|
* So, resolution is to just shift view by the gap between the extremities.
|
|
|
|
|
* We favour moving the 'minimum' across, as that's origin for most things
|
|
|
|
|
*/
|
2008-12-11 03:50:50 +00:00
|
|
|
if ((cur->ymin < tot->ymin) && (cur->ymax > tot->ymax)) {
|
|
|
|
|
/* outside boundaries on both sides, so take middle-point of tot, and place in balanced way */
|
|
|
|
|
temp= (tot->ymax + tot->ymin) * 0.5f;
|
|
|
|
|
diff= curheight * 0.5f;
|
|
|
|
|
|
|
|
|
|
cur->ymin= temp - diff;
|
|
|
|
|
cur->ymax= temp + diff;
|
|
|
|
|
}
|
|
|
|
|
else if (cur->ymin < tot->ymin) {
|
2008-12-06 09:25:42 +00:00
|
|
|
/* there's still space remaining, so shift up */
|
|
|
|
|
temp= tot->ymin - cur->ymin;
|
|
|
|
|
|
|
|
|
|
cur->ymin += temp;
|
|
|
|
|
cur->ymax += temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
else if (cur->ymax > tot->ymax) {
|
2008-12-10 09:07:15 +00:00
|
|
|
/* there's still space remaining, so shift down */
|
2008-12-06 09:25:42 +00:00
|
|
|
temp= cur->ymax - tot->ymax;
|
|
|
|
|
|
|
|
|
|
cur->ymin -= temp;
|
|
|
|
|
cur->ymax -= temp;
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-12-12 16:29:33 +00:00
|
|
|
|
2008-11-30 06:15:33 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-05 02:03:37 +00:00
|
|
|
/* ------------------ */
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
/* Restore 'cur' rect to standard orientation (i.e. optimal maximum view of tot) */
|
|
|
|
|
void UI_view2d_curRect_reset (View2D *v2d)
|
2008-12-05 02:03:37 +00:00
|
|
|
{
|
2008-12-10 09:07:15 +00:00
|
|
|
float width, height;
|
|
|
|
|
|
|
|
|
|
/* assume width and height of 'cur' rect by default, should be same size as mask */
|
|
|
|
|
width= (float)(v2d->mask.xmax - v2d->mask.xmin + 1);
|
|
|
|
|
height= (float)(v2d->mask.ymax - v2d->mask.ymin + 1);
|
|
|
|
|
|
2008-12-05 02:03:37 +00:00
|
|
|
/* handle width - posx and negx flags are mutually exclusive, so watch out */
|
|
|
|
|
if ((v2d->align & V2D_ALIGN_NO_POS_X) && !(v2d->align & V2D_ALIGN_NO_NEG_X)) {
|
|
|
|
|
/* width is in negative-x half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.xmin= (float)-width;
|
|
|
|
|
v2d->cur.xmax= 0.0f;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else if ((v2d->align & V2D_ALIGN_NO_NEG_X) && !(v2d->align & V2D_ALIGN_NO_POS_X)) {
|
|
|
|
|
/* width is in positive-x half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.xmin= 0.0f;
|
|
|
|
|
v2d->cur.xmax= (float)width;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* width is centered around x==0 */
|
|
|
|
|
const float dx= (float)width / 2.0f;
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.xmin= -dx;
|
|
|
|
|
v2d->cur.xmax= dx;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* handle height - posx and negx flags are mutually exclusive, so watch out */
|
|
|
|
|
if ((v2d->align & V2D_ALIGN_NO_POS_Y) && !(v2d->align & V2D_ALIGN_NO_NEG_Y)) {
|
|
|
|
|
/* height is in negative-y half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.ymin= (float)-height;
|
|
|
|
|
v2d->cur.ymax= 0.0f;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else if ((v2d->align & V2D_ALIGN_NO_NEG_Y) && !(v2d->align & V2D_ALIGN_NO_POS_Y)) {
|
|
|
|
|
/* height is in positive-y half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.ymin= 0.0f;
|
|
|
|
|
v2d->cur.ymax= (float)height;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* height is centered around y==0 */
|
|
|
|
|
const float dy= (float)height / 2.0f;
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->cur.ymin= -dy;
|
|
|
|
|
v2d->cur.ymax= dy;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-12 23:25:54 +00:00
|
|
|
/* ------------------ */
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
/* Change the size of the maximum viewable area (i.e. 'tot' rect) */
|
|
|
|
|
void UI_view2d_totRect_set (View2D *v2d, int width, int height)
|
2008-12-05 02:03:37 +00:00
|
|
|
{
|
2008-12-10 09:07:15 +00:00
|
|
|
/* don't do anything if either value is 0 */
|
|
|
|
|
if (ELEM3(0, v2d, width, height))
|
|
|
|
|
return;
|
2008-12-05 02:03:37 +00:00
|
|
|
|
|
|
|
|
/* handle width - posx and negx flags are mutually exclusive, so watch out */
|
|
|
|
|
if ((v2d->align & V2D_ALIGN_NO_POS_X) && !(v2d->align & V2D_ALIGN_NO_NEG_X)) {
|
|
|
|
|
/* width is in negative-x half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.xmin= (float)-width;
|
|
|
|
|
v2d->tot.xmax= 0.0f;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else if ((v2d->align & V2D_ALIGN_NO_NEG_X) && !(v2d->align & V2D_ALIGN_NO_POS_X)) {
|
|
|
|
|
/* width is in positive-x half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.xmin= 0.0f;
|
|
|
|
|
v2d->tot.xmax= (float)width;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* width is centered around x==0 */
|
|
|
|
|
const float dx= (float)width / 2.0f;
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.xmin= -dx;
|
|
|
|
|
v2d->tot.xmax= dx;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* handle height - posx and negx flags are mutually exclusive, so watch out */
|
|
|
|
|
if ((v2d->align & V2D_ALIGN_NO_POS_Y) && !(v2d->align & V2D_ALIGN_NO_NEG_Y)) {
|
|
|
|
|
/* height is in negative-y half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.ymin= (float)-height;
|
|
|
|
|
v2d->tot.ymax= 0.0f;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else if ((v2d->align & V2D_ALIGN_NO_NEG_Y) && !(v2d->align & V2D_ALIGN_NO_POS_Y)) {
|
|
|
|
|
/* height is in positive-y half */
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.ymin= 0.0f;
|
|
|
|
|
v2d->tot.ymax= (float)height;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* height is centered around y==0 */
|
|
|
|
|
const float dy= (float)height / 2.0f;
|
|
|
|
|
|
2008-12-10 09:07:15 +00:00
|
|
|
v2d->tot.ymin= -dy;
|
|
|
|
|
v2d->tot.ymax= dy;
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
2008-12-10 09:07:15 +00:00
|
|
|
|
|
|
|
|
/* make sure that 'cur' rect is in a valid state as a result of these changes */
|
|
|
|
|
UI_view2d_curRect_validate(v2d);
|
2008-12-05 02:03:37 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* *********************************************************************** */
|
|
|
|
|
/* View Matrix Setup */
|
|
|
|
|
|
2008-12-12 23:25:54 +00:00
|
|
|
/* mapping function to ensure 'cur' draws extended over the area where sliders are */
|
2008-12-12 16:29:33 +00:00
|
|
|
static void view2d_map_cur_using_mask(View2D *v2d, rctf *curmasked)
|
|
|
|
|
{
|
|
|
|
|
*curmasked= v2d->cur;
|
|
|
|
|
|
2008-12-13 11:34:03 +00:00
|
|
|
if ((v2d->scroll)) {
|
|
|
|
|
float dx= (v2d->cur.xmax-v2d->cur.xmin)/((float)(v2d->mask.xmax-v2d->mask.xmin+1));
|
|
|
|
|
float dy= (v2d->cur.ymax-v2d->cur.ymin)/((float)(v2d->mask.ymax-v2d->mask.ymin+1));
|
2008-12-12 16:29:33 +00:00
|
|
|
|
|
|
|
|
if (v2d->mask.xmin != 0)
|
|
|
|
|
curmasked->xmin -= dx*(float)v2d->mask.xmin;
|
|
|
|
|
if (v2d->mask.xmax+1 != v2d->winx)
|
|
|
|
|
curmasked->xmax += dx*(float)(v2d->winx - v2d->mask.xmax-1);
|
|
|
|
|
|
|
|
|
|
if (v2d->mask.ymin != 0)
|
|
|
|
|
curmasked->ymin -= dy*(float)v2d->mask.ymin;
|
|
|
|
|
if (v2d->mask.ymax+1 != v2d->winy)
|
|
|
|
|
curmasked->ymax += dy*(float)(v2d->winy - v2d->mask.ymax-1);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* Set view matrices to use 'cur' rect as viewing frame for View2D drawing
|
2008-12-12 16:29:33 +00:00
|
|
|
* - this assumes viewport/scissor been set for the region, taking scrollbars into account
|
|
|
|
|
*/
|
|
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
void UI_view2d_view_ortho(const bContext *C, View2D *v2d)
|
|
|
|
|
{
|
2008-12-12 16:29:33 +00:00
|
|
|
rctf curmasked;
|
|
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* set the matrix - pixel offsets (-0.375) for 1:1 correspondance are not applied,
|
|
|
|
|
* as they were causing some unwanted offsets when drawing
|
|
|
|
|
*/
|
2008-12-12 16:29:33 +00:00
|
|
|
view2d_map_cur_using_mask(v2d, &curmasked);
|
|
|
|
|
wmOrtho2(C->window, curmasked.xmin, curmasked.xmax, curmasked.ymin, curmasked.ymax);
|
2008-12-11 03:50:50 +00:00
|
|
|
|
|
|
|
|
/* XXX is this necessary? */
|
|
|
|
|
wmLoadIdentity(C->window);
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-03 13:14:01 +00:00
|
|
|
/* Set view matrices to only use one axis of 'cur' only
|
|
|
|
|
* - this assumes viewport/scissor been set for the region, taking scrollbars into account
|
2008-12-02 09:43:23 +00:00
|
|
|
*
|
|
|
|
|
* - xaxis = if non-zero, only use cur x-axis, otherwise use cur-yaxis (mostly this will be used for x)
|
|
|
|
|
*/
|
2008-12-05 02:03:37 +00:00
|
|
|
void UI_view2d_view_orthoSpecial(const bContext *C, View2D *v2d, short xaxis)
|
2008-12-02 09:43:23 +00:00
|
|
|
{
|
2008-12-11 03:50:50 +00:00
|
|
|
ARegion *ar= C->region;
|
2008-12-12 16:29:33 +00:00
|
|
|
rctf curmasked;
|
2008-12-02 09:43:23 +00:00
|
|
|
|
|
|
|
|
/* set the matrix - pixel offsets (-0.375) for 1:1 correspondance are not applied,
|
|
|
|
|
* as they were causing some unwanted offsets when drawing
|
|
|
|
|
*/
|
2008-12-12 16:29:33 +00:00
|
|
|
view2d_map_cur_using_mask(v2d, &curmasked);
|
2008-12-02 09:43:23 +00:00
|
|
|
if (xaxis)
|
2008-12-12 16:29:33 +00:00
|
|
|
wmOrtho2(C->window, curmasked.xmin, curmasked.xmax, 0, ar->winy);
|
2008-12-02 09:43:23 +00:00
|
|
|
else
|
2008-12-12 16:29:33 +00:00
|
|
|
wmOrtho2(C->window, 0, ar->winx, curmasked.ymin, curmasked.ymax);
|
2008-12-11 03:50:50 +00:00
|
|
|
|
|
|
|
|
/* XXX is this necessary? */
|
|
|
|
|
wmLoadIdentity(C->window);
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Restore view matrices after drawing */
|
|
|
|
|
void UI_view2d_view_restore(const bContext *C)
|
|
|
|
|
{
|
2008-12-03 22:35:38 +00:00
|
|
|
ED_region_pixelspace(C, C->region);
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-12 16:29:33 +00:00
|
|
|
/* allowing horizontal pan */
|
|
|
|
|
void UI_view2d_header_default(View2D *v2d)
|
|
|
|
|
{
|
2008-12-14 08:32:21 +00:00
|
|
|
v2d->keepzoom = (V2D_LOCKZOOM_X|V2D_LOCKZOOM_Y|V2D_KEEPZOOM|V2D_KEEPASPECT);
|
2008-12-12 16:29:33 +00:00
|
|
|
v2d->keepofs = V2D_LOCKOFS_Y;
|
|
|
|
|
v2d->keeptot = 2; // this keeps the view in place when region size changes...
|
|
|
|
|
v2d->align = V2D_ALIGN_NO_NEG_X;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* *********************************************************************** */
|
|
|
|
|
/* Gridlines */
|
2008-10-08 18:07:56 +00:00
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* minimum pixels per gridstep */
|
|
|
|
|
#define MINGRIDSTEP 35
|
|
|
|
|
|
|
|
|
|
/* View2DGrid is typedef'd in UI_view2d.h */
|
|
|
|
|
struct View2DGrid {
|
|
|
|
|
float dx, dy; /* stepsize (in pixels) between gridlines */
|
2008-12-01 00:20:19 +00:00
|
|
|
float startx, starty; /* initial coordinates to start drawing grid from */
|
2008-11-28 04:01:35 +00:00
|
|
|
int powerx, powery; /* step as power of 10 */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* --------------- */
|
|
|
|
|
|
|
|
|
|
/* try to write step as a power of 10 */
|
|
|
|
|
static void step_to_grid(float *step, int *power, int unit)
|
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
|
|
|
{
|
2008-11-28 04:01:35 +00:00
|
|
|
const float loga= log10(*step);
|
|
|
|
|
float rem;
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
*power= (int)(loga);
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
rem= loga - (*power);
|
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
|
|
|
rem= pow(10.0, rem);
|
|
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
if (loga < 0.0) {
|
|
|
|
|
if (rem < 0.2) rem= 0.2;
|
|
|
|
|
else if(rem < 0.5) rem= 0.5;
|
|
|
|
|
else rem= 1.0;
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
*step= rem * pow(10.0, (float)(*power));
|
2008-11-28 04:01:35 +00:00
|
|
|
|
|
|
|
|
/* for frames, we want 1.0 frame intervals only */
|
|
|
|
|
if (unit == V2D_UNIT_FRAMES) {
|
2008-12-04 02:01:42 +00:00
|
|
|
rem = 1.0;
|
|
|
|
|
*step = 1.0;
|
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
|
|
|
}
|
2008-11-28 04:01:35 +00:00
|
|
|
|
|
|
|
|
/* prevents printing 1.0 2.0 3.0 etc */
|
2008-12-04 02:01:42 +00:00
|
|
|
if (rem == 1.0) (*power)++;
|
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
|
|
|
}
|
|
|
|
|
else {
|
2008-12-04 02:01:42 +00:00
|
|
|
if (rem < 2.0) rem= 2.0;
|
|
|
|
|
else if(rem < 5.0) rem= 5.0;
|
|
|
|
|
else rem= 10.0;
|
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
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
*step= rem * pow(10.0, (float)(*power));
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
(*power)++;
|
|
|
|
|
/* prevents printing 1.0, 2.0, 3.0, etc. */
|
2008-12-04 02:01:42 +00:00
|
|
|
if (rem == 10.0) (*power)++;
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Intialise settings necessary for drawing gridlines in a 2d-view
|
|
|
|
|
* - Currently, will return pointer to View2DGrid struct that needs to
|
2008-12-07 06:21:06 +00:00
|
|
|
* be freed with UI_view2d_grid_free()
|
2008-12-01 00:20:19 +00:00
|
|
|
* - Is used for scrollbar drawing too (for units drawing)
|
2008-12-13 09:25:47 +00:00
|
|
|
* - Units + clamping args will be checked, to make sure they are valid values that can be used
|
|
|
|
|
* so it is very possible that we won't return grid at all!
|
2008-11-28 04:01:35 +00:00
|
|
|
*
|
2008-12-13 09:25:47 +00:00
|
|
|
* - xunits,yunits = V2D_UNIT_* grid steps in seconds or frames
|
|
|
|
|
* - xclamp,yclamp = V2D_CLAMP_* only show whole-number intervals
|
|
|
|
|
* - winx = width of region we're drawing to
|
|
|
|
|
* - winy = height of region we're drawing into
|
2008-11-28 04:01:35 +00:00
|
|
|
*/
|
2008-12-13 09:25:47 +00:00
|
|
|
View2DGrid *UI_view2d_grid_calc(const bContext *C, View2D *v2d, short xunits, short xclamp, short yunits, short yclamp, int winx, int winy)
|
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
|
|
|
{
|
2008-10-08 18:07:56 +00:00
|
|
|
View2DGrid *grid;
|
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
|
|
|
float space, pixels, seconddiv;
|
|
|
|
|
int secondgrid;
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-13 09:25:47 +00:00
|
|
|
/* check that there are at least some workable args */
|
|
|
|
|
if (ELEM(V2D_ARG_DUMMY, xunits, xclamp) && ELEM(V2D_ARG_DUMMY, yunits, yclamp))
|
|
|
|
|
return NULL;
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* grid here is allocated... */
|
2008-10-08 18:07:56 +00:00
|
|
|
grid= MEM_callocN(sizeof(View2DGrid), "View2DGrid");
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* rule: gridstep is minimal GRIDSTEP pixels */
|
2008-12-13 09:25:47 +00:00
|
|
|
if (xunits == V2D_UNIT_SECONDS) {
|
2008-12-04 02:01:42 +00:00
|
|
|
secondgrid= 1;
|
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
|
|
|
seconddiv= 0.01f * FPS;
|
|
|
|
|
}
|
|
|
|
|
else {
|
2008-12-04 02:01:42 +00:00
|
|
|
secondgrid= 0;
|
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
|
|
|
seconddiv= 1.0f;
|
|
|
|
|
}
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-13 09:25:47 +00:00
|
|
|
/* calculate x-axis grid scale (only if both args are valid) */
|
|
|
|
|
if (ELEM(V2D_ARG_DUMMY, xunits, xclamp) == 0) {
|
|
|
|
|
space= v2d->cur.xmax - v2d->cur.xmin;
|
|
|
|
|
pixels= v2d->mask.xmax - v2d->mask.xmin;
|
|
|
|
|
|
|
|
|
|
grid->dx= (MINGRIDSTEP * space) / (seconddiv * pixels);
|
|
|
|
|
step_to_grid(&grid->dx, &grid->powerx, xunits);
|
|
|
|
|
grid->dx *= seconddiv;
|
|
|
|
|
|
|
|
|
|
if (xclamp == V2D_GRID_CLAMP) {
|
|
|
|
|
if (grid->dx < 0.1f) grid->dx= 0.1f;
|
|
|
|
|
grid->powerx-= 2;
|
|
|
|
|
if (grid->powerx < -2) grid->powerx= -2;
|
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
|
2008-12-13 09:25:47 +00:00
|
|
|
/* calculate y-axis grid scale (only if both args are valid) */
|
|
|
|
|
if (ELEM(V2D_ARG_DUMMY, yunits, yclamp) == 0) {
|
|
|
|
|
space= v2d->cur.ymax - v2d->cur.ymin;
|
|
|
|
|
pixels= winy;
|
|
|
|
|
|
|
|
|
|
grid->dy= MINGRIDSTEP * space / pixels;
|
|
|
|
|
step_to_grid(&grid->dy, &grid->powery, yunits);
|
|
|
|
|
|
|
|
|
|
if (yclamp == V2D_GRID_CLAMP) {
|
|
|
|
|
if (grid->dy < 1.0f) grid->dy= 1.0f;
|
|
|
|
|
if (grid->powery < 1) grid->powery= 1;
|
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* calculate start position */
|
2008-12-13 09:25:47 +00:00
|
|
|
if (ELEM(V2D_ARG_DUMMY, xunits, xclamp) == 0) {
|
|
|
|
|
grid->startx= seconddiv*(v2d->cur.xmin/seconddiv - fmod(v2d->cur.xmin/seconddiv, grid->dx/seconddiv));
|
|
|
|
|
if (v2d->cur.xmin < 0.0f) grid->startx-= grid->dx;
|
|
|
|
|
}
|
|
|
|
|
if (ELEM(V2D_ARG_DUMMY, yunits, yclamp) == 0) {
|
|
|
|
|
grid->starty= (v2d->cur.ymin - fmod(v2d->cur.ymin, grid->dy));
|
|
|
|
|
if (v2d->cur.ymin < 0.0f) grid->starty-= grid->dy;
|
|
|
|
|
}
|
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
|
|
|
|
2008-10-08 18:07:56 +00:00
|
|
|
return grid;
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Draw gridlines in the given 2d-region */
|
2008-12-07 06:21:06 +00:00
|
|
|
void UI_view2d_grid_draw(const bContext *C, View2D *v2d, View2DGrid *grid, int flag)
|
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
|
|
|
{
|
|
|
|
|
float vec1[2], vec2[2];
|
|
|
|
|
int a, step;
|
|
|
|
|
|
2008-12-13 09:25:47 +00:00
|
|
|
/* check for grid first, as it may not exist */
|
|
|
|
|
if (grid == NULL)
|
|
|
|
|
return;
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* vertical lines */
|
|
|
|
|
if (flag & V2D_VERTICAL_LINES) {
|
|
|
|
|
/* initialise initial settings */
|
2008-10-08 18:07:56 +00:00
|
|
|
vec1[0]= vec2[0]= grid->startx;
|
|
|
|
|
vec1[1]= grid->starty;
|
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
|
|
|
vec2[1]= v2d->cur.ymax;
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* minor gridlines */
|
|
|
|
|
step= (v2d->mask.xmax - v2d->mask.xmin + 1) / MINGRIDSTEP;
|
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_ThemeColor(TH_GRID);
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
for (a=0; a<step; a++) {
|
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
|
|
|
glBegin(GL_LINE_STRIP);
|
2008-11-28 04:01:35 +00:00
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
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
|
|
|
glEnd();
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-10-08 18:07:56 +00:00
|
|
|
vec2[0]= vec1[0]+= grid->dx;
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* major gridlines */
|
|
|
|
|
vec2[0]= vec1[0]-= 0.5f*grid->dx;
|
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_GRID, 16);
|
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
|
|
|
|
|
|
|
|
step++;
|
2008-11-28 04:01:35 +00:00
|
|
|
for (a=0; a<=step; a++) {
|
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
|
|
|
glBegin(GL_LINE_STRIP);
|
2008-11-28 04:01:35 +00:00
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
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
|
|
|
glEnd();
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-10-08 18:07:56 +00:00
|
|
|
vec2[0]= vec1[0]-= grid->dx;
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* horizontal lines */
|
|
|
|
|
if (flag & V2D_HORIZONTAL_LINES) {
|
|
|
|
|
/* only major gridlines */
|
2008-10-08 18:07:56 +00:00
|
|
|
vec1[1]= vec2[1]= grid->starty;
|
2008-12-12 23:25:54 +00:00
|
|
|
vec1[0]= grid->startx;
|
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
|
|
|
vec2[0]= v2d->cur.xmax;
|
|
|
|
|
|
2008-12-12 23:25:54 +00:00
|
|
|
step= (v2d->mask.ymax - v2d->mask.ymin + 1) / MINGRIDSTEP;
|
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_ThemeColor(TH_GRID);
|
2008-11-28 04:01:35 +00:00
|
|
|
for (a=0; a<=step; a++) {
|
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
|
|
|
glBegin(GL_LINE_STRIP);
|
2008-11-28 04:01:35 +00:00
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
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
|
|
|
glEnd();
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-10-08 18:07:56 +00:00
|
|
|
vec2[1]= vec1[1]+= grid->dy;
|
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
|
|
|
}
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* fine grid lines */
|
2008-11-28 04:01:35 +00:00
|
|
|
vec2[1]= vec1[1]-= 0.5f*grid->dy;
|
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
|
|
|
step++;
|
2008-12-04 02:01:42 +00:00
|
|
|
|
2008-12-12 23:25:54 +00:00
|
|
|
if (flag & V2D_HORIZONTAL_FINELINES) {
|
2008-12-04 02:01:42 +00:00
|
|
|
UI_ThemeColorShade(TH_GRID, 16);
|
|
|
|
|
for (a=0; a<step; a++) {
|
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
|
|
|
|
glEnd();
|
|
|
|
|
|
|
|
|
|
vec2[1]= vec1[1]-= grid->dy;
|
|
|
|
|
}
|
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Axes are drawn as darker lines */
|
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_GRID, -50);
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* horizontal axis */
|
|
|
|
|
if (flag & V2D_HORIZONTAL_AXIS) {
|
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
|
|
|
vec1[0]= v2d->cur.xmin;
|
|
|
|
|
vec2[0]= v2d->cur.xmax;
|
2008-11-28 04:01:35 +00:00
|
|
|
vec1[1]= vec2[1]= 0.0f;
|
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
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
glBegin(GL_LINE_STRIP);
|
|
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
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
|
|
|
glEnd();
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* vertical axis */
|
|
|
|
|
if (flag & V2D_VERTICAL_AXIS) {
|
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
|
|
|
vec1[1]= v2d->cur.ymin;
|
|
|
|
|
vec2[1]= v2d->cur.ymax;
|
2008-11-28 04:01:35 +00:00
|
|
|
vec1[0]= vec2[0]= 0.0f;
|
|
|
|
|
|
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
|
|
|
glBegin(GL_LINE_STRIP);
|
2008-11-28 04:01:35 +00:00
|
|
|
glVertex2fv(vec1);
|
|
|
|
|
glVertex2fv(vec2);
|
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
|
|
|
glEnd();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* free temporary memory used for drawing grid */
|
2008-12-07 06:21:06 +00:00
|
|
|
void UI_view2d_grid_free(View2DGrid *grid)
|
2008-10-08 18:07:56 +00:00
|
|
|
{
|
2008-12-13 09:25:47 +00:00
|
|
|
/* only free if there's a grid */
|
|
|
|
|
if (grid)
|
|
|
|
|
MEM_freeN(grid);
|
2008-10-08 18:07:56 +00:00
|
|
|
}
|
|
|
|
|
|
2008-11-30 06:15:33 +00:00
|
|
|
/* *********************************************************************** */
|
|
|
|
|
/* Scrollbars */
|
|
|
|
|
|
2008-12-07 12:15:04 +00:00
|
|
|
/* View2DScrollers is typedef'd in UI_view2d.h
|
|
|
|
|
* WARNING: the start of this struct must not change, as view2d_ops.c uses this too.
|
|
|
|
|
* For now, we don't need to have a separate (internal) header for structs like this...
|
|
|
|
|
*/
|
2008-12-04 02:01:42 +00:00
|
|
|
struct View2DScrollers {
|
|
|
|
|
/* focus bubbles */
|
|
|
|
|
int vert_min, vert_max; /* vertical scrollbar */
|
|
|
|
|
int hor_min, hor_max; /* horizontal scrollbar */
|
2008-12-01 00:20:19 +00:00
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* scales */
|
|
|
|
|
View2DGrid *grid; /* grid for coordinate drawing */
|
|
|
|
|
short xunits, xclamp; /* units and clamping options for x-axis */
|
|
|
|
|
short yunits, yclamp; /* units and clamping options for y-axis */
|
2008-12-01 00:20:19 +00:00
|
|
|
};
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-12-01 11:37:05 +00:00
|
|
|
/* Calculate relevant scroller properties */
|
2008-12-07 06:21:06 +00:00
|
|
|
View2DScrollers *UI_view2d_scrollers_calc(const bContext *C, View2D *v2d, short xunits, short xclamp, short yunits, short yclamp)
|
2008-12-01 00:20:19 +00:00
|
|
|
{
|
|
|
|
|
View2DScrollers *scrollers;
|
2008-12-01 11:37:05 +00:00
|
|
|
rcti vert, hor;
|
|
|
|
|
float fac, totsize, scrollsize;
|
|
|
|
|
|
|
|
|
|
vert= v2d->vert;
|
|
|
|
|
hor= v2d->hor;
|
2008-12-01 00:20:19 +00:00
|
|
|
|
|
|
|
|
/* scrollers is allocated here... */
|
|
|
|
|
scrollers= MEM_callocN(sizeof(View2DScrollers), "View2DScrollers");
|
|
|
|
|
|
2008-12-03 09:06:30 +00:00
|
|
|
/* scroller 'buttons':
|
2008-12-01 11:37:05 +00:00
|
|
|
* - These should always remain within the visible region of the scrollbar
|
|
|
|
|
* - They represent the region of 'tot' that is visible in 'cur'
|
|
|
|
|
*/
|
2008-12-03 09:06:30 +00:00
|
|
|
|
|
|
|
|
/* horizontal scrollers */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & (V2D_SCROLL_HORIZONTAL|V2D_SCROLL_HORIZONTAL_O)) {
|
2008-12-07 06:21:06 +00:00
|
|
|
/* scroller 'button' extents */
|
2008-12-05 18:41:28 +00:00
|
|
|
totsize= v2d->tot.xmax - v2d->tot.xmin;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollsize= hor.xmax - hor.xmin;
|
|
|
|
|
|
2008-12-05 18:41:28 +00:00
|
|
|
fac= (v2d->cur.xmin- v2d->tot.xmin) / totsize;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollers->hor_min= hor.xmin + (fac * scrollsize);
|
|
|
|
|
|
2008-12-05 18:41:28 +00:00
|
|
|
fac= (v2d->cur.xmax - v2d->tot.xmin) / totsize;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollers->hor_max= hor.xmin + (fac * scrollsize);
|
|
|
|
|
|
|
|
|
|
if (scrollers->hor_min > scrollers->hor_max)
|
|
|
|
|
scrollers->hor_min= scrollers->hor_max;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-03 09:06:30 +00:00
|
|
|
/* vertical scrollers */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & V2D_SCROLL_VERTICAL) {
|
2008-12-07 06:21:06 +00:00
|
|
|
/* scroller 'button' extents */
|
2008-12-05 18:41:28 +00:00
|
|
|
totsize= v2d->tot.ymax - v2d->tot.ymin;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollsize= vert.ymax - vert.ymin;
|
|
|
|
|
|
2008-12-05 18:41:28 +00:00
|
|
|
fac= (v2d->cur.ymin- v2d->tot.ymin) / totsize;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollers->vert_min= vert.ymin + (fac * scrollsize);
|
|
|
|
|
|
2008-12-08 00:40:27 +00:00
|
|
|
fac= (v2d->cur.ymax - v2d->tot.ymin) / totsize;
|
2008-12-01 11:37:05 +00:00
|
|
|
scrollers->vert_max= vert.ymin + (fac * scrollsize);
|
|
|
|
|
|
|
|
|
|
if (scrollers->vert_min > scrollers->vert_max)
|
|
|
|
|
scrollers->vert_min= scrollers->vert_max;
|
|
|
|
|
}
|
2008-12-01 00:20:19 +00:00
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* grid markings on scrollbars */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & (V2D_SCROLL_SCALE_HORIZONTAL|V2D_SCROLL_SCALE_VERTICAL)) {
|
2008-12-04 02:01:42 +00:00
|
|
|
/* store clamping */
|
|
|
|
|
scrollers->xclamp= xclamp;
|
|
|
|
|
scrollers->xunits= xunits;
|
|
|
|
|
scrollers->yclamp= yclamp;
|
|
|
|
|
scrollers->yunits= yunits;
|
|
|
|
|
|
2008-12-13 09:25:47 +00:00
|
|
|
scrollers->grid= UI_view2d_grid_calc(C, v2d, xunits, xclamp, yunits, yclamp, (hor.xmax - hor.xmin), (vert.ymax - vert.ymin));
|
2008-12-04 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* return scrollers */
|
2008-12-01 00:20:19 +00:00
|
|
|
return scrollers;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* XXX */
|
|
|
|
|
extern void ui_rasterpos_safe(float x, float y, float aspect);
|
|
|
|
|
|
|
|
|
|
/* Print scale marking along a time scrollbar */
|
|
|
|
|
static void scroll_printstr(View2DScrollers *scrollers, float x, float y, float val, int power, short unit, char dir)
|
|
|
|
|
{
|
|
|
|
|
int len;
|
|
|
|
|
char str[32];
|
|
|
|
|
|
|
|
|
|
/* adjust the scale unit to work ok */
|
|
|
|
|
if (dir == 'v') {
|
|
|
|
|
/* here we bump up the power by factor of 10, as
|
|
|
|
|
* rotation values (hence 'degrees') are divided by 10 to
|
|
|
|
|
* be able to show the curves at the same time
|
|
|
|
|
*/
|
|
|
|
|
if ELEM(unit, V2D_UNIT_DEGREES, V2D_UNIT_TIME) {
|
|
|
|
|
power += 1;
|
|
|
|
|
val *= 10;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* get string to print */
|
2008-12-07 03:42:25 +00:00
|
|
|
if (unit == V2D_UNIT_SECONDS) {
|
|
|
|
|
/* SMPTE timecode style:
|
|
|
|
|
* - In general, minutes and seconds should be shown, as most clips will be
|
|
|
|
|
* within this length. Hours will only be included if relevant.
|
|
|
|
|
* - Only show frames when zoomed in enough for them to be relevant
|
|
|
|
|
* (using separator convention of ';' for frames, ala QuickTime).
|
|
|
|
|
* When showing frames, use slightly different display to avoid confusion with mm:ss format
|
|
|
|
|
*/
|
|
|
|
|
int hours=0, minutes=0, seconds=0, frames=0;
|
|
|
|
|
char neg[2]= "";
|
|
|
|
|
|
|
|
|
|
/* get values */
|
|
|
|
|
if (val < 0) {
|
|
|
|
|
/* correction for negative values */
|
|
|
|
|
sprintf(neg, "-");
|
|
|
|
|
val = -val;
|
|
|
|
|
}
|
|
|
|
|
if (val >= 3600) {
|
|
|
|
|
/* hours */
|
|
|
|
|
/* XXX should we only display a single digit for hours since clips are
|
|
|
|
|
* VERY UNLIKELY to be more than 1-2 hours max? However, that would
|
|
|
|
|
* go against conventions...
|
|
|
|
|
*/
|
|
|
|
|
hours= (int)val / 3600;
|
|
|
|
|
val= fmod(val, 3600);
|
|
|
|
|
}
|
|
|
|
|
if (val >= 60) {
|
|
|
|
|
/* minutes */
|
|
|
|
|
minutes= (int)val / 60;
|
|
|
|
|
val= fmod(val, 60);
|
|
|
|
|
}
|
|
|
|
|
if (power <= 0) {
|
|
|
|
|
/* seconds + frames
|
|
|
|
|
* Frames are derived from 'fraction' of second. We need to perform some additional rounding
|
|
|
|
|
* to cope with 'half' frames, etc., which should be fine in most cases
|
|
|
|
|
*/
|
|
|
|
|
seconds= (int)val;
|
|
|
|
|
frames= (int)floor( ((val - seconds) * FPS) + 0.5f );
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* seconds (with pixel offset) */
|
|
|
|
|
seconds= (int)floor(val + 0.375f);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* print timecode to temp string buffer */
|
|
|
|
|
if (power <= 0) {
|
|
|
|
|
/* include "frames" in display */
|
|
|
|
|
if (hours) sprintf(str, "%s%02d:%02d:%02d;%02d", neg, hours, minutes, seconds, frames);
|
|
|
|
|
else if (minutes) sprintf(str, "%s%02d:%02d;%02d", neg, minutes, seconds, frames);
|
|
|
|
|
else sprintf(str, "%s%d;%02d", neg, seconds, frames);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* don't include 'frames' in display */
|
|
|
|
|
if (hours) sprintf(str, "%s%02d:%02d:%02d", neg, hours, minutes, seconds);
|
|
|
|
|
else sprintf(str, "%s%02d:%02d", neg, minutes, seconds);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* round to whole numbers if power is >= 1 (i.e. scale is coarse) */
|
|
|
|
|
if (power <= 0) sprintf(str, "%.*f", 1-power, val);
|
|
|
|
|
else sprintf(str, "%d", (int)floor(val + 0.375f));
|
|
|
|
|
}
|
2008-12-04 02:01:42 +00:00
|
|
|
|
|
|
|
|
/* get length of string, and adjust printing location to fit it into the horizontal scrollbar */
|
|
|
|
|
len= strlen(str);
|
2008-12-07 03:42:25 +00:00
|
|
|
if (dir == 'h') {
|
|
|
|
|
/* seconds/timecode display has slightly longer strings... */
|
|
|
|
|
if (unit == V2D_UNIT_SECONDS)
|
|
|
|
|
x-= 3*len;
|
|
|
|
|
else
|
|
|
|
|
x-= 4*len;
|
|
|
|
|
}
|
2008-12-04 02:01:42 +00:00
|
|
|
|
|
|
|
|
/* Add degree sympbol to end of string for vertical scrollbar? */
|
|
|
|
|
if ((dir == 'v') && (unit == V2D_UNIT_DEGREES)) {
|
|
|
|
|
str[len]= 186;
|
|
|
|
|
str[len+1]= 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* draw it */
|
|
|
|
|
ui_rasterpos_safe(x, y, 1.0);
|
|
|
|
|
UI_DrawString(G.fonts, str, 0); // XXX check this again when new text-drawing api is done
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-14 08:32:21 +00:00
|
|
|
/* local defines for scrollers drawing */
|
|
|
|
|
/* radius of scroller 'button' caps */
|
|
|
|
|
#define V2D_SCROLLCAP_RAD 5
|
|
|
|
|
/* shading factor for scroller 'bar' */
|
|
|
|
|
#define V2D_SCROLLBAR_SHADE 0.1f
|
|
|
|
|
/* shading factor for scroller 'button' caps */
|
|
|
|
|
#define V2D_SCROLLCAP_SHADE 0.2f
|
2008-12-01 00:20:19 +00:00
|
|
|
|
|
|
|
|
/* Draw scrollbars in the given 2d-region */
|
2008-12-12 11:41:05 +00:00
|
|
|
void UI_view2d_scrollers_draw(const bContext *C, View2D *v2d, View2DScrollers *vs)
|
2008-12-01 00:20:19 +00:00
|
|
|
{
|
2008-12-14 08:32:21 +00:00
|
|
|
const short darker= -50, dark= -10, light= 20, lighter= 50;
|
2008-12-01 00:20:19 +00:00
|
|
|
rcti vert, hor;
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
/* make copies of rects for less typing */
|
2008-12-01 00:20:19 +00:00
|
|
|
vert= v2d->vert;
|
|
|
|
|
hor= v2d->hor;
|
|
|
|
|
|
|
|
|
|
/* horizontal scrollbar */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & (V2D_SCROLL_HORIZONTAL|V2D_SCROLL_HORIZONTAL_O)) {
|
2008-12-01 00:20:19 +00:00
|
|
|
/* scroller backdrop */
|
|
|
|
|
UI_ThemeColorShade(TH_SHADE1, light);
|
|
|
|
|
glRecti(hor.xmin, hor.ymin, hor.xmax, hor.ymax);
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
/* scroller 'button'
|
|
|
|
|
* - if view is zoomable in x, draw handles too
|
|
|
|
|
* - handles are drawn darker
|
|
|
|
|
*/
|
|
|
|
|
if (v2d->keepzoom & V2D_LOCKZOOM_X) {
|
|
|
|
|
/* draw base bar as rounded shape */
|
|
|
|
|
UI_ThemeColorShade(TH_SHADE1, dark);
|
|
|
|
|
uiSetRoundBox(15);
|
2008-12-14 08:32:21 +00:00
|
|
|
|
|
|
|
|
/* check that box is large enough for round drawing */
|
|
|
|
|
if ((vs->hor_max - vs->hor_min) < (V2D_SCROLLCAP_RAD * 2)) {
|
|
|
|
|
/* Rounded box still gets drawn at the minimum size limit
|
|
|
|
|
* This doesn't represent extreme scaling well, but looks nicer...
|
|
|
|
|
*/
|
|
|
|
|
float mid= 0.5f * (vs->hor_max + vs->hor_min);
|
|
|
|
|
|
|
|
|
|
gl_round_box_shade(GL_POLYGON,
|
|
|
|
|
mid-V2D_SCROLLCAP_RAD, hor.ymin+2,
|
|
|
|
|
mid+V2D_SCROLLCAP_RAD, hor.ymax-2,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* draw rounded box as per normal */
|
|
|
|
|
gl_round_box_shade(GL_POLYGON,
|
2008-12-12 11:41:05 +00:00
|
|
|
vs->hor_min, hor.ymin+2,
|
|
|
|
|
vs->hor_max, hor.ymax-2,
|
2008-12-14 08:32:21 +00:00
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
|
|
|
|
}
|
2008-12-12 11:41:05 +00:00
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* base bar drawn as shaded rect */
|
2008-12-02 09:43:23 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, dark);
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(0);
|
|
|
|
|
gl_round_box_shade(GL_POLYGON,
|
2008-12-14 08:32:21 +00:00
|
|
|
vs->hor_min, hor.ymin+2,
|
|
|
|
|
vs->hor_max, hor.ymax-2,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
2008-12-07 22:19:41 +00:00
|
|
|
|
|
|
|
|
/* 'minimum' handle */
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(9);
|
2008-12-14 08:32:21 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, darker);
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
gl_round_box_shade(GL_POLYGON,
|
2008-12-14 08:32:21 +00:00
|
|
|
vs->hor_min-V2D_SCROLLER_HANDLE_SIZE, hor.ymin+2,
|
|
|
|
|
vs->hor_min+V2D_SCROLLER_HANDLE_SIZE, hor.ymax-2,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLCAP_SHADE, -V2D_SCROLLCAP_SHADE);
|
2008-12-12 11:41:05 +00:00
|
|
|
|
2008-12-07 22:19:41 +00:00
|
|
|
/* maximum handle */
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(6);
|
2008-12-14 08:32:21 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, darker);
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
gl_round_box_shade(GL_POLYGON,
|
2008-12-14 08:32:21 +00:00
|
|
|
vs->hor_max-V2D_SCROLLER_HANDLE_SIZE, hor.ymin+2,
|
|
|
|
|
vs->hor_max+V2D_SCROLLER_HANDLE_SIZE, hor.ymax-2,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLCAP_SHADE, -V2D_SCROLLCAP_SHADE);
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
2008-12-01 11:37:05 +00:00
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* scale indicators */
|
|
|
|
|
// XXX will need to update the font drawing when the new stuff comes in
|
2008-12-13 09:25:47 +00:00
|
|
|
if ((v2d->scroll & V2D_SCROLL_SCALE_HORIZONTAL) && (vs->grid)) {
|
2008-12-12 11:41:05 +00:00
|
|
|
View2DGrid *grid= vs->grid;
|
2008-12-04 05:37:55 +00:00
|
|
|
float fac, dfac, fac2, val;
|
2008-12-02 09:43:23 +00:00
|
|
|
|
2008-12-04 02:01:42 +00:00
|
|
|
/* the numbers: convert grid->startx and -dx to scroll coordinates
|
|
|
|
|
* - fac is x-coordinate to draw to
|
|
|
|
|
* - dfac is gap between scale markings
|
|
|
|
|
*/
|
2008-12-13 09:25:47 +00:00
|
|
|
fac= (grid->startx - v2d->cur.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
|
2008-12-04 02:01:42 +00:00
|
|
|
fac= hor.xmin + fac*(hor.xmax - hor.xmin);
|
|
|
|
|
|
|
|
|
|
dfac= (grid->dx) / (v2d->cur.xmax - v2d->cur.xmin);
|
2008-12-04 05:37:55 +00:00
|
|
|
dfac= dfac * (hor.xmax - hor.xmin);
|
2008-12-04 02:01:42 +00:00
|
|
|
|
2008-12-04 05:37:55 +00:00
|
|
|
/* set starting value, and text color */
|
2008-12-04 02:01:42 +00:00
|
|
|
UI_ThemeColor(TH_TEXT);
|
|
|
|
|
val= grid->startx;
|
|
|
|
|
|
|
|
|
|
/* if we're clamping to whole numbers only, make sure entries won't be repeated */
|
2008-12-12 11:41:05 +00:00
|
|
|
if (vs->xclamp == V2D_GRID_CLAMP) {
|
2008-12-04 02:01:42 +00:00
|
|
|
while (grid->dx < 0.9999f) {
|
|
|
|
|
grid->dx *= 2.0f;
|
|
|
|
|
dfac *= 2.0f;
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-12-12 11:41:05 +00:00
|
|
|
if (vs->xunits == V2D_UNIT_FRAMES)
|
2008-12-04 02:01:42 +00:00
|
|
|
grid->powerx= 1;
|
|
|
|
|
|
|
|
|
|
/* draw numbers in the appropriate range */
|
|
|
|
|
if (dfac != 0.0f) {
|
|
|
|
|
for (; fac < hor.xmax; fac+=dfac, val+=grid->dx) {
|
2008-12-12 11:41:05 +00:00
|
|
|
switch (vs->xunits) {
|
2008-12-04 02:01:42 +00:00
|
|
|
case V2D_UNIT_FRAMES: /* frames (as whole numbers)*/
|
2008-12-12 11:41:05 +00:00
|
|
|
scroll_printstr(vs, fac, 3.0+(float)(hor.ymin), val, grid->powerx, V2D_UNIT_FRAMES, 'h');
|
2008-12-04 02:01:42 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case V2D_UNIT_SECONDS: /* seconds */
|
|
|
|
|
fac2= val/FPS;
|
2008-12-12 11:41:05 +00:00
|
|
|
scroll_printstr(vs, fac, 3.0+(float)(hor.ymin), fac2, grid->powerx, V2D_UNIT_SECONDS, 'h');
|
2008-12-04 02:01:42 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case V2D_UNIT_SECONDSSEQ: /* seconds with special calculations (only used for sequencer only) */
|
|
|
|
|
{
|
|
|
|
|
float time;
|
|
|
|
|
|
|
|
|
|
fac2= val/FPS;
|
|
|
|
|
time= floor(fac2);
|
|
|
|
|
fac2= fac2-time;
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
scroll_printstr(vs, fac, 3.0+(float)(hor.ymin), time+FPS*fac2/100.0, grid->powerx, V2D_UNIT_SECONDSSEQ, 'h');
|
2008-12-04 02:01:42 +00:00
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case V2D_UNIT_DEGREES: /* IPO-Editor for rotation IPO-Drivers */
|
|
|
|
|
/* HACK: although we're drawing horizontal, we make this draw as 'vertical', just to get degree signs */
|
2008-12-12 11:41:05 +00:00
|
|
|
scroll_printstr(vs, fac, 3.0+(float)(hor.ymin), val, grid->powerx, V2D_UNIT_DEGREES, 'v');
|
2008-12-04 02:01:42 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
2008-12-01 00:20:19 +00:00
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* decoration outer bevel line */
|
2008-12-01 00:20:19 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, lighter);
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & (V2D_SCROLL_BOTTOM|V2D_SCROLL_BOTTOM_O))
|
2008-12-02 09:43:23 +00:00
|
|
|
sdrawline(hor.xmin, hor.ymax, hor.xmax, hor.ymax);
|
2008-12-04 20:28:59 +00:00
|
|
|
else if (v2d->scroll & V2D_SCROLL_TOP)
|
2008-12-02 09:43:23 +00:00
|
|
|
sdrawline(hor.xmin, hor.ymin, hor.xmax, hor.ymin);
|
2008-12-01 00:20:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* vertical scrollbar */
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & V2D_SCROLL_VERTICAL) {
|
2008-12-01 00:20:19 +00:00
|
|
|
/* scroller backdrop */
|
|
|
|
|
UI_ThemeColorShade(TH_SHADE1, light);
|
|
|
|
|
glRecti(vert.xmin, vert.ymin, vert.xmax, vert.ymax);
|
|
|
|
|
|
2008-12-12 11:41:05 +00:00
|
|
|
/* scroller 'button'
|
|
|
|
|
* - if view is zoomable in y, draw handles too
|
|
|
|
|
* - handles are drawn darker
|
|
|
|
|
*/
|
|
|
|
|
if (v2d->keepzoom & V2D_LOCKZOOM_Y) {
|
|
|
|
|
/* draw base bar as rounded shape */
|
2008-12-02 09:43:23 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, dark);
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(15);
|
2008-12-14 08:32:21 +00:00
|
|
|
|
|
|
|
|
/* check that box is large enough for round drawing */
|
|
|
|
|
if ((vs->vert_max - vs->vert_min) < (V2D_SCROLLCAP_RAD * 2)) {
|
|
|
|
|
/* Rounded box still gets drawn at the minimum size limit
|
|
|
|
|
* This doesn't represent extreme scaling well, but looks nicer...
|
|
|
|
|
*/
|
|
|
|
|
float mid= 0.5f * (vs->vert_max + vs->vert_min);
|
|
|
|
|
|
|
|
|
|
gl_round_box_vertical_shade(GL_POLYGON,
|
|
|
|
|
vert.xmin+2, mid-V2D_SCROLLCAP_RAD,
|
|
|
|
|
vert.xmax-2, mid+V2D_SCROLLCAP_RAD,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
/* draw rounded box as per normal */
|
|
|
|
|
gl_round_box_vertical_shade(GL_POLYGON,
|
2008-12-12 11:41:05 +00:00
|
|
|
vert.xmin+2, vs->vert_min,
|
|
|
|
|
vert.xmax-2, vs->vert_max,
|
2008-12-14 08:32:21 +00:00
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
|
|
|
|
}
|
2008-12-12 11:41:05 +00:00
|
|
|
}
|
|
|
|
|
else {
|
2008-12-14 08:32:21 +00:00
|
|
|
/* base bar drawn as shaded rect */
|
2008-12-12 11:41:05 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, dark);
|
2008-12-14 08:32:21 +00:00
|
|
|
uiSetRoundBox(0);
|
|
|
|
|
gl_round_box_vertical_shade(GL_POLYGON,
|
|
|
|
|
vert.xmin+2, vs->vert_min,
|
|
|
|
|
vert.xmax-2, vs->vert_max,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLBAR_SHADE, -V2D_SCROLLBAR_SHADE);
|
2008-12-07 22:19:41 +00:00
|
|
|
|
|
|
|
|
/* 'minimum' handle */
|
2008-12-14 08:32:21 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, darker);
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(12);
|
2008-12-14 08:32:21 +00:00
|
|
|
|
|
|
|
|
gl_round_box_vertical_shade(GL_POLYGON,
|
|
|
|
|
vert.xmin+2, vs->vert_min-V2D_SCROLLER_HANDLE_SIZE,
|
|
|
|
|
vert.xmax-2, vs->vert_min+V2D_SCROLLER_HANDLE_SIZE,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLCAP_SHADE, -V2D_SCROLLCAP_SHADE);
|
2008-12-12 11:41:05 +00:00
|
|
|
|
2008-12-07 22:19:41 +00:00
|
|
|
/* maximum handle */
|
2008-12-14 08:32:21 +00:00
|
|
|
UI_ThemeColorShade(TH_SHADE1, darker);
|
2008-12-12 11:41:05 +00:00
|
|
|
uiSetRoundBox(3);
|
2008-12-14 08:32:21 +00:00
|
|
|
|
|
|
|
|
gl_round_box_vertical_shade(GL_POLYGON,
|
|
|
|
|
vert.xmin+2, vs->vert_max-V2D_SCROLLER_HANDLE_SIZE,
|
|
|
|
|
vert.xmax-2, vs->vert_max+V2D_SCROLLER_HANDLE_SIZE,
|
|
|
|
|
V2D_SCROLLCAP_RAD, V2D_SCROLLCAP_SHADE, -V2D_SCROLLCAP_SHADE);
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* scale indiators */
|
|
|
|
|
// XXX will need to update the font drawing when the new stuff comes in
|
2008-12-13 09:25:47 +00:00
|
|
|
if ((v2d->scroll & V2D_SCROLL_SCALE_VERTICAL) && (vs->grid)) {
|
2008-12-12 11:41:05 +00:00
|
|
|
View2DGrid *grid= vs->grid;
|
2008-12-04 05:37:55 +00:00
|
|
|
float fac, dfac, val;
|
|
|
|
|
|
|
|
|
|
/* the numbers: convert grid->starty and dy to scroll coordinates
|
|
|
|
|
* - fac is y-coordinate to draw to
|
|
|
|
|
* - dfac is gap between scale markings
|
|
|
|
|
* - these involve a correction for horizontal scrollbar
|
|
|
|
|
* NOTE: it's assumed that that scrollbar is there if this is involved!
|
|
|
|
|
*/
|
|
|
|
|
fac= (grid->starty- v2d->cur.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
|
2008-12-04 20:28:59 +00:00
|
|
|
fac= (vert.ymin + V2D_SCROLL_HEIGHT) + fac*(vert.ymax - vert.ymin - V2D_SCROLL_HEIGHT);
|
2008-12-02 09:43:23 +00:00
|
|
|
|
2008-12-04 05:37:55 +00:00
|
|
|
dfac= (grid->dy) / (v2d->cur.ymax - v2d->cur.ymin);
|
2008-12-04 20:28:59 +00:00
|
|
|
dfac= dfac * (vert.ymax - vert.ymin - V2D_SCROLL_HEIGHT);
|
2008-12-04 05:37:55 +00:00
|
|
|
|
|
|
|
|
/* set starting value, and text color */
|
|
|
|
|
UI_ThemeColor(TH_TEXT);
|
|
|
|
|
val= grid->starty;
|
|
|
|
|
|
|
|
|
|
/* if vertical clamping (to whole numbers) is used (i.e. in Sequencer), apply correction */
|
|
|
|
|
// XXX only relevant to Sequencer, so need to review this when we port that code
|
2008-12-12 11:41:05 +00:00
|
|
|
if (vs->yclamp == V2D_GRID_CLAMP)
|
2008-12-04 05:37:55 +00:00
|
|
|
fac += 0.5f * dfac;
|
|
|
|
|
|
|
|
|
|
/* draw vertical steps */
|
|
|
|
|
for (; fac < vert.ymax; fac+= dfac, val += grid->dy) {
|
2008-12-12 11:41:05 +00:00
|
|
|
scroll_printstr(vs, (float)(vert.xmax)-14.0, fac, val, grid->powery, vs->yunits, 'v');
|
2008-12-04 05:37:55 +00:00
|
|
|
}
|
2008-12-02 09:43:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* decoration outer bevel line */
|
|
|
|
|
UI_ThemeColorShade(TH_SHADE1, lighter);
|
2008-12-04 20:28:59 +00:00
|
|
|
if (v2d->scroll & V2D_SCROLL_RIGHT)
|
2008-12-02 09:43:23 +00:00
|
|
|
sdrawline(vert.xmin, vert.ymin, vert.xmin, vert.ymax);
|
2008-12-04 20:28:59 +00:00
|
|
|
else if (v2d->scroll & V2D_SCROLL_LEFT)
|
2008-12-01 00:20:19 +00:00
|
|
|
sdrawline(vert.xmax, vert.ymin, vert.xmax, vert.ymax);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* free temporary memory used for drawing scrollers */
|
2008-12-07 06:21:06 +00:00
|
|
|
void UI_view2d_scrollers_free(View2DScrollers *scrollers)
|
2008-12-01 00:20:19 +00:00
|
|
|
{
|
2008-12-04 02:01:42 +00:00
|
|
|
/* need to free grid as well... */
|
|
|
|
|
if (scrollers->grid) MEM_freeN(scrollers->grid);
|
2008-12-01 00:20:19 +00:00
|
|
|
MEM_freeN(scrollers);
|
|
|
|
|
}
|
2008-11-30 06:15:33 +00:00
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* *********************************************************************** */
|
|
|
|
|
/* Coordinate Conversions */
|
2008-10-08 18:07:56 +00:00
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Convert from screen/region space to 2d-View space
|
|
|
|
|
*
|
|
|
|
|
* - x,y = coordinates to convert
|
|
|
|
|
* - viewx,viewy = resultant coordinates
|
|
|
|
|
*/
|
2008-12-03 13:14:01 +00:00
|
|
|
void UI_view2d_region_to_view(View2D *v2d, int x, int y, float *viewx, float *viewy)
|
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
|
|
|
{
|
|
|
|
|
float div, ofs;
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
if (viewx) {
|
|
|
|
|
div= v2d->mask.xmax - v2d->mask.xmin;
|
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
|
|
|
ofs= v2d->mask.xmin;
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-03 13:14:01 +00:00
|
|
|
*viewx= v2d->cur.xmin + (v2d->cur.xmax-v2d->cur.xmin) * ((float)x - ofs) / div;
|
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
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
if (viewy) {
|
|
|
|
|
div= v2d->mask.ymax - v2d->mask.ymin;
|
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
|
|
|
ofs= v2d->mask.ymin;
|
2008-11-28 04:01:35 +00:00
|
|
|
|
2008-12-03 13:14:01 +00:00
|
|
|
*viewy= v2d->cur.ymin + (v2d->cur.ymax - v2d->cur.ymin) * ((float)y - ofs) / div;
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Convert from 2d-View space to screen/region space
|
|
|
|
|
* - Coordinates are clamped to lie within bounds of region
|
|
|
|
|
*
|
|
|
|
|
* - x,y = coordinates to convert
|
|
|
|
|
* - regionx,regiony = resultant coordinates
|
|
|
|
|
*/
|
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
|
|
|
void UI_view2d_view_to_region(View2D *v2d, float x, float y, short *regionx, short *regiony)
|
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
|
|
|
{
|
2008-11-28 04:01:35 +00:00
|
|
|
/* set initial value in case coordinate lies outside of bounds */
|
|
|
|
|
if (regionx)
|
|
|
|
|
*regionx= V2D_IS_CLIPPED;
|
|
|
|
|
if (regiony)
|
|
|
|
|
*regiony= V2D_IS_CLIPPED;
|
|
|
|
|
|
|
|
|
|
/* express given coordinates as proportional values */
|
|
|
|
|
x= (x - v2d->cur.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
|
2008-12-03 17:11:50 +00:00
|
|
|
y= (y - v2d->cur.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
|
2008-11-28 04:01:35 +00:00
|
|
|
|
|
|
|
|
/* check if values are within bounds */
|
|
|
|
|
if ((x>=0.0f) && (x<=1.0f) && (y>=0.0f) && (y<=1.0f)) {
|
|
|
|
|
if (regionx)
|
|
|
|
|
*regionx= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
|
|
|
|
|
if (regiony)
|
|
|
|
|
*regiony= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Convert from 2d-view space to screen/region space
|
|
|
|
|
* - Coordinates are NOT clamped to lie within bounds of region
|
|
|
|
|
*
|
|
|
|
|
* - x,y = coordinates to convert
|
|
|
|
|
* - regionx,regiony = resultant coordinates
|
|
|
|
|
*/
|
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
|
|
|
void UI_view2d_to_region_no_clip(View2D *v2d, float x, float y, short *regionx, short *regiony)
|
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
|
|
|
{
|
2008-11-28 04:01:35 +00:00
|
|
|
/* step 1: express given coordinates as proportional values */
|
|
|
|
|
x= (x - v2d->cur.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
|
2008-12-03 17:11:50 +00:00
|
|
|
y= (y - v2d->cur.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
|
2008-11-28 04:01:35 +00:00
|
|
|
|
|
|
|
|
/* step 2: convert proportional distances to screen coordinates */
|
|
|
|
|
x= v2d->mask.xmin + x*(v2d->mask.xmax - v2d->mask.xmin);
|
|
|
|
|
y= v2d->mask.ymin + y*(v2d->mask.ymax - v2d->mask.ymin);
|
|
|
|
|
|
|
|
|
|
/* although we don't clamp to lie within region bounds, we must avoid exceeding size of shorts */
|
|
|
|
|
if (regionx) {
|
|
|
|
|
if (x < -32760) *regionx= -32760;
|
|
|
|
|
else if(x > 32760) *regionx= 32760;
|
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
|
|
|
else *regionx= x;
|
|
|
|
|
}
|
2008-11-28 04:01:35 +00:00
|
|
|
if (regiony) {
|
|
|
|
|
if (y < -32760) *regiony= -32760;
|
|
|
|
|
else if(y > 32760) *regiony= 32760;
|
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
|
|
|
else *regiony= y;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* *********************************************************************** */
|
|
|
|
|
/* Utilities */
|
|
|
|
|
|
2008-12-02 09:43:23 +00:00
|
|
|
/* View2D data by default resides in region, so get from region stored in context */
|
|
|
|
|
View2D *UI_view2d_fromcontext(const bContext *C)
|
|
|
|
|
{
|
|
|
|
|
if (C->area == NULL) return NULL;
|
|
|
|
|
if (C->region == NULL) return NULL;
|
|
|
|
|
return &(C->region->v2d);
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-11 15:38:16 +00:00
|
|
|
/* same as above, but it returns regionwindow. Utility for pulldowns or buttons */
|
|
|
|
|
View2D *UI_view2d_fromcontext_rwin(const bContext *C)
|
|
|
|
|
{
|
|
|
|
|
if (C->area == NULL) return NULL;
|
|
|
|
|
if (C->region == NULL) return NULL;
|
|
|
|
|
if (C->region->regiontype!=RGN_TYPE_WINDOW) {
|
|
|
|
|
ARegion *ar= C->area->regionbase.first;
|
|
|
|
|
for(; ar; ar= ar->next)
|
|
|
|
|
if(ar->regiontype==RGN_TYPE_WINDOW)
|
|
|
|
|
return &(ar->v2d);
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
return &(C->region->v2d);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2008-11-28 04:01:35 +00:00
|
|
|
/* Calculate the scale per-axis of the drawing-area
|
|
|
|
|
* - Is used to inverse correct drawing of icons, etc. that need to follow view
|
|
|
|
|
* but not be affected by scale
|
|
|
|
|
*
|
|
|
|
|
* - x,y = scale on each axis
|
|
|
|
|
*/
|
2008-11-24 18:59:59 +00:00
|
|
|
void UI_view2d_getscale(View2D *v2d, float *x, float *y)
|
|
|
|
|
{
|
2008-11-28 04:01:35 +00:00
|
|
|
if (x) *x = (v2d->mask.xmax - v2d->mask.xmin) / (v2d->cur.xmax - v2d->cur.xmin);
|
|
|
|
|
if (y) *y = (v2d->mask.ymax - v2d->mask.ymin) / (v2d->cur.ymax - v2d->cur.ymin);
|
2008-11-24 18:59:59 +00:00
|
|
|
}
|
