archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Step 3 for the initial commits for 2.5: removing src/ and python,

Browse Source 
adding new windowmanager module, and the first bits of new editors
module.
This commit is contained in:
Ton Roosendaal
2007-12-24 18:27:28 +00:00
parent 8a07e665c2
commit a1c8543f2a
481 changed files with 13724 additions and 366053 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
source/blender/windowmanager/Makefile Normal file
View File

@@ -0,0 +1,34 @@
#
# $Id: Makefile
#
# ***** 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) Blender Foundation.
# All rights reserved.
#
# The Original Code is: all of this file.
#
# Contributor(s): none yet.
#
# ***** END GPL LICENSE BLOCK *****
#
# Bounces make to subdirectories.
SOURCEDIR = source/blender/windowmanager
DIRS = intern
include nan_subdirs.mk

77
source/blender/windowmanager/WM_api.h Normal file
View File

@@ -0,0 +1,77 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_API_H
#define WM_API_H
/* dna-savable wmStructs here */
#include "DNA_windowmanager_types.h"
struct bContext;
struct wmEvent;
struct wmEventHandler;
/* general API */
void WM_setprefsize (int stax, int stay, int sizx, int sizy);
void WM_init (struct bContext *C);
void WM_exit (struct bContext *C);
void WM_main (struct bContext *C);
/* files */
int WM_read_homefile (struct bContext *C, int from_memory);
int WM_write_homefile (struct bContext *C, struct wmOperator *op);
void WM_read_file (struct bContext *C, char *name);
void WM_write_file (struct bContext *C, char *target);
void WM_read_autosavefile(struct bContext *C);
void WM_write_autosave (struct bContext *C);
/* mouse cursors */
void WM_init_cursor_data (void);
void WM_set_cursor (struct bContext *C, int curs);
/* keymap and handlers */
void WM_keymap_set_item (ListBase *lb, char *idname, short type,
short val, int modifier, short keymodifier);
void WM_keymap_verify_item(ListBase *lb, char *idname, short type,
short val, int modifier, short keymodifier);
struct wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers);
struct wmEventHandler *WM_event_add_modal_keymap_handler(ListBase *keymap, ListBase *handlers, wmOperator *op);
/* operator api, default callbacks */
/* confirm menu + exec */
int WM_operator_confirm (struct bContext *C, struct wmOperator *op, struct wmEvent *event);
/* context checks */
int WM_operator_winactive (struct bContext *C);
/* operator api */
wmOperatorType *WM_operatortype_find(const char *idname);
void WM_operator_register(wmWindowManager *wm, wmOperator *ot);
#endif /* WM_API_H */

70
source/blender/windowmanager/WM_types.h Normal file
View File

@@ -0,0 +1,70 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_TYPES_H
#define WM_TYPES_H
/* exported types for WM */
/* ************** wmOperatorType ************************ */
/* flag */
#define OPTYPE_REGISTER 1
/* ************** wmKeyMap ************************ */
/* modifier */
#define KM_SHIFT 1
#define KM_CTRL 2
#define KM_ALT 4
#define KM_OSKEY 8
/* means modifier should be pressed 2nd */
#define KM_SHIFT2 16
#define KM_CTRL2 32
#define KM_ALT2 64
#define KM_OSKEY2 128
/* val */
#define KM_PRESS 2
#define KM_RELEASE 1
/* ************** custom wmEvent data ************** */
#define DEV_STYLUS 1
#define DEV_ERASER 2
typedef struct wmTabletData {
int Active; /* 0=None, 1=Stylus, 2=Eraser */
float Pressure; /* range 0.0 (not touching) to 1.0 (full pressure) */
float Xtilt; /* range 0.0 (upright) to 1.0 (tilted fully against the tablet surface) */
float Ytilt; /* as above */
} wmTabletData;
#endif /* WM_TYPES_H */

98
source/blender/windowmanager/intern/Makefile Normal file
View File

@@ -0,0 +1,98 @@
#
# $Id: Makefile 11904 2007-08-31 16:16:33Z sirdude $
#
# ***** 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) 2001-2002 by NaN Holding BV.
# All rights reserved.
#
# The Original Code is: all of this file.
#
# Contributor(s): none yet.
#
# ***** END GPL LICENSE BLOCK *****
#
#
LIBNAME = windowmanager
DIR = $(OCGDIR)/blender/$(LIBNAME)
include nan_compile.mk
CFLAGS += $(LEVEL_1_C_WARNINGS)
# OpenGL and Python
CPPFLAGS += $(OGL_CPPFLAGS)
CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION)
# PreProcessor stuff
CPPFLAGS += -I$(NAN_GHOST)/include
CPPFLAGS += -I$(NAN_BMFONT)/include
CPPFLAGS += -I$(NAN_ELBEEM)/include
CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include $(NAN_SDLCFLAGS)
# modules
CPPFLAGS += -I../../editors/include
CPPFLAGS += -I../../python
CPPFLAGS += -I../../makesdna
CPPFLAGS += -I../../blenlib
CPPFLAGS += -I../../blenkernel
CPPFLAGS += -I../../nodes
CPPFLAGS += -I../../imbuf
CPPFLAGS += -I../../blenloader
CPPFLAGS += -I../../render/extern/include
CPPFLAGS += -I../../ftfont
CPPFLAGS += -I../../radiosity/extern/include
CPPFLAGS += -I../../../kernel/gen_system
# path to the guarded memory allocator
CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
CPPFLAGS += -I$(NAN_MEMUTIL)/include
ifeq ($(INTERNATIONAL), true)
CPPFLAGS += -DINTERNATIONAL
endif
ifeq ($(WITH_VERSE), true)
CPPFLAGS += -DWITH_VERSE
CPPFLAGS += -I$(NAN_VERSE)/include
# print some other debug information
ifeq ($(VERSE_DEBUG_PRINT), true)
CPPFLAGS += -DVERSE_DEBUG_PRINT
endif
endif
ifeq ($(WITH_QUICKTIME),true)
CPPFLAGS += -I../quicktime
CPPFLAGS += -DWITH_QUICKTIME
endif
ifeq ($(OS),linux)
ifeq ($(CPU),alpha)
CPPFLAGS += -I$(NAN_MESA)/include
endif
ifeq ($(CPU),i386)
CPPFLAGS += -I$(NAN_MESA)/include
endif
ifeq ($(CPU),powerpc)
CPPFLAGS += -I/usr/src/MesaCVS/include
endif
endif
# path to our own headerfiles
CPPFLAGS += -I..

164
source/blender/windowmanager/intern/wm.c Normal file
View File

@@ -0,0 +1,164 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "WM_api.h"
#include "WM_types.h"
#include "wm_window.h"
#include "wm_event_system.h"
#include "wm_event_types.h"
/* ****************************************************** */
#define MAX_OP_REGISTERED 32
/* all operations get registered in the windowmanager here */
/* called on event handling by event_system.c */
void WM_operator_register(wmWindowManager *wm, wmOperator *op)
{
wmOperator *opc= MEM_mallocN(sizeof(wmOperator), "operator registry");
int tot;
*opc= *op;
BLI_addtail(&wm->operators, opc);
tot= BLI_countlist(&wm->operators);
while(tot>MAX_OP_REGISTERED) {
wmOperator *opt= wm->operators.first;
BLI_remlink(&wm->operators, opt);
MEM_freeN(opt);
tot--;
}
}
/* **************** standard keymap for WM ********************** */
/* default keymap for windows and screens, only call once per WM */
static void wm_window_keymap(wmWindowManager *wm)
{
/* note, this doesn't replace existing keymap items */
WM_keymap_verify_item(&wm->windowkeymap, "WM_OT_window_duplicate", AKEY, KM_PRESS, 0, 0);
WM_keymap_verify_item(&wm->windowkeymap, "WM_OT_save_homefile", UKEY, KM_PRESS, KM_CTRL, 0);
}
/* ****************************************** */
void wm_check(bContext *C)
{
/* wm context */
if(C->wm==NULL) C->wm= G.main->wm.first;
if(C->wm==NULL) return;
if(C->wm->windows.first==NULL) return;
/* case: no open windows at all, for old file reads */
wm_window_add_ghostwindows(C->wm);
if(C->window==NULL) C->window= C->wm->windrawable;
if(C->wm->initialized==0) {
wm_window_keymap(C->wm);
C->wm->initialized= 1;
}
}
/* on startup, it adds all data, for matching */
void wm_add_default(bContext *C)
{
wmWindowManager *wm= alloc_libblock(&G.main->wm, ID_WM, "WinMan");
wmWindow *win;
C->wm= wm;
win= wm_window_new(C, C->screen);
wm->windrawable= win;
C->window= win;
}
/* context is allowed to be NULL, do net free wm itself (library.c) */
void wm_close_and_free(bContext *C, wmWindowManager *wm)
{
wmWindow *win;
while((win= wm->windows.first)) {
BLI_remlink(&wm->windows, win);
wm_window_free(C, win);
}
BLI_freelistN(&wm->operators);
BLI_freelistN(&wm->windowkeymap);
BLI_freelistN(&wm->screenkeymap);
if(C && C->wm==wm) C->wm= NULL;
}
void wm_close_and_free_all(bContext *C, ListBase *wmlist)
{
wmWindowManager *wm;
while((wm=wmlist->first)) {
wm_close_and_free(C, wm);
BLI_remlink(wmlist, wm);
MEM_freeN(wm);
}
}
void WM_main(bContext *C)
{
while(1) {
/* get events from ghost, handle window events, add to window queues */
/* WM_init has assigned to ghost the bContext already */
wm_window_process_events(1);
/* per window, all events to the window, screen, area and region handlers */
wm_event_do_handlers(C);
}
}
/* While (local_event) {
Update controller stack if active changed ()
Match event to an action()
Process_event()
Do_notifications()
Do_draw_updates()
}
*/

138
source/blender/windowmanager/intern/wm_apple.c Normal file
View File

@@ -0,0 +1,138 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifdef __APPLE__
#include "BKE_global.h"
#include "WM_api.h"
#include <OpenGL/OpenGL.h>
#define __CARBONSOUND__
/* XXX BIG WARNING: carbon.h can not be included in blender code, it conflicts with struct ID */
#define ID ID_
#include <Carbon/Carbon.h>
/* To avoid killing small end comps, we want to allow
blender to start maximised if all the followings are true :
- Renderer is OpenGL capable
- Hardware acceleration
- VRAM > 16 Mo
We will bail out if VRAM is less than 8Mo
*/
/* bad global, used in wm_window.c to open windows */
int macPrefState = 0;
static int checkAppleVideoCard(void)
{
CGLRendererInfoObj rend;
long theErr;
unsigned long display_mask;
long nrend;
int j;
long value;
long maxvram = 0; /* we get always more than 1 renderer, check one, at least, has 8 Mo */
display_mask = CGDisplayIDToOpenGLDisplayMask (CGMainDisplayID() );
theErr = CGLQueryRendererInfo( display_mask, &rend, &nrend);
if (theErr == 0) {
theErr = CGLDescribeRenderer (rend, 0, kCGLRPRendererCount, &nrend);
if (theErr == 0) {
for (j = 0; j < nrend; j++) {
theErr = CGLDescribeRenderer (rend, j, kCGLRPVideoMemory, &value);
if (value > maxvram)
maxvram = value;
if ((theErr == 0) && (value >= 20000000)) {
theErr = CGLDescribeRenderer (rend, j, kCGLRPAccelerated, &value);
if ((theErr == 0) && (value != 0)) {
theErr = CGLDescribeRenderer (rend, j, kCGLRPCompliant, &value);
if ((theErr == 0) && (value != 0)) {
/*fprintf(stderr,"make it big\n");*/
CGLDestroyRendererInfo (rend);
macPrefState = 8;
return 1;
}
}
}
}
}
}
if (maxvram < 7500000 ) { /* put a standard alert and quit*/
SInt16 junkHit;
char inError[] = "* Not enough VRAM ";
char inText[] = "* blender needs at least 8Mb ";
inError[0] = 16;
inText[0] = 28;
fprintf(stderr, " vram is %li . not enough, aborting\n", maxvram);
StandardAlert ( kAlertStopAlert, (ConstStr255Param) &inError, (ConstStr255Param)&inText,NULL,&junkHit);
abort();
}
CGLDestroyRendererInfo (rend);
return 0;
}
static void getMacAvailableBounds(short *top, short *left, short *bottom, short *right)
{
Rect outAvailableRect;
GetAvailableWindowPositioningBounds ( GetMainDevice(), &outAvailableRect);
*top = outAvailableRect.top;
*left = outAvailableRect.left;
*bottom = outAvailableRect.bottom;
*right = outAvailableRect.right;
}
void wm_set_apple_prefsize(int scr_x, int scr_y)
{
/* first let us check if we are hardware accelerated and with VRAM > 16 Mo */
if (checkAppleVideoCard()) {
short top, left, bottom, right;
getMacAvailableBounds(&top, &left, &bottom, &right);
WM_setprefsize(left +10,scr_y - bottom +10,right-left -20,bottom - 64);
G.windowstate= 0;
} else {
/* 40 + 684 + (headers) 22 + 22 = 768, the powerbook screen height */
WM_setprefsize(120, 40, 850, 684);
G.windowstate= 0;
}
}
#endif /* __APPLE__ */

879
source/blender/windowmanager/intern/wm_cursors.c Normal file
View File

@@ -0,0 +1,879 @@
/**
* $Id: wm_cursors.c
*
* ***** 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) 2005-2007 Blender Foundation
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Matt Ebb
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <stdio.h>
#include "GHOST_C-api.h"
#include "DNA_listBase.h"
#include "DNA_userdef_types.h"
#include "BKE_global.h"
#include "WM_api.h"
#include "wm_cursors.h"
/* XXX this still is mess from old code */
/* Some simple ghost <-> blender conversions */
static GHOST_TStandardCursor convert_cursor(int curs)
{
switch(curs) {
default:
case CURSOR_STD: return GHOST_kStandardCursorDefault;
case CURSOR_FACESEL: return GHOST_kStandardCursorRightArrow;
case CURSOR_WAIT: return GHOST_kStandardCursorWait;
case CURSOR_EDIT: return GHOST_kStandardCursorCrosshair;
case CURSOR_HELP: return GHOST_kStandardCursorHelp;
case CURSOR_X_MOVE: return GHOST_kStandardCursorLeftRight;
case CURSOR_Y_MOVE: return GHOST_kStandardCursorUpDown;
case CURSOR_PENCIL: return GHOST_kStandardCursorPencil;
}
}
void window_set_custom_cursor(wmWindow *win, unsigned char mask[16][2],
unsigned char bitmap[16][2], int hotx, int hoty)
{
GHOST_SetCustomCursorShape(win->ghostwin, bitmap, mask, hotx, hoty);
}
static void window_set_custom_cursor_ex(wmWindow *win, BCursor *cursor, int useBig)
{
if (useBig) {
GHOST_SetCustomCursorShapeEx(win->ghostwin,
(GHOST_TUns8 *)cursor->big_bm, (GHOST_TUns8 *)cursor->big_mask,
cursor->big_sizex,cursor->big_sizey,
cursor->big_hotx,cursor->big_hoty,
cursor->fg_color, cursor->bg_color);
} else {
GHOST_SetCustomCursorShapeEx(win->ghostwin,
(GHOST_TUns8 *)cursor->small_bm, (GHOST_TUns8 *)cursor->small_mask,
cursor->small_sizex,cursor->small_sizey,
cursor->small_hotx,cursor->small_hoty,
cursor->fg_color, cursor->bg_color);
}
}
/* Cursor Globals */
static BCursor *BlenderCursor[BC_NUMCURSORS]; /*Points to static BCursor Structs */
static short CurrentCursor=-1, LastCursor=-1;
void WM_set_cursor(bContext *C, int curs)
{
wmWindow *win= C->window;
if (win==NULL) return; /* Can't set custom cursor before Window init */
win->cursor= curs;
if (curs==CURSOR_NONE) {
GHOST_SetCursorVisibility(win->ghostwin, 0);
return;
}
GHOST_SetCursorVisibility(win->ghostwin, 1);
/* detect if we use system cursor or Blender cursor */
if(curs>=BC_GHOST_CURSORS) {
GHOST_SetCursorShape(win->ghostwin, convert_cursor(curs));
return;
}
if ((curs<LASTCURSOR)||(curs>=BC_NUMCURSORS)) return;
LastCursor=CurrentCursor;
CurrentCursor=curs;
if (curs==LASTCURSOR) curs=LastCursor;
if (curs==SYSCURSOR) { /* System default Cursor */
GHOST_SetCursorShape(win->ghostwin, convert_cursor(CURSOR_STD));
}
else if ( (U.curssize==0) || (BlenderCursor[curs]->big_bm == NULL) ) {
window_set_custom_cursor_ex(win, BlenderCursor[curs], 0);
}
else {
window_set_custom_cursor_ex(win, BlenderCursor[curs], 1);
}
}
/* ******************************************************************
Custom Cursor Description:
Each bit represents a pixel, so 1 byte = 8 pixels,
the bytes go Left to Right. Top to bottom
the bits in a byte go right to left
(ie; 0x01, 0x80 represents a line of 16 pix with the first and last pix set.)
A 0 in the bitmap = bg_color, a 1 fg_color
a 0 in the mask = transparent pix.
Until 32x32 cursors are supported on all platforms, the size of the
small cursors MUST be 16x16.
Large cursors have a MAXSIZE of 32x32.
Other than that, the specified size of the cursors is just a guideline,
However, the char array that defines the BM and MASK must be byte aligned.
ie a 17x17 cursor needs 3 bytes (cols) * 17 bytes (rows)
(3 bytes = 17 bits rounded up to nearest whole byte). Pad extra bits
in mask with 0's.
Setting big_bm=NULL disables the large version of the cursor.
*******************************************************************
There is a nice Python GUI utility that can be used for drawing cursors in
this format in the Blender source distribution, in
blender/source/tools/MakeCursor.py . Start it with $ python MakeCursor.py
It will copy its output to the console when you press 'Do it'.
*/
/* Because defining a cursor mixes declarations and executable code
each cursor needs it's own scoping block or it would be split up
over several hundred lines of code. To enforce/document this better
I define 2 pretty braindead macros so it's obvious what the extra "[]"
are for */
#define BEGIN_CURSOR_BLOCK {
#define END_CURSOR_BLOCK }
void WM_init_cursor_data(void){
/********************** NW_ARROW Cursor **************************/
BEGIN_CURSOR_BLOCK
static char nw_sbm[]={
0x03, 0x00, 0x05, 0x00, 0x09, 0x00, 0x11, 0x00,
0x21, 0x00, 0x41, 0x00, 0x81, 0x00, 0x01, 0x01,
0x01, 0x02, 0xc1, 0x03, 0x49, 0x00, 0x8d, 0x00,
0x8b, 0x00, 0x10, 0x01, 0x90, 0x01, 0x60, 0x00,
};
static char nw_smsk[]={
0x03, 0x00, 0x07, 0x00, 0x0f, 0x00, 0x1f, 0x00,
0x3f, 0x00, 0x7f, 0x00, 0xff, 0x00, 0xff, 0x01,
0xff, 0x03, 0xff, 0x03, 0x7f, 0x00, 0xff, 0x00,
0xfb, 0x00, 0xf0, 0x01, 0xf0, 0x01, 0x60, 0x00,
};
static BCursor NWArrowCursor = {
/*small*/
nw_sbm, nw_smsk,
16, 16,
6, 7,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_NW_ARROWCURSOR]=&NWArrowCursor;
END_CURSOR_BLOCK
///********************** NS_ARROW Cursor *************************/
BEGIN_CURSOR_BLOCK
static char ns_sbm[]={
0x40, 0x01, 0x20, 0x02, 0x10, 0x04, 0x08, 0x08,
0x04, 0x10, 0x3c, 0x1e, 0x20, 0x02, 0x20, 0x02,
0x20, 0x02, 0x20, 0x02, 0x3c, 0x1e, 0x04, 0x10,
0x08, 0x08, 0x10, 0x04, 0x20, 0x02, 0x40, 0x01
};
static char ns_smsk[]={
0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0f,
0xfc, 0x1f, 0xfc, 0x1f, 0xe0, 0x03, 0xe0, 0x03,
0xe0, 0x03, 0xe0, 0x03, 0xfc, 0x1f, 0xfc, 0x1f,
0xf8, 0x0f, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01
};
static BCursor NSArrowCursor = {
/*small*/
ns_sbm, ns_smsk,
16, 16,
6, 7,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_NS_ARROWCURSOR]=&NSArrowCursor;
END_CURSOR_BLOCK
/********************** EW_ARROW Cursor *************************/
BEGIN_CURSOR_BLOCK
static char ew_sbm[]={
0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c,
0x2c, 0x34, 0xe6, 0x67, 0x03, 0xc0, 0x01, 0x80,
0x03, 0xc0, 0xe6, 0x67, 0x2c, 0x34, 0x38, 0x1c,
0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static char ew_smsk[]={
0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x38, 0x1c,
0x3c, 0x3c, 0xfe, 0x7f, 0xff, 0xff, 0x3f, 0xfc,
0xff, 0xff, 0xfe, 0x7f, 0x3c, 0x3c, 0x38, 0x1c,
0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static BCursor EWArrowCursor = {
/*small*/
ew_sbm, ew_smsk,
16, 16,
7, 6,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_EW_ARROWCURSOR]=&EWArrowCursor;
END_CURSOR_BLOCK
/********************** Wait Cursor *****************************/
BEGIN_CURSOR_BLOCK
static char wait_sbm[]={
0xfe, 0x7f, 0x02, 0x40, 0x02, 0x40, 0x84, 0x21,
0xc8, 0x13, 0xd0, 0x0b, 0xa0, 0x04, 0x20, 0x05,
0xa0, 0x04, 0x10, 0x09, 0x88, 0x11, 0xc4, 0x23,
0xe2, 0x47, 0xfa, 0x5f, 0x02, 0x40, 0xfe, 0x7f,
};
static char wait_smsk[]={
0xfe, 0x7f, 0xfe, 0x7f, 0x06, 0x60, 0x8c, 0x31,
0xd8, 0x1b, 0xf0, 0x0f, 0xe0, 0x06, 0x60, 0x07,
0xe0, 0x06, 0x30, 0x0d, 0x98, 0x19, 0xcc, 0x33,
0xe6, 0x67, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f,
};
static char wait_lbm[]={
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x30,
0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x18,
0x18, 0xc0, 0x03, 0x0c, 0x30, 0x20, 0x07, 0x06,
0x60, 0xf0, 0x0f, 0x03, 0xc0, 0xd0, 0x8d, 0x01,
0x80, 0x79, 0xcf, 0x00, 0x00, 0xf3, 0x67, 0x00,
0x00, 0x66, 0x37, 0x00, 0x00, 0x8c, 0x33, 0x00,
0x00, 0x0c, 0x32, 0x00, 0x00, 0xcc, 0x33, 0x00,
0x00, 0x8c, 0x30, 0x00, 0x00, 0x46, 0x61, 0x00,
0x00, 0x03, 0xc3, 0x00, 0x80, 0x01, 0x83, 0x01,
0xc0, 0xc0, 0x03, 0x03, 0x60, 0xa0, 0x05, 0x06,
0x30, 0xf0, 0x0f, 0x0c, 0x18, 0xf8, 0x1d, 0x18,
0x0c, 0x5c, 0x3f, 0x30, 0x0c, 0xff, 0x5f, 0x30,
0x0c, 0xf7, 0xfe, 0x31, 0xcc, 0xfb, 0x9f, 0x33,
0x0c, 0x00, 0x00, 0x30, 0x0c, 0x00, 0x00, 0x30,
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
};
static char wait_lmsk[]={
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
0x3c, 0x00, 0x00, 0x3c, 0x3c, 0x00, 0x00, 0x1e,
0x78, 0xc0, 0x03, 0x0f, 0xf0, 0xa0, 0x87, 0x07,
0xe0, 0xf1, 0xcf, 0x03, 0xc0, 0xf3, 0xef, 0x01,
0x80, 0xff, 0xff, 0x00, 0x00, 0xff, 0x7f, 0x00,
0x00, 0xfe, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00,
0x00, 0x3c, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00,
0x00, 0xbc, 0x3c, 0x00, 0x00, 0xde, 0x79, 0x00,
0x00, 0x0f, 0xf3, 0x00, 0x80, 0x07, 0xe3, 0x01,
0xc0, 0xc3, 0xc3, 0x03, 0xe0, 0xe1, 0x87, 0x07,
0xf0, 0xf0, 0x0f, 0x0f, 0x78, 0xf8, 0x1f, 0x1e,
0x3c, 0x7c, 0x3f, 0x3c, 0x3c, 0xff, 0x7f, 0x3c,
0xbc, 0xff, 0xff, 0x3d, 0xfc, 0xfb, 0xbf, 0x3f,
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
0xfc, 0xff, 0xff, 0x3f, 0xfc, 0xff, 0xff, 0x3f,
};
static BCursor WaitCursor = {
/*small*/
wait_sbm, wait_smsk,
16, 16,
7, 7,
/*big*/
wait_lbm, wait_lmsk,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_WAITCURSOR]=&WaitCursor;
END_CURSOR_BLOCK
/********************** Cross Cursor ***************************/
BEGIN_CURSOR_BLOCK
static char cross_sbm[]={
0x00, 0x00, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x7e, 0x7e,
0x7e, 0x7e, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x00, 0x00,
};
static char cross_smsk[]={
0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
0x80, 0x01, 0x80, 0x01, 0xc0, 0x03, 0x7f, 0xfe,
0x7f, 0xfe, 0xc0, 0x03, 0x80, 0x01, 0x80, 0x01,
0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
};
static char cross_lbm[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00,
0x00, 0xc0, 0x03, 0x00, 0x00, 0x40, 0x02, 0x00,
0x00, 0x78, 0x1e, 0x00, 0xfc, 0x1f, 0xf8, 0x3f,
0xfc, 0x1f, 0xf8, 0x3f, 0x00, 0x78, 0x1e, 0x00,
0x00, 0x40, 0x02, 0x00, 0x00, 0xc0, 0x03, 0x00,
0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static char cross_lmsk[]={
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0xc0, 0x03, 0x00,
0x00, 0xe0, 0x07, 0x00, 0x00, 0x70, 0x0e, 0x00,
0x00, 0x78, 0x1e, 0x00, 0xff, 0x1f, 0xf8, 0xff,
0xff, 0x1f, 0xf8, 0xff, 0x00, 0x78, 0x1e, 0x00,
0x00, 0x70, 0x0e, 0x00, 0x00, 0xe0, 0x07, 0x00,
0x00, 0xc0, 0x03, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
0x00, 0x80, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00,
};
static BCursor CrossCursor = {
/*small*/
cross_sbm, cross_smsk,
16, 16,
7, 7,
/*big*/
cross_lbm, cross_lmsk,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_CROSSCURSOR]=&CrossCursor;
END_CURSOR_BLOCK
/********************** EditCross Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char editcross_sbm[]={
0x0e, 0x00, 0x11, 0x00, 0x1d, 0x00, 0x19, 0x03,
0x1d, 0x03, 0x11, 0x03, 0x0e, 0x03, 0x00, 0x03,
0xf8, 0x7c, 0xf8, 0x7c, 0x00, 0x03, 0x00, 0x03,
0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x00,
};
static char editcross_smsk[]={
0x0e, 0x00, 0x1f, 0x00, 0x1f, 0x03, 0x1f, 0x03,
0x1f, 0x03, 0x1f, 0x03, 0x0e, 0x03, 0x80, 0x07,
0xfc, 0xfc, 0xfc, 0xfc, 0x80, 0x07, 0x00, 0x03,
0x00, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x03,
};
static BCursor EditCrossCursor = {
/*small*/
editcross_sbm, editcross_smsk,
16, 16,
9, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_EDITCROSSCURSOR]=&EditCrossCursor;
END_CURSOR_BLOCK
/********************** Box Select *************************/
BEGIN_CURSOR_BLOCK
static char box_sbm[32]={
0x7f, 0x00, 0x41, 0x00, 0x41, 0x00, 0x41, 0x06,
0x41, 0x06, 0x41, 0x06, 0x7f, 0x06, 0x00, 0x06,
0xe0, 0x79, 0xe0, 0x79, 0x00, 0x06, 0x00, 0x06,
0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00,
};
static char box_smsk[32]={
0x7f, 0x00, 0x7f, 0x00, 0x63, 0x06, 0x63, 0x06,
0x63, 0x06, 0x7f, 0x06, 0x7f, 0x06, 0x00, 0x0f,
0xf0, 0xf9, 0xf0, 0xf9, 0x00, 0x0f, 0x00, 0x06,
0x00, 0x06, 0x00, 0x06, 0x00, 0x06, 0x00, 0x06,
};
static BCursor BoxSelCursor = {
/*small*/
box_sbm, box_smsk,
16, 16,
9, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_BOXSELCURSOR]=&BoxSelCursor;
END_CURSOR_BLOCK
/********************** Knife Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char knife_sbm[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x2c,
0x00, 0x5a, 0x00, 0x34, 0x00, 0x2a, 0x00, 0x17,
0x80, 0x06, 0x40, 0x03, 0xa0, 0x03, 0xd0, 0x01,
0x68, 0x00, 0x1c, 0x00, 0x06, 0x00, 0x00, 0x00
};
static char knife_smsk[]={
0x00, 0x60, 0x00, 0xf0, 0x00, 0xfc, 0x00, 0xfe,
0x00, 0xfe, 0x00, 0x7e, 0x00, 0x7f, 0x80, 0x3f,
0xc0, 0x0e, 0x60, 0x07, 0xb0, 0x07, 0xd8, 0x03,
0xec, 0x01, 0x7e, 0x00, 0x1f, 0x00, 0x07, 0x00
};
static char knife_lbm[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x1c,
0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x7f,
0x00, 0x00, 0x80, 0xbf, 0x00, 0x00, 0xc0, 0x5f,
0x00, 0x00, 0xc0, 0x6f, 0x00, 0x00, 0xc0, 0x37,
0x00, 0x00, 0xa8, 0x1b, 0x00, 0x00, 0x54, 0x0d,
0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x54, 0x00,
0x00, 0x00, 0xa8, 0x00, 0x00, 0x00, 0x53, 0x00,
0x00, 0xc0, 0x07, 0x00, 0x00, 0xe0, 0x0f, 0x00,
0x00, 0xd0, 0x0f, 0x00, 0x00, 0xe8, 0x07, 0x00,
0x00, 0xf4, 0x07, 0x00, 0x00, 0xfa, 0x00, 0x00,
0x00, 0x3d, 0x00, 0x00, 0x80, 0x0e, 0x00, 0x00,
0xc0, 0x03, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
0x30, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static char knife_lmsk[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x7e,
0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x80, 0xff,
0x00, 0x00, 0xc0, 0xbf, 0x00, 0x00, 0xe0, 0xdf,
0x00, 0x00, 0xe0, 0xef, 0x00, 0x00, 0xf8, 0x77,
0x00, 0x00, 0xfc, 0x3b, 0x00, 0x00, 0xfe, 0x1d,
0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0xfe, 0x01,
0x00, 0x00, 0xff, 0x01, 0x00, 0xc0, 0xff, 0x00,
0x00, 0xe0, 0x7f, 0x00, 0x00, 0xf0, 0x1f, 0x00,
0x00, 0xd8, 0x1f, 0x00, 0x00, 0xec, 0x0f, 0x00,
0x00, 0xf6, 0x0f, 0x00, 0x00, 0xfb, 0x06, 0x00,
0x80, 0xbd, 0x01, 0x00, 0xc0, 0x6e, 0x00, 0x00,
0xe0, 0x1b, 0x00, 0x00, 0xf0, 0x06, 0x00, 0x00,
0xb8, 0x01, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static BCursor KnifeCursor = {
/*small*/
knife_sbm, knife_smsk,
16, 16,
0, 15,
/*big*/
knife_lbm, knife_lmsk,
32,32,
0, 31,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_KNIFECURSOR]=&KnifeCursor;
END_CURSOR_BLOCK
/********************** Loop Select Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char vloop_sbm[]={
0x00, 0x00, 0x7e, 0x00, 0x3e, 0x00, 0x1e, 0x00,
0x0e, 0x00, 0x66, 0x60, 0x62, 0x6f, 0x00, 0x00,
0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
0x00, 0x00, 0x60, 0x60, 0x60, 0x6f, 0x00, 0x00,
};
static char vloop_smsk[]={
0xff, 0x01, 0xff, 0x00, 0x7f, 0x00, 0x3f, 0x00,
0xff, 0xf0, 0xff, 0xff, 0xf7, 0xff, 0xf3, 0xf0,
0x61, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60,
0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xff, 0xf0, 0xf0,
};
static char vloop_lbm[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xfc, 0x3f, 0x00, 0x00, 0xfc, 0x3f, 0x00, 0x00,
0xfc, 0x0f, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00,
0xfc, 0x03, 0x00, 0x00, 0xfc, 0x03, 0x00, 0x00,
0xfc, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00,
0x3c, 0x3c, 0x00, 0x3c, 0x3c, 0x3c, 0x00, 0x3c,
0x0c, 0x3c, 0xff, 0x3c, 0x0c, 0x3c, 0xff, 0x3c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
0x00, 0x3c, 0xff, 0x3c, 0x00, 0x3c, 0xff, 0x3c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static char vloop_lmsk[]={
0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0x03, 0x00,
0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
0xff, 0x3f, 0x00, 0x00, 0xff, 0x3f, 0x00, 0x00,
0xff, 0x0f, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00,
0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff,
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0x3f, 0xff, 0xff, 0xff, 0x3f, 0xff, 0xff, 0xff,
0x0f, 0xff, 0x00, 0xff, 0x0f, 0xff, 0x00, 0xff,
0x03, 0x3c, 0x00, 0x3c, 0x03, 0x3c, 0x00, 0x3c,
0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c, 0x00, 0x3c,
0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff,
0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
};
static BCursor VLoopCursor = {
/*small*/
vloop_sbm, vloop_smsk,
16, 16,
0, 0,
/*big*/
vloop_lbm, vloop_lmsk,
32,32,
0, 0,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_VLOOPCURSOR]=&VLoopCursor;
END_CURSOR_BLOCK
/********************** TextEdit Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char textedit_sbm[]={
0xe0, 0x03, 0x10, 0x04, 0x60, 0x03, 0x40, 0x01,
0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01,
0x40, 0x01, 0x60, 0x03, 0x10, 0x04, 0xe0, 0x03,
};
static char textedit_smsk[]={
0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03, 0xc0, 0x01,
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01,
0xc0, 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xe0, 0x03,
};
static BCursor TextEditCursor = {
/*small*/
textedit_sbm, textedit_smsk,
16, 16,
9, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_TEXTEDITCURSOR]=&TextEditCursor;
END_CURSOR_BLOCK
/********************** Paintbrush Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char paintbrush_sbm[]={
0x00, 0xe0, 0x00, 0x98, 0x00, 0x44, 0x00, 0x42,
0x00, 0x21, 0x80, 0x20, 0x40, 0x13, 0x40, 0x17,
0xa0, 0x0b, 0x98, 0x05, 0x04, 0x02, 0x02, 0x01,
0x02, 0x01, 0x02, 0x01, 0x81, 0x00, 0x7f, 0x00,
};
static char paintbrush_smsk[]={
0x00, 0xe0, 0x00, 0xf8, 0x00, 0x7c, 0x00, 0x7e,
0x00, 0x3f, 0x80, 0x3f, 0xc0, 0x1f, 0xc0, 0x1f,
0xe0, 0x0f, 0xf8, 0x07, 0xfc, 0x03, 0xfe, 0x01,
0xfe, 0x01, 0xfe, 0x01, 0xff, 0x00, 0x7f, 0x00,
};
static BCursor PaintBrushCursor = {
/*small*/
paintbrush_sbm, paintbrush_smsk,
16, 16,
0, 15,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_PAINTBRUSHCURSOR]=&PaintBrushCursor;
END_CURSOR_BLOCK
/********************** Hand Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char hand_sbm[]={
0x00, 0x00, 0x00, 0x00, 0x80, 0x01, 0x80, 0x0d,
0x98, 0x6d, 0x98, 0x6d, 0xb0, 0x6d, 0xb0, 0x6d,
0xe0, 0x6f, 0xe6, 0x7f, 0xee, 0x7f, 0xfc, 0x3f,
0xf8, 0x3f, 0xf0, 0x1f, 0xc0, 0x1f, 0xc0, 0x1f,
};
static char hand_smsk[]={
0x00, 0x00, 0x80, 0x01, 0xc0, 0x0f, 0xd8, 0x7f,
0xfc, 0xff, 0xfc, 0xff, 0xf8, 0xff, 0xf8, 0xff,
0xf6, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f,
0xfc, 0x7f, 0xf8, 0x3f, 0xf0, 0x3f, 0xe0, 0x3f,
};
static BCursor HandCursor = {
/*small*/
hand_sbm, hand_smsk,
16, 16,
8, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_HANDCURSOR]=&HandCursor;
END_CURSOR_BLOCK
/********************** NSEW Scroll Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char nsewscroll_sbm[]={
0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x30, 0x0e, 0x70,
0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00, 0x00, 0x00,
0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
};
static char nsewscroll_smsk[]={
0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07,
0xc0, 0x03, 0x0c, 0x30, 0x1e, 0x78, 0x1f, 0xf8,
0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30, 0xc0, 0x03,
0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
};
static BCursor NSEWScrollCursor = {
/*small*/
nsewscroll_sbm, nsewscroll_smsk,
16, 16,
8, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_NSEW_SCROLLCURSOR]=&NSEWScrollCursor;
END_CURSOR_BLOCK
/********************** NS Scroll Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char nsscroll_sbm[]={
0x00, 0x00, 0x80, 0x01, 0xc0, 0x03, 0xc0, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xc0, 0x03, 0xc0, 0x03, 0x80, 0x01, 0x00, 0x00,
};
static char nsscroll_smsk[]={
0x80, 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xe0, 0x07,
0xc0, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x03,
0xe0, 0x07, 0xe0, 0x07, 0xc0, 0x03, 0x80, 0x01,
};
static BCursor NSScrollCursor = {
/*small*/
nsscroll_sbm, nsscroll_smsk,
16, 16,
8, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_NS_SCROLLCURSOR]=&NSScrollCursor;
END_CURSOR_BLOCK
/********************** EW Scroll Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char ewscroll_sbm[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x0c, 0x30, 0x0e, 0x70,
0x0e, 0x70, 0x0c, 0x30, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static char ewscroll_smsk[]={
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x0c, 0x30, 0x1e, 0x78, 0x1f, 0xf8,
0x1f, 0xf8, 0x1e, 0x78, 0x0c, 0x30, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static BCursor EWScrollCursor = {
/*small*/
ewscroll_sbm, ewscroll_smsk,
16, 16,
8, 8,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_EW_SCROLLCURSOR]=&EWScrollCursor;
END_CURSOR_BLOCK
/********************** Eyedropper Cursor ***********************/
BEGIN_CURSOR_BLOCK
static char eyedropper_sbm[]={
0x00, 0x30, 0x00, 0x48, 0x00, 0x85, 0x80, 0x82,
0x40, 0x40, 0x80, 0x20, 0x40, 0x11, 0xa0, 0x23,
0xd0, 0x15, 0xe8, 0x0a, 0x74, 0x01, 0xb4, 0x00,
0x4a, 0x00, 0x35, 0x00, 0x08, 0x00, 0x04, 0x00,
};
static char eyedropper_smsk[]={
0x00, 0x30, 0x00, 0x78, 0x00, 0xfd, 0x80, 0xff,
0xc0, 0x7f, 0x80, 0x3f, 0xc0, 0x1f, 0xe0, 0x3f,
0xf0, 0x1f, 0xf8, 0x0b, 0xfc, 0x01, 0xfc, 0x00,
0x7e, 0x00, 0x3f, 0x00, 0x0c, 0x00, 0x04, 0x00,
};
static BCursor EyedropperCursor = {
/*small*/
eyedropper_sbm, eyedropper_smsk,
16, 16,
1, 15,
/*big*/
NULL, NULL,
32,32,
15, 15,
/*color*/
BC_BLACK, BC_WHITE
};
BlenderCursor[BC_EYEDROPPER_CURSOR]=&EyedropperCursor;
END_CURSOR_BLOCK
/********************** Put the cursors in the array ***********************/
}

470
source/blender/windowmanager/intern/wm_event_system.c Normal file
View File

@@ -0,0 +1,470 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <stdlib.h>
#include <string.h>
#include "DNA_listBase.h"
#include "DNA_screen_types.h"
#include "DNA_windowmanager_types.h"
#include "DNA_userdef_types.h" /* U.flag & TWOBUTTONMOUSE */
#include "MEM_guardedalloc.h"
#include "GHOST_C-api.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
#include "BKE_global.h"
#include "WM_api.h"
#include "WM_types.h"
#include "wm.h"
#include "wm_window.h"
#include "wm_event_system.h"
#include "wm_event_types.h"
/* ************ event management ************** */
static void wm_event_add(wmWindow *win, wmEvent *event_to_add)
{
wmEvent *event= MEM_callocN(sizeof(wmEvent), "event");
*event= *event_to_add;
BLI_addtail(&win->queue, event);
}
wmEvent *wm_event_next(wmWindow *win)
{
wmEvent *event= win->queue.first;
if(event) BLI_remlink(&win->queue, event);
return event;
}
static void wm_event_free(wmEvent *event)
{
if(event->customdata) MEM_freeN(event->customdata);
MEM_freeN(event);
}
void wm_event_free_all(wmWindow *win)
{
wmEvent *event;
while((event= win->queue.first)) {
BLI_remlink(&win->queue, event);
wm_event_free(event);
}
}
/* ********************* handlers *************** */
void wm_event_free_handlers(ListBase *lb)
{
wmEventHandler *handler;
for(handler= lb->first; handler; handler= handler->next) {
if(handler->op)
MEM_freeN(handler->op);
}
BLI_freelistN(lb);
}
static int wm_eventmatch(wmEvent *winevent, wmKeymapItem *km)
{
if(winevent->type!=km->type) return 0;
if(km->val) /* KM_PRESS, KM_RELEASE */
if(winevent->val!=km->val-1) return 0;
if(winevent->shift!=km->shift) return 0;
if(winevent->ctrl!=km->ctrl) return 0;
if(winevent->alt!=km->alt) return 0;
if(winevent->oskey!=km->oskey) return 0;
if(winevent->keymodifier!=km->keymodifier) return 0;
/* optional boundbox */
return 1;
}
static int wm_handler_operator_call(bContext *C, wmEventHandler *handler, wmEvent *event)
{
int retval= 0;
/* derived, modal or blocking operator */
if(handler->op) {
if( handler->op->type->poll(C)) {
if(handler->op->type->interactive)
retval= handler->op->type->interactive(C, handler->op, event);
else
printf("wm_handler_operator_call error\n");
}
}
else {
wmOperatorType *ot= WM_operatortype_find(event->keymap_idname);
if(ot) {
if(ot->poll(C)) {
/* operator on stack, register or new modal handle malloc-copies */
wmOperator op;
memset(&op, 0, sizeof(wmOperator));
op.type= ot;
if(op.type->interactive)
retval= op.type->interactive(C, &op, event);
else if(&op.type->exec)
retval= op.type->exec(C, &op);
if( ot->flag & OPTYPE_REGISTER)
WM_operator_register(C->wm, &op);
}
}
}
if(retval)
return WM_HANDLER_BREAK;
return WM_HANDLER_CONTINUE;
}
static int wm_handlers_do(bContext *C, wmEvent *event, ListBase *handlers)
{
wmEventHandler *handler;
int action= WM_HANDLER_CONTINUE;
if(handlers==NULL) return action;
for(handler= handlers->first; handler; handler= handler->next) {
if(handler->keymap) {
wmKeymapItem *km;
for(km= handler->keymap->first; km; km= km->next) {
if(wm_eventmatch(event, km)) {
if(event->type!=MOUSEMOVE)
printf("handle evt %d win %d op %s\n", event->type, C->window->winid, km->idname);
event->keymap_idname= km->idname; /* weak, but allows interactive callback to not use rawkey */
action= wm_handler_operator_call(C, handler, event);
}
}
if(action==WM_HANDLER_BREAK)
break;
}
/* modal+blocking handler */
if(handler->flag & WM_HANDLER_BLOCKING)
action= WM_HANDLER_BREAK;
}
return action;
}
static int wm_event_inside_i(wmEvent *event, rcti *rect)
{
return BLI_in_rcti(rect, event->x, event->y);
}
//static int wm_event_inside_f(wmEvent *event, rctf *rect)
//{
// return BLI_in_rctf(rect, (float)event->x, (float)event->y);
//}
/* called in main loop */
/* goes over entire hierarchy: events -> window -> screen -> area -> region */
void wm_event_do_handlers(bContext *C)
{
wmWindow *win;
for(win= C->wm->windows.first; win; win= win->next) {
wmEvent *event;
/* MVC demands to not draw in event handlers... for now we leave it */
/* it also updates context (win, screen) */
wm_window_make_drawable(C, win);
if( C->screen==NULL )
wm_event_free_all(C->window);
while( (event=wm_event_next(C->window)) ) {
int action= wm_handlers_do(C, event, &C->window->handlers);
if(action==WM_HANDLER_CONTINUE)
action= wm_handlers_do(C, event, &C->screen->handlers);
if(action==WM_HANDLER_CONTINUE) {
ScrArea *sa= C->screen->areabase.first;
for(; sa; sa= sa->next) {
if(wm_event_inside_i(event, &sa->winrct)) {
C->curarea= sa;
action= wm_handlers_do(C, event, &sa->handlers);
if(action==WM_HANDLER_CONTINUE) {
ARegion *ar= sa->regionbase.first;
for(; ar; ar= ar->next) {
if(wm_event_inside_i(event, &ar->winrct)) {
C->region= ar;
action= wm_handlers_do(C, event, &ar->handlers);
if(action==WM_HANDLER_BREAK)
break;
}
}
}
if(action==WM_HANDLER_BREAK)
break;
}
}
}
wm_event_free(event);
}
}
}
/* lets not expose struct outside wm? */
void WM_event_set_handler_flag(wmEventHandler *handler, int flag)
{
handler->flag= flag;
}
wmEventHandler *WM_event_add_modal_keymap_handler(ListBase *keymap, ListBase *handlers, wmOperator *op)
{
/* debug test; operator not in registry */
if(op->type->flag & OPTYPE_REGISTER) {
printf("error: handler (%s) cannot be modal, was registered\n", op->type->idname);
}
else {
wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "event handler");
wmOperator *opc= MEM_mallocN(sizeof(wmOperator), "operator modal");
BLI_addtail(handlers, handler);
handler->keymap= keymap;
*opc= *op;
handler->op= opc;
return handler;
}
return NULL;
}
wmEventHandler *WM_event_add_keymap_handler(ListBase *keymap, ListBase *handlers)
{
wmEventHandler *handler= MEM_callocN(sizeof(wmEventHandler), "event handler");
BLI_addtail(handlers, handler);
handler->keymap= keymap;
return handler;
}
/* ********************* ghost stuff *************** */
static int convert_key(GHOST_TKey key)
{
if (key>=GHOST_kKeyA && key<=GHOST_kKeyZ) {
return (AKEY + ((int) key - GHOST_kKeyA));
} else if (key>=GHOST_kKey0 && key<=GHOST_kKey9) {
return (ZEROKEY + ((int) key - GHOST_kKey0));
} else if (key>=GHOST_kKeyNumpad0 && key<=GHOST_kKeyNumpad9) {
return (PAD0 + ((int) key - GHOST_kKeyNumpad0));
} else if (key>=GHOST_kKeyF1 && key<=GHOST_kKeyF12) {
return (F1KEY + ((int) key - GHOST_kKeyF1));
} else {
switch (key) {
case GHOST_kKeyBackSpace: return BACKSPACEKEY;
case GHOST_kKeyTab: return TABKEY;
case GHOST_kKeyLinefeed: return LINEFEEDKEY;
case GHOST_kKeyClear: return 0;
case GHOST_kKeyEnter: return RETKEY;
case GHOST_kKeyEsc: return ESCKEY;
case GHOST_kKeySpace: return SPACEKEY;
case GHOST_kKeyQuote: return QUOTEKEY;
case GHOST_kKeyComma: return COMMAKEY;
case GHOST_kKeyMinus: return MINUSKEY;
case GHOST_kKeyPeriod: return PERIODKEY;
case GHOST_kKeySlash: return SLASHKEY;
case GHOST_kKeySemicolon: return SEMICOLONKEY;
case GHOST_kKeyEqual: return EQUALKEY;
case GHOST_kKeyLeftBracket: return LEFTBRACKETKEY;
case GHOST_kKeyRightBracket: return RIGHTBRACKETKEY;
case GHOST_kKeyBackslash: return BACKSLASHKEY;
case GHOST_kKeyAccentGrave: return ACCENTGRAVEKEY;
case GHOST_kKeyLeftShift: return LEFTSHIFTKEY;
case GHOST_kKeyRightShift: return RIGHTSHIFTKEY;
case GHOST_kKeyLeftControl: return LEFTCTRLKEY;
case GHOST_kKeyRightControl: return RIGHTCTRLKEY;
case GHOST_kKeyCommand: return COMMANDKEY;
case GHOST_kKeyLeftAlt: return LEFTALTKEY;
case GHOST_kKeyRightAlt: return RIGHTALTKEY;
case GHOST_kKeyCapsLock: return CAPSLOCKKEY;
case GHOST_kKeyNumLock: return 0;
case GHOST_kKeyScrollLock: return 0;
case GHOST_kKeyLeftArrow: return LEFTARROWKEY;
case GHOST_kKeyRightArrow: return RIGHTARROWKEY;
case GHOST_kKeyUpArrow: return UPARROWKEY;
case GHOST_kKeyDownArrow: return DOWNARROWKEY;
case GHOST_kKeyPrintScreen: return 0;
case GHOST_kKeyPause: return PAUSEKEY;
case GHOST_kKeyInsert: return INSERTKEY;
case GHOST_kKeyDelete: return DELKEY;
case GHOST_kKeyHome: return HOMEKEY;
case GHOST_kKeyEnd: return ENDKEY;
case GHOST_kKeyUpPage: return PAGEUPKEY;
case GHOST_kKeyDownPage: return PAGEDOWNKEY;
case GHOST_kKeyNumpadPeriod: return PADPERIOD;
case GHOST_kKeyNumpadEnter: return PADENTER;
case GHOST_kKeyNumpadPlus: return PADPLUSKEY;
case GHOST_kKeyNumpadMinus: return PADMINUS;
case GHOST_kKeyNumpadAsterisk: return PADASTERKEY;
case GHOST_kKeyNumpadSlash: return PADSLASHKEY;
case GHOST_kKeyGrLess: return GRLESSKEY;
default:
return UNKNOWNKEY; /* GHOST_kKeyUnknown */
}
}
}
/* adds customdata to event */
static void update_tablet_data(wmWindow *win, wmEvent *event)
{
const GHOST_TabletData *td= GHOST_GetTabletData(win->ghostwin);
/* if there's tablet data from an active tablet device then add it */
if ((td != NULL) && td->Active) {
struct wmTabletData *wmtab= MEM_mallocN(sizeof(wmTabletData), "customdata tablet");
wmtab->Active = td->Active;
wmtab->Pressure = td->Pressure;
wmtab->Xtilt = td->Xtilt;
wmtab->Ytilt = td->Ytilt;
event->custom= EVT_TABLET;
event->customdata= wmtab;
}
}
/* windows store own event queues, no bContext here */
void wm_event_add_ghostevent(wmWindow *win, int type, void *customdata)
{
wmEvent event, *evt= win->eventstate;
/* initialize and copy state (only mouse x y and modifiers) */
event= *evt;
switch (type) {
/* mouse move */
case GHOST_kEventCursorMove: {
if(win->active) {
GHOST_TEventCursorData *cd= customdata;
int cx, cy;
GHOST_ScreenToClient(win->ghostwin, cd->x, cd->y, &cx, &cy);
event.type= MOUSEMOVE;
event.x= evt->x= cx;
event.y= evt->y= (win->sizey-1) - cy;
update_tablet_data(win, &event);
wm_event_add(win, &event);
}
break;
}
/* mouse button */
case GHOST_kEventButtonDown:
case GHOST_kEventButtonUp: {
GHOST_TEventButtonData *bd= customdata;
event.val= (type==GHOST_kEventButtonDown);
if (bd->button == GHOST_kButtonMaskLeft)
event.type= LEFTMOUSE;
else if (bd->button == GHOST_kButtonMaskRight)
event.type= RIGHTMOUSE;
else
event.type= MIDDLEMOUSE;
update_tablet_data(win, &event);
wm_event_add(win, &event);
break;
}
/* keyboard */
case GHOST_kEventKeyDown:
case GHOST_kEventKeyUp: {
GHOST_TEventKeyData *kd= customdata;
event.type= convert_key(kd->key);
event.ascii= kd->ascii;
event.val= (type==GHOST_kEventKeyDown);
/* modifiers */
if (event.type==LEFTSHIFTKEY || event.type==RIGHTSHIFTKEY) {
event.shift= evt->shift= event.val;
} else if (event.type==LEFTCTRLKEY || event.type==RIGHTCTRLKEY) {
event.ctrl= evt->ctrl= event.val;
} else if (event.type==LEFTALTKEY || event.type==RIGHTALTKEY) {
event.alt= evt->alt= event.val;
} else if (event.type==COMMANDKEY) {
event.oskey= evt->oskey= event.val;
}
wm_event_add(win, &event);
break;
}
case GHOST_kEventWheel: {
GHOST_TEventWheelData* wheelData = customdata;
if (wheelData->z > 0)
event.type= WHEELUPMOUSE;
else
event.type= WHEELDOWNMOUSE;
event.val= wheelData->z; /* currently -1 or +1, see ghost for improvements here... */
wm_event_add(win, &event);
break;
}
case GHOST_kEventUnknown:
case GHOST_kNumEventTypes:
break;
}
}

929
source/blender/windowmanager/intern/wm_files.c Normal file
View File

@@ -0,0 +1,929 @@
/**
* $Id: wm_files.c
*
* ***** 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) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* Contributor(s): Blender Foundation 2007
*
* ***** END GPL LICENSE BLOCK *****
*/
/* placed up here because of crappy
* winsock stuff.
*/
#include <stdio.h>
#include <string.h>
#ifdef WIN32
#include <windows.h> /* need to include windows.h so _WIN32_IE is defined */
#ifndef _WIN32_IE
#define _WIN32_IE 0x0400 /* minimal requirements for SHGetSpecialFolderPath on MINGW MSVC has this defined already */
#endif
#include <shlobj.h> /* for SHGetSpecialFolderPath, has to be done before BLI_winstuff because 'near' is disabled through BLI_windstuff */
#include "BLI_winstuff.h"
#include <process.h> /* getpid */
#else
#include <unistd.h> /* getpid */
#endif
#include "MEM_guardedalloc.h"
#include "MEM_CacheLimiterC-Api.h"
#include "BIF_language.h"
#ifdef INTERNATIONAL
#include "FTF_Api.h"
#endif
#include "BLI_blenlib.h"
#include "BLI_linklist.h"
#include "DNA_object_types.h"
#include "DNA_space_types.h"
#include "DNA_userdef_types.h"
#include "DNA_sound_types.h"
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "DNA_windowmanager_types.h"
#include "BKE_blender.h"
#include "BKE_DerivedMesh.h"
#include "BKE_exotic.h"
#include "BKE_font.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BKE_packedFile.h"
#include "BKE_texture.h"
#include "BKE_utildefines.h"
#ifdef WITH_VERSE
#include "BKE_verse.h"
#endif
#include "BIF_fsmenu.h"
#include "BIF_interface.h"
#include "BIF_usiblender.h" /* XXX */
#include "BIF_editsound.h"
#include "BIF_editmode_undo.h"
#include "BIF_filelist.h"
#include "BIF_resources.h"
#include "BIF_screen.h"
#include "BIF_space.h"
#include "BIF_toolbox.h"
#ifdef WITH_VERSE
#include "BIF_verse.h"
#endif
#include "BDR_editobject.h"
#include "BLO_readfile.h"
#include "BLO_writefile.h"
// XXX #include "BPY_extern.h"
#include "datatoc.h"
#include "WM_api.h"
#include "wm.h"
/***/
/* define for setting colors in theme below */
#define SETCOL(col, r, g, b, a) col[0]=r; col[1]=g; col[2]= b; col[3]= a;
/* patching UserDef struct and Themes */
static void init_userdef_themes(void)
{
// XXX BIF_InitTheme(); // sets default again
// countall();
/* the UserDef struct is not corrected with do_versions() .... ugh! */
if(U.wheellinescroll == 0) U.wheellinescroll = 3;
if(U.menuthreshold1==0) {
U.menuthreshold1= 5;
U.menuthreshold2= 2;
}
if(U.tb_leftmouse==0) {
U.tb_leftmouse= 5;
U.tb_rightmouse= 5;
}
if(U.mixbufsize==0) U.mixbufsize= 2048;
if (BLI_streq(U.tempdir, "/")) {
char *tmp= getenv("TEMP");
strcpy(U.tempdir, tmp?tmp:"/tmp/");
}
if (U.savetime <= 0) {
U.savetime = 1;
// XXX error(".B.blend is buggy, please consider removing it.\n");
}
/* transform widget settings */
if(U.tw_hotspot==0) {
U.tw_hotspot= 14;
U.tw_size= 20; // percentage of window size
U.tw_handlesize= 16; // percentage of widget radius
}
if(U.pad_rot_angle==0)
U.pad_rot_angle= 15;
if(U.flag & USER_CUSTOM_RANGE)
vDM_ColorBand_store(&U.coba_weight); /* signal for derivedmesh to use colorband */
if (G.main->versionfile <= 191) {
strcpy(U.plugtexdir, U.textudir);
strcpy(U.sounddir, "/");
}
/* patch to set Dupli Armature */
if (G.main->versionfile < 220) {
U.dupflag |= USER_DUP_ARM;
}
/* userdef new option */
if (G.main->versionfile <= 222) {
U.vrmlflag= USER_VRML_LAYERS;
}
/* added seam, normal color, undo */
if (G.main->versionfile <= 234) {
bTheme *btheme;
U.uiflag |= USER_GLOBALUNDO;
if (U.undosteps==0) U.undosteps=32;
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* check for alpha==0 is safe, then color was never set */
if(btheme->tv3d.edge_seam[3]==0) {
SETCOL(btheme->tv3d.edge_seam, 230, 150, 50, 255);
}
if(btheme->tv3d.normal[3]==0) {
SETCOL(btheme->tv3d.normal, 0x22, 0xDD, 0xDD, 255);
}
if(btheme->tv3d.face_dot[3]==0) {
SETCOL(btheme->tv3d.face_dot, 255, 138, 48, 255);
btheme->tv3d.facedot_size= 4;
}
}
}
if (G.main->versionfile <= 235) {
/* illegal combo... */
if (U.flag & USER_LMOUSESELECT)
U.flag &= ~USER_TWOBUTTONMOUSE;
}
if (G.main->versionfile <= 236) {
bTheme *btheme;
/* new space type */
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* check for alpha==0 is safe, then color was never set */
if(btheme->ttime.back[3]==0) {
btheme->ttime = btheme->tsnd; // copy from sound
}
if(btheme->text.syntaxn[3]==0) {
SETCOL(btheme->text.syntaxn, 0, 0, 200, 255); /* Numbers Blue*/
SETCOL(btheme->text.syntaxl, 100, 0, 0, 255); /* Strings red */
SETCOL(btheme->text.syntaxc, 0, 100, 50, 255); /* Comments greenish */
SETCOL(btheme->text.syntaxv, 95, 95, 0, 255); /* Special */
SETCOL(btheme->text.syntaxb, 128, 0, 80, 255); /* Builtin, red-purple */
}
}
}
if (G.main->versionfile <= 237) {
bTheme *btheme;
/* bone colors */
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* check for alpha==0 is safe, then color was never set */
if(btheme->tv3d.bone_solid[3]==0) {
SETCOL(btheme->tv3d.bone_solid, 200, 200, 200, 255);
SETCOL(btheme->tv3d.bone_pose, 80, 200, 255, 80);
}
}
}
if (G.main->versionfile <= 238) {
bTheme *btheme;
/* bone colors */
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* check for alpha==0 is safe, then color was never set */
if(btheme->tnla.strip[3]==0) {
SETCOL(btheme->tnla.strip_select, 0xff, 0xff, 0xaa, 255);
SETCOL(btheme->tnla.strip, 0xe4, 0x9c, 0xc6, 255);
}
}
}
if (G.main->versionfile <= 239) {
bTheme *btheme;
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* Lamp theme, check for alpha==0 is safe, then color was never set */
if(btheme->tv3d.lamp[3]==0) {
SETCOL(btheme->tv3d.lamp, 0, 0, 0, 40);
/* TEMPORAL, remove me! (ton) */
U.uiflag |= USER_PLAINMENUS;
}
/* check for text field selection highlight, set it to text editor highlight by default */
if(btheme->tui.textfield_hi[3]==0) {
SETCOL(btheme->tui.textfield_hi,
btheme->text.shade2[0],
btheme->text.shade2[1],
btheme->text.shade2[2],
255);
}
}
if(U.obcenter_dia==0) U.obcenter_dia= 6;
}
if (G.main->versionfile <= 241) {
bTheme *btheme;
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* Node editor theme, check for alpha==0 is safe, then color was never set */
if(btheme->tnode.syntaxn[3]==0) {
/* re-uses syntax color storage */
btheme->tnode= btheme->tv3d;
SETCOL(btheme->tnode.edge_select, 255, 255, 255, 255);
SETCOL(btheme->tnode.syntaxl, 150, 150, 150, 255); /* TH_NODE, backdrop */
SETCOL(btheme->tnode.syntaxn, 129, 131, 144, 255); /* in/output */
SETCOL(btheme->tnode.syntaxb, 127,127,127, 255); /* operator */
SETCOL(btheme->tnode.syntaxv, 142, 138, 145, 255); /* generator */
SETCOL(btheme->tnode.syntaxc, 120, 145, 120, 255); /* group */
}
/* Group theme colors */
if(btheme->tv3d.group[3]==0) {
SETCOL(btheme->tv3d.group, 0x10, 0x40, 0x10, 255);
SETCOL(btheme->tv3d.group_active, 0x66, 0xFF, 0x66, 255);
}
/* Sequence editor theme*/
if(btheme->tseq.movie[3]==0) {
SETCOL(btheme->tseq.movie, 81, 105, 135, 255);
SETCOL(btheme->tseq.image, 109, 88, 129, 255);
SETCOL(btheme->tseq.scene, 78, 152, 62, 255);
SETCOL(btheme->tseq.audio, 46, 143, 143, 255);
SETCOL(btheme->tseq.effect, 169, 84, 124, 255);
SETCOL(btheme->tseq.plugin, 126, 126, 80, 255);
SETCOL(btheme->tseq.transition, 162, 95, 111, 255);
SETCOL(btheme->tseq.meta, 109, 145, 131, 255);
}
if(!(btheme->tui.iconfile)) {
BLI_strncpy(btheme->tui.iconfile, "", sizeof(btheme->tui.iconfile));
}
}
/* set defaults for 3D View rotating axis indicator */
/* since size can't be set to 0, this indicates it's not saved in .B.blend */
if (U.rvisize == 0) {
U.rvisize = 15;
U.rvibright = 8;
U.uiflag |= USER_SHOW_ROTVIEWICON;
}
}
if (G.main->versionfile <= 242) {
bTheme *btheme;
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
/* long keyframe color */
/* check for alpha==0 is safe, then color was never set */
if(btheme->tact.strip[3]==0) {
SETCOL(btheme->tv3d.edge_sharp, 255, 32, 32, 255);
SETCOL(btheme->tact.strip_select, 0xff, 0xff, 0xaa, 204);
SETCOL(btheme->tact.strip, 0xe4, 0x9c, 0xc6, 204);
}
/* IPO-Editor - Vertex Size*/
if(btheme->tipo.vertex_size == 0) {
btheme->tipo.vertex_size= 3;
}
}
}
if (G.main->versionfile <= 243) {
/* set default number of recently-used files (if not set) */
if (U.recent_files == 0) U.recent_files = 10;
}
if (G.main->versionfile < 245 || (G.main->versionfile == 245 && G.main->subversionfile < 3)) {
bTheme *btheme;
for(btheme= U.themes.first; btheme; btheme= btheme->next) {
SETCOL(btheme->tv3d.editmesh_active, 255, 255, 255, 128);
}
if(U.coba_weight.tot==0)
init_colorband(&U.coba_weight, 1);
}
if ((G.main->versionfile < 245) || (G.main->versionfile == 245 && G.main->subversionfile < 11)) {
bTheme *btheme;
for (btheme= U.themes.first; btheme; btheme= btheme->next) {
/* these should all use the same colour */
SETCOL(btheme->tv3d.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->tipo.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->tact.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->tnla.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->tseq.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->tsnd.cframe, 0x60, 0xc0, 0x40, 255);
SETCOL(btheme->ttime.cframe, 0x60, 0xc0, 0x40, 255);
}
}
/* GL Texture Garbage Collection (variable abused above!) */
if (U.textimeout == 0) {
U.texcollectrate = 60;
U.textimeout = 120;
}
if (U.memcachelimit <= 0) {
U.memcachelimit = 32;
}
if (U.frameserverport == 0) {
U.frameserverport = 8080;
}
MEM_CacheLimiter_set_maximum(U.memcachelimit * 1024 * 1024);
/* funny name, but it is GE stuff, moves userdef stuff to engine */
// XXX space_set_commmandline_options();
/* this timer uses U */
// XXX reset_autosave();
#ifdef WITH_VERSE
if(strlen(U.versemaster)<1) {
strcpy(U.versemaster, "master.uni-verse.org");
}
if(strlen(U.verseuser)<1) {
char *name = verse_client_name();
strcpy(U.verseuser, name);
MEM_freeN(name);
}
#endif
}
/* To be able to read files without windows closing, opening, moving
we try to prepare for worst case:
- active window gets active screen from file
- restoring the screens from non-active windows
Best case is all screens match, in that case they get assigned to proper window
*/
static void wm_window_match_init(bContext *C, ListBase *wmlist)
{
wmWindowManager *wm= G.main->wm.first;
wmWindow *win;
*wmlist= G.main->wm;
G.main->wm.first= G.main->wm.last= NULL;
return;
if(wm==NULL) return;
if(G.fileflags & G_FILE_NO_UI) return;
/* we take apart the used screens from non-active window */
for(win= wm->windows.first; win; win= win->next) {
BLI_strncpy(win->screenname, win->screen->id.name, MAX_ID_NAME);
if(win!=C->window) {
BLI_remlink(&G.main->screen, win->screen);
//BLI_addtail(screenbase, win->screen);
}
}
}
/* match old WM with new, 4 cases:
1- no current wm, no read wm: make new default
2- no current wm, but read wm: that's OK, do nothing
3- current wm, but not in file: try match screen names
4- current wm, and wm in file: try match ghostwin
*/
static void wm_window_match_do(bContext *C, ListBase *wmlist)
{
wmWindowManager *oldwm, *wm;
wmWindow *oldwin, *win;
/* cases 1 and 2 */
if(wmlist->first==NULL) {
if(G.main->wm.first); /* nothing todo */
else
wm_add_default(C);
}
else {
/* cases 3 and 4 */
/* we've read file without wm... */
if(G.main->wm.first==NULL) {
/* match oldwm to new dbase, only old files */
for(wm= wmlist->first; wm; wm= wm->id.next) {
for(win= wm->windows.first; win; win= win->next) {
win->screen= (bScreen *)find_id("SR", win->screenname);
if(win->screen->winid==0) {
if(win->screen==NULL)
win->screen= C->screen; /* active screen */
win->screen->winid= win->winid;
}
}
}
/* XXX still solve, case where multiple windows open */
G.main->wm= *wmlist;
}
else {
/* what if old was 3, and loaded 1? */
/* this code could move to setup_appdata */
oldwm= wmlist->first;
wm= G.main->wm.first;
/* only first wm in list has ghostwins */
for(win= wm->windows.first; win; win= win->next) {
for(oldwin= oldwm->windows.first; oldwin; oldwin= oldwin->next) {
if(oldwin->winid == win->winid ) {
win->ghostwin= oldwin->ghostwin;
oldwin->ghostwin= NULL;
}
}
}
wm_close_and_free_all(C, wmlist);
}
}
}
#ifdef WITH_VERSE
static void verse_unsub(void)
{
extern ListBase session_list;
struct VerseSession *session;
struct VNode *vnode;
session = session_list.first;
while(session) {
vnode = session->nodes.lb.first;
while(vnode) {
switch(vnode->type) {
case V_NT_OBJECT:
unsubscribe_from_obj_node(vnode);
break;
case V_NT_GEOMETRY:
unsubscribe_from_geom_node(vnode);
break;
case V_NT_BITMAP:
unsubscribe_from_bitmap_node(vnode);
break;
}
vnode = vnode->next;
}
session = session->next;
}
}
#endif
void WM_read_file(bContext *C, char *name)
{
int retval;
#ifdef WITH_VERSE
verse_unsub(); /* bad call here (ton) */
#endif
/* first try to append data from exotic file formats... */
/* it throws error box when file doesnt exist and returns -1 */
retval= BKE_read_exotic(name);
/* we didn't succeed, now try to read Blender file */
if (retval== 0) {
ListBase wmbase;
/* put aside screens to match with persistant windows later */
wm_window_match_init(C, &wmbase);
retval= BKE_read_file(C, name, NULL);
/* match the read WM with current WM */
wm_window_match_do(C, &wmbase);
// XXX mainwindow_set_filename_to_title(G.main->name);
// countall(); <-- will be listener
// XXX sound_initialize_sounds();
// winqueue_break= 1; /* leave queues everywhere */
if(retval==2) init_userdef_themes(); // in case a userdef is read from regular .blend
if (retval!=0) G.relbase_valid = 1;
// XXX undo_editmode_clear();
BKE_reset_undo();
BKE_write_undo(C, "original"); /* save current state */
// refresh_interface_font();
}
// else if(retval==1)
// XXX BIF_undo_push("Import file");
}
static void outliner_242_patch(void)
{
ScrArea *sa;
for(sa= G.curscreen->areabase.first; sa; sa= sa->next) {
SpaceLink *sl= sa->spacedata.first;
for(; sl; sl= sl->next) {
if(sl->spacetype==SPACE_OOPS) {
SpaceOops *soops= (SpaceOops *)sl;
if(soops->type!=SO_OUTLINER) {
soops->type= SO_OUTLINER;
// XXX init_v2d_oops(sa, soops);
}
}
}
}
G.fileflags |= G_FILE_GAME_MAT;
}
/* called on startup, (context entirely filled with NULLs) */
/* or called for 'Erase All' */
int WM_read_homefile(bContext *C, int from_memory)
{
ListBase wmbase;
char tstr[FILE_MAXDIR+FILE_MAXFILE], scestr[FILE_MAXDIR];
char *home= BLI_gethome();
int success;
BLI_clean(home);
free_ttfont(); /* still weird... what does it here? */
G.relbase_valid = 0;
if (!from_memory) BLI_make_file_string(G.sce, tstr, home, ".B.blend");
strcpy(scestr, G.sce); /* temporary store */
/* prevent loading no UI */
G.fileflags &= ~G_FILE_NO_UI;
/* put aside screens to match with persistant windows later */
wm_window_match_init(C, &wmbase);
if (!from_memory && BLI_exists(tstr)) {
success = BKE_read_file(C, tstr, NULL);
} else {
success = BKE_read_file_from_memory(C, datatoc_B_blend, datatoc_B_blend_size, NULL);
/* outliner patch for 2.42 .b.blend */
outliner_242_patch();
}
/* match the read WM with current WM */
wm_window_match_do(C, &wmbase);
strcpy(G.sce, scestr); /* restore */
init_userdef_themes();
/* XXX */
G.save_over = 0; // start with save preference untitled.blend
G.fileflags &= ~G_FILE_AUTOPLAY; /* disable autoplay in .B.blend... */
// mainwindow_set_filename_to_title(""); // empty string re-initializes title to "Blender"
#ifdef INTERNATIONAL
// XXX read_languagefile();
#endif
// refresh_interface_font();
// undo_editmode_clear();
BKE_reset_undo();
BKE_write_undo(C, "original"); /* save current state */
return success;
}
static void get_autosave_location(char buf[FILE_MAXDIR+FILE_MAXFILE])
{
char pidstr[32];
#ifdef WIN32
char subdir[9];
char savedir[FILE_MAXDIR];
#endif
sprintf(pidstr, "%d.blend", abs(getpid()));
#ifdef WIN32
if (!BLI_exists(U.tempdir)) {
BLI_strncpy(subdir, "autosave", sizeof(subdir));
BLI_make_file_string("/", savedir, BLI_gethome(), subdir);
/* create a new autosave dir
* function already checks for existence or not */
BLI_recurdir_fileops(savedir);
BLI_make_file_string("/", buf, savedir, pidstr);
return;
}
#endif
BLI_make_file_string("/", buf, U.tempdir, pidstr);
}
void WM_read_autosavefile(bContext *C)
{
char tstr[FILE_MAX], scestr[FILE_MAX];
int save_over;
BLI_strncpy(scestr, G.sce, FILE_MAX); /* temporal store */
get_autosave_location(tstr);
save_over = G.save_over;
BKE_read_file(C, tstr, NULL);
G.save_over = save_over;
BLI_strncpy(G.sce, scestr, FILE_MAX);
}
void read_Blog(void)
{
char name[FILE_MAX], filename[FILE_MAX];
LinkNode *l, *lines;
struct RecentFile *recent;
char *line;
int num;
BLI_make_file_string("/", name, BLI_gethome(), ".Blog");
lines= BLI_read_file_as_lines(name);
G.recent_files.first = G.recent_files.last = NULL;
/* read list of recent opend files from .Blog to memory */
for (l= lines, num= 0; l && (num<U.recent_files); l= l->next, num++) {
line = l->link;
if (!BLI_streq(line, "")) {
if (num==0)
strcpy(G.sce, line);
recent = (RecentFile*)MEM_mallocN(sizeof(RecentFile),"RecentFile");
BLI_addtail(&(G.recent_files), recent);
recent->filename = (char*)MEM_mallocN(sizeof(char)*(strlen(line)+1), "name of file");
recent->filename[0] = '\0';
strcpy(recent->filename, line);
}
}
if(G.sce[0] == 0)
BLI_make_file_string("/", G.sce, BLI_gethome(), "untitled.blend");
BLI_free_file_lines(lines);
#ifdef WIN32
/* Add the drive names to the listing */
{
__int64 tmp;
char folder[MAX_PATH];
char tmps[4];
int i;
tmp= GetLogicalDrives();
for (i=2; i < 26; i++) {
if ((tmp>>i) & 1) {
tmps[0]='a'+i;
tmps[1]=':';
tmps[2]='\\';
tmps[3]=0;
// XX fsmenu_insert_entry(tmps, 0, 0);
}
}
/* Adding Desktop and My Documents */
// XXX fsmenu_append_separator();
SHGetSpecialFolderPath(0, folder, CSIDL_PERSONAL, 0);
// XXX fsmenu_insert_entry(folder, 0, 0);
SHGetSpecialFolderPath(0, folder, CSIDL_DESKTOPDIRECTORY, 0);
// XXX fsmenu_insert_entry(folder, 0, 0);
// XXX fsmenu_append_separator();
}
#endif
BLI_make_file_string(G.sce, name, BLI_gethome(), ".Bfs");
lines= BLI_read_file_as_lines(name);
for (l= lines; l; l= l->next) {
char *line= l->link;
if (!BLI_streq(line, "")) {
// XXX fsmenu_insert_entry(line, 0, 1);
}
}
// XXX fsmenu_append_separator();
/* add last saved file */
BLI_split_dirfile(G.sce, name, filename); /* G.sce shouldn't be relative */
// XXX fsmenu_insert_entry(name, 0, 0);
BLI_free_file_lines(lines);
}
static void writeBlog(void)
{
struct RecentFile *recent, *next_recent;
char name[FILE_MAXDIR+FILE_MAXFILE];
FILE *fp;
int i;
BLI_make_file_string("/", name, BLI_gethome(), ".Blog");
recent = G.recent_files.first;
/* refresh .Blog of recent opened files, when current file was changed */
if(!(recent) || (strcmp(recent->filename, G.sce)!=0)) {
fp= fopen(name, "w");
if (fp) {
/* add current file to the beginning of list */
recent = (RecentFile*)MEM_mallocN(sizeof(RecentFile),"RecentFile");
recent->filename = (char*)MEM_mallocN(sizeof(char)*(strlen(G.sce)+1), "name of file");
recent->filename[0] = '\0';
strcpy(recent->filename, G.sce);
BLI_addhead(&(G.recent_files), recent);
/* write current file to .Blog */
fprintf(fp, "%s\n", recent->filename);
recent = recent->next;
i=1;
/* write rest of recent opened files to .Blog */
while((i<U.recent_files) && (recent)){
/* this prevents to have duplicities in list */
if (strcmp(recent->filename, G.sce)!=0) {
fprintf(fp, "%s\n", recent->filename);
recent = recent->next;
}
else {
next_recent = recent->next;
MEM_freeN(recent->filename);
BLI_freelinkN(&(G.recent_files), recent);
recent = next_recent;
}
i++;
}
fclose(fp);
}
}
}
static void do_history(char *name)
{
char tempname1[FILE_MAXDIR+FILE_MAXFILE], tempname2[FILE_MAXDIR+FILE_MAXFILE];
int hisnr= U.versions;
if(U.versions==0) return;
if(strlen(name)<2) return;
while( hisnr > 1) {
sprintf(tempname1, "%s%d", name, hisnr-1);
sprintf(tempname2, "%s%d", name, hisnr);
// if(BLI_rename(tempname1, tempname2))
// XXX error("Unable to make version backup");
hisnr--;
}
/* is needed when hisnr==1 */
sprintf(tempname1, "%s%d", name, hisnr);
// if(BLI_rename(name, tempname1))
// XXX error("Unable to make version backup");
}
void WM_write_file(bContext *C, char *target)
{
Library *li;
int writeflags, len;
char di[FILE_MAX];
char *err;
len = strlen(target);
if (len == 0) return;
if (len >= FILE_MAX) {
// XXX error("Path too long, cannot save");
return;
}
/* send the OnSave event */
// XXX if (G.f & G_DOSCRIPTLINKS) BPY_do_pyscript(&C->scene->id, SCRIPT_ONSAVE);
for (li= G.main->library.first; li; li= li->id.next) {
if (BLI_streq(li->name, target)) {
// XXX error("Cannot overwrite used library");
return;
}
}
if (!BLO_has_bfile_extension(target) && (len+6 < FILE_MAX)) {
sprintf(di, "%s.blend", target);
} else {
strcpy(di, target);
}
if (BLI_exists(di)) {
// XXX if(!saveover(di))
// XXX return;
}
if(G.obedit) {
// XXX exit_editmode(0); /* 0 = no free data */
}
if (G.fileflags & G_AUTOPACK) {
packAll();
}
// XXX waitcursor(1); // exit_editmode sets cursor too
do_history(di);
/* we use the UserDef to define compression flag */
writeflags= G.fileflags & ~G_FILE_COMPRESS;
if(U.flag & USER_FILECOMPRESS)
writeflags |= G_FILE_COMPRESS;
if (BLO_write_file(C, di, writeflags, &err)) {
strcpy(G.sce, di);
G.relbase_valid = 1;
strcpy(G.main->name, di); /* is guaranteed current file */
// XXX mainwindow_set_filename_to_title(G.main->name);
G.save_over = 1;
writeBlog();
} else {
// XXX error("%s", err);
}
// XXX waitcursor(0);
}
/* operator entry */
int WM_write_homefile(bContext *C, wmOperator *op)
{
char *err, tstr[FILE_MAXDIR+FILE_MAXFILE];
int write_flags;
BLI_make_file_string("/", tstr, BLI_gethome(), ".B.blend");
/* force save as regular blend file */
write_flags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_LOCK | G_FILE_SIGN);
BLO_write_file(C, tstr, write_flags, &err);
return 1;
}
void WM_write_autosave(bContext *C)
{
char *err, tstr[FILE_MAXDIR+FILE_MAXFILE];
int write_flags;
get_autosave_location(tstr);
/* force save as regular blend file */
write_flags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_LOCK | G_FILE_SIGN);
BLO_write_file(C, tstr, write_flags, &err);
}
/* if global undo; remove tempsave, otherwise rename */
void delete_autosave(void)
{
char tstr[FILE_MAXDIR+FILE_MAXFILE];
get_autosave_location(tstr);
if (BLI_exists(tstr)) {
char str[FILE_MAXDIR+FILE_MAXFILE];
BLI_make_file_string("/", str, U.tempdir, "quit.blend");
if(U.uiflag & USER_GLOBALUNDO) BLI_delete(tstr, 0, 0);
else BLI_rename(tstr, str);
}
}
/***/

302
source/blender/windowmanager/intern/wm_init_exit.c Normal file
View File

@@ -0,0 +1,302 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "MEM_guardedalloc.h"
#include "MEM_CacheLimiterC-Api.h"
#include "IMB_imbuf_types.h"
#include "IMB_imbuf.h"
#include "DNA_object_types.h"
#include "DNA_scene_types.h"
#include "DNA_sound_types.h"
#include "DNA_userdef_types.h"
#include "DNA_windowmanager_types.h"
#include "BKE_blender.h"
#include "BKE_curve.h"
#include "BKE_displist.h"
#include "BKE_DerivedMesh.h"
#include "BKE_font.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_mball.h"
#include "BKE_utildefines.h"
#include "BKE_packedFile.h"
#include "BMF_Api.h"
#include "BIF_language.h"
#ifdef INTERNATIONAL
#include "FTF_Api.h"
#endif
#include "BLI_blenlib.h"
#include "BIF_cursors.h"
#include "BIF_drawtext.h"
#include "BIF_editaction.h"
#include "BIF_editarmature.h"
#include "BIF_editlattice.h"
#include "BIF_editfont.h"
#include "BIF_editmesh.h"
#include "BIF_editmode_undo.h"
#include "BIF_editsound.h"
#include "BIF_filelist.h"
#include "BIF_fsmenu.h"
#include "BIF_interface.h"
#include "BIF_gl.h"
#include "BIF_poseobject.h"
#include "BIF_previewrender.h"
#include "BIF_resources.h"
#include "BIF_usiblender.h" /* XXX */
#include "BSE_drawview.h"
#include "BSE_edit.h"
#include "BSE_editipo.h"
#include "BSE_filesel.h"
#include "BSE_headerbuttons.h"
#include "BSE_node.h"
#include "BDR_drawobject.h"
#include "BDR_editobject.h"
#include "BDR_editcurve.h"
#include "BDR_imagepaint.h"
#include "BDR_vpaint.h"
#include "RE_pipeline.h" /* RE_ free stuff */
#include "radio.h"
#include "BPY_extern.h"
#include "SYS_System.h"
#include "WM_api.h"
#include "wm.h"
#include "wm_files.h"
#include "wm_window.h"
static void initbuttons(void)
{
// uiDefFont(UI_HELVB,
// BMF_GetFont(BMF_kHelveticaBold14),
// BMF_GetFont(BMF_kHelveticaBold12),
// BMF_GetFont(BMF_kHelveticaBold10),
// BMF_GetFont(BMF_kHelveticaBold8));
// uiDefFont(UI_HELV,
// BMF_GetFont(BMF_kHelvetica12),
// BMF_GetFont(BMF_kHelvetica12),
// BMF_GetFont(BMF_kHelvetica10),
// BMF_GetFont(BMF_kHelveticaBold8));
// glClearColor(.7f, .7f, .6f, 0.0);
G.font= BMF_GetFont(BMF_kHelvetica12);
G.fonts= BMF_GetFont(BMF_kHelvetica10);
G.fontss= BMF_GetFont(BMF_kHelveticaBold8);
// clear_matcopybuf(); /* XXX */
// glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
}
/* XXX */
static void sound_init_listener(void)
{
G.listener = MEM_callocN(sizeof(bSoundListener), "soundlistener");
G.listener->gain = 1.0;
G.listener->dopplerfactor = 1.0;
G.listener->dopplervelocity = 340.29f;
}
/* only called once, for startup */
void WM_init(bContext *C)
{
wm_ghost_init(C); /* note: it assigns C to ghost! */
wm_operatortype_init();
set_free_windowmanager_cb(wm_close_and_free); /* library.c */
/* get the default database, plus a wm */
WM_read_homefile(C, 0);
wm_check(C); /* opens window(s), checks keymaps */
// initscreen(); /* for (visual) speed, this first, then setscreen */
initbuttons();
// InitCursorData();
sound_init_listener();
// init_node_butfuncs();
// XXX BIF_preview_init_dbase();
// XXX BIF_resources_init(); /* after homefile, to dynamically load an icon file based on theme settings */
// XXX BIF_filelist_init_icons();
// init_gl_stuff(); /* drawview.c, after homefile */
read_Blog();
BLI_strncpy(G.lib, G.sce, FILE_MAX);
}
/* free strings of open recent files */
static void free_openrecent(void)
{
struct RecentFile *recent;
for(recent = G.recent_files.first; recent; recent=recent->next)
MEM_freeN(recent->filename);
BLI_freelistN(&(G.recent_files));
}
/* bad stuff*/
extern ListBase editNurb;
extern ListBase editelems;
extern wchar_t *copybuf;
extern wchar_t *copybufinfo;
/* called in creator.c even... tsk, split this! */
void WM_exit(bContext *C)
{
wm_operatortype_free();
free_ttfont(); /* bke_font.h */
#ifdef WITH_VERSE
end_all_verse_sessions();
#endif
free_openrecent();
freeAllRad();
BKE_freecubetable();
// if (G.background == 0)
// sound_end_all_sounds();
if(G.obedit) {
if(G.obedit->type==OB_FONT) {
// free_editText();
}
// else if(G.obedit->type==OB_MBALL) BLI_freelistN(&editelems);
// free_editMesh(G.editMesh);
}
// free_editLatt();
// free_editArmature();
// free_posebuf();
/* before free_blender so py's gc happens while library still exists */
/* needed at least for a rare sigsegv that can happen in pydrivers */
// BPY_end_python();
// fastshade_free_render(); /* shaded view */
free_blender(); /* blender.c, does entire library */
// free_matcopybuf();
// free_ipocopybuf();
// free_actcopybuf();
// free_vertexpaint();
// free_imagepaint();
/* editnurb can remain to exist outside editmode */
freeNurblist(&editNurb);
// fsmenu_free();
#ifdef INTERNATIONAL
// free_languagemenu();
#endif
RE_FreeAllRender();
// free_txt_data();
// sound_exit_audio();
if(G.listener) MEM_freeN(G.listener);
libtiff_exit();
#ifdef WITH_QUICKTIME
quicktime_exit();
#endif
if (!G.background) {
// XXX BIF_resources_free();
// XXX BIF_filelist_free_icons();
}
#ifdef INTERNATIONAL
FTF_End();
#endif
// if (copybuf) MEM_freeN(copybuf);
// if (copybufinfo) MEM_freeN(copybufinfo);
/* undo free stuff */
// undo_editmode_clear();
BKE_undo_save_quit(); // saves quit.blend if global undo is on
BKE_reset_undo();
BLI_freelistN(&U.themes);
// XXX BIF_preview_free_dbase();
MEM_freeN(C);
if(totblock!=0) {
printf("Error Totblock: %d\n",totblock);
MEM_printmemlist();
}
// delete_autosave();
printf("\nBlender quit\n");
#ifdef WIN32
/* ask user to press enter when in debug mode */
if(G.f & G_DEBUG) {
printf("press enter key to exit...\n\n");
getchar();
}
#endif
SYS_DeleteSystem(SYS_GetSystem());
exit(G.afbreek==1);
}

112
source/blender/windowmanager/intern/wm_keymap.c Normal file
View File

@@ -0,0 +1,112 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <string.h>
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "WM_api.h"
#include "WM_types.h"
#include "wm_window.h"
#include "wm_event_system.h"
#include "wm_event_types.h"
/* ***************** generic call, exported **************** */
static void keymap_set(wmKeymapItem *km, short type, short val, int modifier, short keymodifier)
{
km->type= type;
km->val= val;
km->keymodifier= keymodifier;
if(modifier & KM_SHIFT)
km->shift= 1;
else if(modifier & KM_SHIFT2)
km->shift= 2;
if(modifier & KM_CTRL)
km->ctrl= 1;
else if(modifier & KM_CTRL2)
km->ctrl= 2;
if(modifier & KM_ALT)
km->alt= 1;
else if(modifier & KM_ALT2)
km->alt= 2;
if(modifier & KM_OSKEY)
km->oskey= 1;
else if(modifier & KM_OSKEY2)
km->oskey= 2;
}
/* if item was added, then replace */
void WM_keymap_verify_item(ListBase *lb, char *idname, short type, short val, int modifier, short keymodifier)
{
wmKeymapItem *km;
/* if item was added, then bail out */
for(km= lb->first; km; km= km->next)
if(strncmp(km->idname, idname, OP_MAX_TYPENAME)==0)
break;
if(km==NULL) {
km= MEM_callocN(sizeof(wmKeymapItem), "keymap entry");
BLI_addtail(lb, km);
BLI_strncpy(km->idname, idname, OP_MAX_TYPENAME);
keymap_set(km, type, val, modifier, keymodifier);
}
}
/* if item was added, then replace */
void WM_keymap_set_item(ListBase *lb, char *idname, short type, short val, int modifier, short keymodifier)
{
wmKeymapItem *km;
for(km= lb->first; km; km= km->next)
if(strncmp(km->idname, idname, OP_MAX_TYPENAME)==0)
break;
if(km==NULL) {
km= MEM_callocN(sizeof(wmKeymapItem), "keymap entry");
BLI_addtail(lb, km);
BLI_strncpy(km->idname, idname, OP_MAX_TYPENAME);
}
keymap_set(km, type, val, modifier, keymodifier);
}

125
source/blender/windowmanager/intern/wm_operators.c Normal file
View File

@@ -0,0 +1,125 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <string.h>
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
#include "BKE_global.h"
#include "BKE_library.h"
#include "BKE_main.h"
#include "BIF_toolbox.h"
#include "WM_api.h"
#include "WM_types.h"
#include "wm_window.h"
#include "wm_event_system.h"
static ListBase global_ops= {NULL, NULL};
/* ************ operator API, exported ********** */
wmOperatorType *WM_operatortype_find(const char *idname)
{
wmOperatorType *ot;
for(ot= global_ops.first; ot; ot= ot->next) {
if(strncmp(ot->idname, idname, OP_MAX_TYPENAME)==0)
return ot;
}
return NULL;
}
/* ************ default ops, exported *********** */
int WM_operator_confirm(bContext *C, wmOperator *op, wmEvent *event)
{
// if(okee(op->type->name)) {
// return op->type->exec(C, op);
// }
return 0;
}
int WM_operator_winactive(bContext *C)
{
if(C->window==NULL) return 0;
return 1;
}
/* ************ window / screen operator definitions ************** */
static void WM_OT_window_duplicate(wmOperatorType *ot)
{
ot->name= "Duplicate Window";
ot->idname= "WM_OT_window_duplicate";
ot->interactive= NULL; //WM_operator_confirm;
ot->exec= wm_window_duplicate_op;
ot->poll= WM_operator_winactive;
}
static void WM_OT_save_homefile(wmOperatorType *ot)
{
ot->name= "Save User Settings";
ot->idname= "WM_OT_save_homefile";
ot->interactive= NULL; //WM_operator_confirm;
ot->exec= WM_write_homefile;
ot->poll= WM_operator_winactive;
ot->flag= OPTYPE_REGISTER;
}
#define ADD_OPTYPE(opfunc) ot= MEM_callocN(sizeof(wmOperatorType), "operatortype"); \
opfunc(ot); \
BLI_addtail(&global_ops, ot)
/* called on initialize WM_exit() */
void wm_operatortype_free(void)
{
BLI_freelistN(&global_ops);
}
/* called on initialize WM_init() */
void wm_operatortype_init(void)
{
wmOperatorType *ot;
ADD_OPTYPE(WM_OT_window_duplicate);
ADD_OPTYPE(WM_OT_save_homefile);
}

491
source/blender/windowmanager/intern/wm_window.c Normal file
View File

@@ -0,0 +1,491 @@
/**
* $Id: wm_window.c
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation but based
* on ghostwinlay.c (C) 2001-2002 by NaN Holding BV
* All rights reserved.
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include <stdlib.h>
#include <stdio.h>
#include "DNA_listBase.h"
#include "DNA_screen_types.h"
#include "DNA_windowmanager_types.h"
#include "MEM_guardedalloc.h"
#include "GHOST_C-api.h"
#include "BLI_blenlib.h"
#include "BKE_blender.h"
#include "BKE_global.h"
#include "BKE_utildefines.h"
#include "BIF_gl.h"
#include "WM_api.h"
#include "wm.h"
#include "wm_window.h"
#include "wm_event_system.h"
/* the global to talk to ghost */
GHOST_SystemHandle g_system= NULL;
/* set by commandline */
static int prefsizx= 0, prefsizy= 0, prefstax= 0, prefstay= 0;
/* ******** win open & close ************ */
static void wm_get_screensize(int *width_r, int *height_r)
{
unsigned int uiwidth;
unsigned int uiheight;
GHOST_GetMainDisplayDimensions(g_system, &uiwidth, &uiheight);
*width_r= uiwidth;
*height_r= uiheight;
}
static void wm_ghostwindow_destroy(wmWindow *win)
{
if (win->timer) {
GHOST_RemoveTimer(g_system, (GHOST_TimerTaskHandle)win->timer);
win->timer= NULL;
}
if(win->ghostwin) {
GHOST_DisposeWindow(g_system, win->ghostwin);
win->ghostwin= NULL;
}
}
/* including window itself */
void wm_window_free(bContext *C, wmWindow *win)
{
/* update context */
if(C) {
if(C->wm->windrawable==win)
C->wm->windrawable= NULL;
if(C->wm->winactive==win)
C->wm->winactive= NULL;
if(C->window==win)
C->window= NULL;
if(C->screen==win->screen)
C->screen= NULL;
}
/* XXX free screens */
if(win->eventstate) MEM_freeN(win->eventstate);
BLI_freelistN(&win->queue);
wm_event_free_handlers(&win->handlers);
wm_event_free_all(win);
wm_ghostwindow_destroy(win);
MEM_freeN(win);
}
static int find_free_winid(wmWindowManager *wm)
{
wmWindow *win;
int id= 0;
for(win= wm->windows.first; win; win= win->next)
if(id <= win->winid)
id= win->winid+1;
return id;
}
/* dont change context itself */
wmWindow *wm_window_new(bContext *C, bScreen *screen)
{
wmWindow *win= MEM_callocN(sizeof(wmWindow), "window");
BLI_addtail(&C->wm->windows, win);
win->winid= find_free_winid(C->wm);
win->screen= screen;
return win;
}
/* part of wm_window.c api */
wmWindow *wm_window_copy(bContext *C, wmWindow *winorig)
{
wmWindow *win= wm_window_new(C, winorig->screen); /* XXX need copy */
win->posx= winorig->posx+10;
win->posy= winorig->posy;
win->sizex= winorig->sizex;
win->sizey= winorig->sizey;
return win;
}
/* operator callback */
int wm_window_duplicate_op(bContext *C, wmOperator *op)
{
wm_window_copy(C, C->window);
wm_check(C);
return 1;
}
/* this is event from ghost */
static void wm_window_close(bContext *C, wmWindow *win)
{
BLI_remlink(&C->wm->windows, win);
wm_window_free(C, win);
if(C->wm->windows.first==NULL)
WM_exit(C);
}
static void wm_window_open(wmWindowManager *wm, char *title, wmWindow *win)
{
GHOST_WindowHandle ghostwin;
GHOST_TWindowState inital_state;
int scr_w, scr_h, posy;
wm_get_screensize(&scr_w, &scr_h);
posy= (scr_h - win->posy - win->sizey);
if (win->windowstate == G_WINDOWSTATE_FULLSCREEN)
inital_state = GHOST_kWindowStateFullScreen;
else if (win->windowstate == G_WINDOWSTATE_BORDER)
inital_state = GHOST_kWindowStateMaximized;
else
inital_state = GHOST_kWindowStateNormal;
#ifdef __APPLE__
{
extern int macPrefState; /* creator.c */
inital_state += macPrefState;
}
#endif
ghostwin= GHOST_CreateWindow(g_system, title,
win->posx, posy, win->sizex, win->sizey,
inital_state,
GHOST_kDrawingContextTypeOpenGL,
0 /* no stereo */);
if (ghostwin) {
win->ghostwin= ghostwin;
GHOST_SetWindowUserData(ghostwin, win); /* pointer back */
if(win->eventstate==NULL)
win->eventstate= MEM_callocN(sizeof(wmEvent), "window event state");
/* add keymap handler (1 for all keys in map!) */
WM_event_add_keymap_handler(&wm->windowkeymap, &win->handlers);
/* until screens get drawn, make it nice grey */
glClearColor(.55, .55, .55, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
wm_window_swap_buffers(win);
}
}
/* for wmWindows without ghostwin, open these and clear */
void wm_window_add_ghostwindows(wmWindowManager *wm)
{
wmWindow *win;
/* no commandline prefsize? then we set this */
if (!prefsizx) {
wm_get_screensize(&prefsizx, &prefsizy);
#ifdef __APPLE__
extern void wm_set_apple_prefsize(int, int); /* wm_apple.c */
wm_set_apple_prefsize(prefsizx, prefsizy);
#else
prefstax= 0;
prefstay= 0;
#endif
}
for(win= wm->windows.first; win; win= win->next) {
if(win->ghostwin==NULL) {
if(win->sizex==0) {
win->posx= prefstax;
win->posy= prefstay;
win->sizex= prefsizx;
win->sizey= prefsizy;
win->windowstate= G.windowstate;
}
wm_window_open(wm, "Blender", win);
}
}
}
/* ************ events *************** */
static int query_qual(char qual)
{
GHOST_TModifierKeyMask left, right;
int val= 0;
if (qual=='s') {
left= GHOST_kModifierKeyLeftShift;
right= GHOST_kModifierKeyRightShift;
} else if (qual=='c') {
left= GHOST_kModifierKeyLeftControl;
right= GHOST_kModifierKeyRightControl;
} else if (qual=='C') {
left= right= GHOST_kModifierKeyCommand;
} else {
left= GHOST_kModifierKeyLeftAlt;
right= GHOST_kModifierKeyRightAlt;
}
GHOST_GetModifierKeyState(g_system, left, &val);
if (!val)
GHOST_GetModifierKeyState(g_system, right, &val);
return val;
}
void wm_window_make_drawable(bContext *C, wmWindow *win)
{
if (win != C->window && win->ghostwin) {
// win->lmbut= 0; /* keeps hanging when mousepressed while other window opened */
C->wm->windrawable= win;
C->window= win;
C->screen= win->screen;
GHOST_ActivateWindowDrawingContext(win->ghostwin);
}
}
/* called by ghost, here we handle events for windows themselves or send to event system */
int ghost_event_proc(GHOST_EventHandle evt, GHOST_TUserDataPtr private)
{
bContext *C= private;
GHOST_TEventType type= GHOST_GetEventType(evt);
if (type == GHOST_kEventQuit) {
WM_exit(C);
} else {
GHOST_WindowHandle ghostwin= GHOST_GetEventWindow(evt);
GHOST_TEventDataPtr data= GHOST_GetEventData(evt);
wmWindow *win;
if (!ghostwin) {
// XXX - should be checked, why are we getting an event here, and
// what is it?
return 1;
} else if (!GHOST_ValidWindow(g_system, ghostwin)) {
// XXX - should be checked, why are we getting an event here, and
// what is it?
return 1;
} else {
win= GHOST_GetWindowUserData(ghostwin);
}
switch(type) {
case GHOST_kEventWindowDeactivate:
win->active= 0; /* XXX */
break;
case GHOST_kEventWindowActivate:
{
GHOST_TEventKeyData kdata;
int cx, cy, wx, wy;
C->wm->winactive= win; /* no context change! c->window is drawable, or for area queues */
win->active= 1;
// window_handle(win, INPUTCHANGE, win->active);
/* bad ghost support for modifier keys... */
kdata.ascii= 0;
if (win->eventstate->shift && !query_qual('s')) {
kdata.key= GHOST_kKeyLeftShift;
wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
}
if (win->eventstate->ctrl && !query_qual('c')) {
kdata.key= GHOST_kKeyLeftControl;
wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
}
if (win->eventstate->alt && !query_qual('a')) {
kdata.key= GHOST_kKeyLeftAlt;
wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
}
if (win->eventstate->oskey && !query_qual('C')) {
kdata.key= GHOST_kKeyCommand;
wm_event_add_ghostevent(win, GHOST_kEventKeyUp, &kdata);
}
/* entering window, update mouse pos. but no event */
GHOST_GetCursorPosition(g_system, &wx, &wy);
GHOST_ScreenToClient(win->ghostwin, wx, wy, &cx, &cy);
win->eventstate->x= cx;
win->eventstate->y= (win->sizey-1) - cy;
break;
}
case GHOST_kEventWindowClose: {
wm_window_close(C, win);
break;
}
case GHOST_kEventWindowUpdate: {
// window_handle(win, REDRAW, 1);
break;
}
case GHOST_kEventWindowSize: {
GHOST_RectangleHandle client_rect;
int l, t, r, b, scr_w, scr_h;
/* was GetClientBounds, doesnt work (at least osx) */
client_rect= GHOST_GetWindowBounds(win->ghostwin);
GHOST_GetRectangle(client_rect, &l, &t, &r, &b);
GHOST_DisposeRectangle(client_rect);
wm_get_screensize(&scr_w, &scr_h);
win->sizex= r-l;
win->sizey= b-t;
win->posx= l;
win->posy= scr_h - t - win->sizey;
#ifdef __APPLE__
win->posy-= 24; /* gutter... see ghost, bad stuff */
#endif
// window_handle(win, RESHAPE, 1);
break;
}
default:
wm_event_add_ghostevent(win, type, data);
break;
}
}
return 1;
}
void wm_window_process_events(int wait_for_event)
{
GHOST_ProcessEvents(g_system, wait_for_event);
GHOST_DispatchEvents(g_system);
}
/* **************** init ********************** */
void wm_ghost_init(bContext *C)
{
if (!g_system) {
GHOST_EventConsumerHandle consumer= GHOST_CreateEventConsumer(ghost_event_proc, C);
g_system= GHOST_CreateSystem();
GHOST_AddEventConsumer(g_system, consumer);
}
}
/* **************** timer ********************** */
static void window_timer_proc(GHOST_TimerTaskHandle timer, GHOST_TUns64 time)
{
wmWindow *win= GHOST_GetTimerTaskUserData(timer);
wm_event_add_ghostevent(win, win->timer_event, NULL);
}
void wm_window_set_timer(wmWindow *win, int delay_ms, int event)
{
if (win->timer) GHOST_RemoveTimer(g_system, win->timer);
win->timer_event= event;
win->timer= GHOST_InstallTimer(g_system, delay_ms, delay_ms, window_timer_proc, win);
}
/* ************************************ */
void wm_window_set_title(wmWindow *win, char *title)
{
GHOST_SetTitle(win->ghostwin, title);
}
void wm_window_get_position(wmWindow *win, int *posx_r, int *posy_r)
{
*posx_r= win->posx;
*posy_r= win->posy;
}
void wm_window_get_size(wmWindow *win, int *width_r, int *height_r)
{
*width_r= win->sizex;
*height_r= win->sizey;
}
void wm_window_set_size(wmWindow *win, int width, int height)
{
GHOST_SetClientSize(win->ghostwin, width, height);
}
void wm_window_lower(wmWindow *win)
{
GHOST_SetWindowOrder(win->ghostwin, GHOST_kWindowOrderBottom);
}
void wm_window_raise(wmWindow *win)
{
GHOST_SetWindowOrder(win->ghostwin, GHOST_kWindowOrderTop);
#ifdef _WIN32
// markdirty_all(); /* to avoid redraw errors in fullscreen mode (aphex) */
#endif
}
void wm_window_swap_buffers(wmWindow *win)
{
GHOST_SwapWindowBuffers(win->ghostwin);
}
/* ******************* exported api ***************** */
/* called whem no ghost system was initialized */
void WM_setprefsize(int stax, int stay, int sizx, int sizy)
{
prefstax= stax;
prefstay= stay;
prefsizx= sizx;
prefsizy= sizy;
}

43
source/blender/windowmanager/wm.h Normal file
View File

@@ -0,0 +1,43 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_H
#define WM_H
extern void wm_close_and_free(bContext *C, wmWindowManager *);
extern void wm_close_and_free_all(bContext *C, ListBase *);
extern void wm_add_default(bContext *C);
extern void wm_check(bContext *C);
/* wm_operator.c, for init/exit */
void wm_operatortype_free(void);
void wm_operatortype_init(void);
#endif /* WM_H */

115
source/blender/windowmanager/wm_cursors.h Normal file
View File

@@ -0,0 +1,115 @@
/**
* $Id: BIF_cursors.h 7739 2006-06-15 14:22:59Z broken $
*
* ***** BEGIN GPL/BL DUAL 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. The Blender
* Foundation also sells licenses for use in proprietary software under
* the Blender License. See http://www.blender.org/BL/ for information
* about this.
*
* 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) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): none yet.
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#ifndef WM_CURSORS_H
#define WM_CURSORS_H
#define BC_GHOST_CURSORS 1000
/* old cursors */
enum {
CURSOR_FACESEL=BC_GHOST_CURSORS,
CURSOR_WAIT,
CURSOR_EDIT,
CURSOR_X_MOVE,
CURSOR_Y_MOVE,
CURSOR_HELP,
CURSOR_STD,
CURSOR_NONE,
CURSOR_PENCIL,
};
//typedef struct BCursor_s BCursor;
typedef struct BCursor {
char *small_bm;
char *small_mask;
char small_sizex;
char small_sizey;
char small_hotx;
char small_hoty;
char *big_bm;
char *big_mask;
char big_sizex;
char big_sizey;
char big_hotx;
char big_hoty;
char fg_color;
char bg_color;
} BCursor;
#define LASTCURSOR -2
#define SYSCURSOR -1
enum {
BC_NW_ARROWCURSOR=0,
BC_NS_ARROWCURSOR,
BC_EW_ARROWCURSOR,
BC_WAITCURSOR,
BC_CROSSCURSOR,
BC_EDITCROSSCURSOR,
BC_BOXSELCURSOR,
BC_KNIFECURSOR,
BC_VLOOPCURSOR,
BC_TEXTEDITCURSOR,
BC_PAINTBRUSHCURSOR,
BC_HANDCURSOR,
BC_NSEW_SCROLLCURSOR,
BC_NS_SCROLLCURSOR,
BC_EW_SCROLLCURSOR,
BC_EYEDROPPER_CURSOR,
/* --- ALWAYS LAST ----- */
BC_NUMCURSORS,
};
enum {
BC_BLACK=0,
BC_WHITE,
BC_RED,
BC_BLUE,
BC_GREEN,
BC_YELLOW
};
#define SMALL_CURSOR 0
#define BIG_CURSOR 1
#endif /* WM_CURSORS_H */

97
source/blender/windowmanager/wm_event_system.h Normal file
View File

@@ -0,0 +1,97 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_EVENT_SYSTEM_H
#define WM_EVENT_SYSTEM_H
/* return value of handler-operator call */
#define WM_HANDLER_CONTINUE 0
#define WM_HANDLER_BREAK 1
/* each event should have full modifier state */
/* event comes from eventmanager and from keymap */
typedef struct wmEvent {
struct wmEvent *next, *prev;
short type; /* event code itself (short, is also in keymap) */
short val; /* press, release, scrollvalue */
short x, y; /* mouse pointer position */
short unicode; /* future, ghost? */
char ascii; /* from ghost */
char pad1;
/* modifier states */
short shift, ctrl, alt, oskey; /* oskey is apple or windowskey, value denotes order of pressed */
short keymodifier; /* rawkey modifier */
/* keymap item, set by handler (weak?) */
const char *keymap_idname;
/* custom data */
short custom; /* custom data type, stylus, 6dof, see wm_event_types.h */
void *customdata; /* ascii, unicode, mouse coords, angles, vectors, dragdrop info */
} wmEvent;
/* wmKeyMap is in DNA_windowmanager.h, it's savable */
typedef struct wmEventHandler {
struct wmEventHandler *next, *prev;
int type, flag; /* type default=0, rest is custom */
ListBase *keymap; /* pointer to builtin/custom keymaps */
rctf boundbox; /* float, in bContext space (window, area, region) */
wmOperator *op; /* for derived handlers */
} wmEventHandler;
/* handler flag */
/* after this handler all others are ignored */
#define WM_HANDLER_BLOCKING 1
/* custom types for handlers, for signalling, freeing */
enum {
WM_HANDLER_DEFAULT,
WM_HANDLER_TRANSFORM
};
void wm_event_free_all (wmWindow *win);
wmEvent *wm_event_next (wmWindow *win);
void wm_event_free_handlers (ListBase *lb);
/* goes over entire hierarchy: events -> window -> screen -> area -> region */
void wm_event_do_handlers(bContext *C);
void wm_event_add_ghostevent(wmWindow *win, int type, void *customdata);
#endif /* WM_EVENT_SYSTEM_H */

255
source/blender/windowmanager/wm_event_types.h Normal file
View File

@@ -0,0 +1,255 @@
/*
* $Id: wm_event_types.h
*
* ***** 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) 2001-2002 by NaN Holding BV.
* All rights reserved.
*
* The Original Code is: all of this file.
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
/*
* These define have its origin at sgi, where all device defines were written down in device.h.
* Blender copied the conventions quite some, and expanded it with internal new defines (ton)
*
*/
#ifndef WM_EVENT_TYPES_H
#define WM_EVENT_TYPES_H
/* custom data type */
#define EVT_TABLET 1
/* MOUSE : 0x00x */
#define LEFTMOUSE 0x001
#define MIDDLEMOUSE 0x002
#define RIGHTMOUSE 0x003
#define MOUSEMOVE 0x004
/* only use if you want user option switch possible */
#define ACTIONMOUSE 0x005
#define SELECTMOUSE 0x006
#define WHEELUPMOUSE 0x00a
#define WHEELDOWNMOUSE 0x00b
/* SYSTEM : 0x01x */
#define KEYBD 0x010 /* keyboard */
#define RAWKEYBD 0x011 /* raw keyboard for keyboard manager */
#define REDRAW 0x012 /* used by port manager to signal redraws */
#define INPUTCHANGE 0x013 /* input connected or disconnected */
#define QFULL 0x014 /* queue was filled */
#define WINFREEZE 0x015 /* user wants process in this win to shut up */
#define WINTHAW 0x016 /* user wants process in this win to go again */
#define WINCLOSE 0x017 /* window close */
#define WINQUIT 0x018 /* signal from user that app is to go away */
#define Q_FIRSTTIME 0x019 /* on startup */
/* standard keyboard */
#define AKEY 'a'
#define BKEY 'b'
#define CKEY 'c'
#define DKEY 'd'
#define EKEY 'e'
#define FKEY 'f'
#define GKEY 'g'
#define HKEY 'h'
#define IKEY 'i'
#define JKEY 'j'
#define KKEY 'k'
#define LKEY 'l'
#define MKEY 'm'
#define NKEY 'n'
#define OKEY 'o'
#define PKEY 'p'
#define QKEY 'q'
#define RKEY 'r'
#define SKEY 's'
#define TKEY 't'
#define UKEY 'u'
#define VKEY 'v'
#define WKEY 'w'
#define XKEY 'x'
#define YKEY 'y'
#define ZKEY 'z'
#define ZEROKEY '0'
#define ONEKEY '1'
#define TWOKEY '2'
#define THREEKEY '3'
#define FOURKEY '4'
#define FIVEKEY '5'
#define SIXKEY '6'
#define SEVENKEY '7'
#define EIGHTKEY '8'
#define NINEKEY '9'
#define CAPSLOCKKEY 211
#define LEFTCTRLKEY 212
#define LEFTALTKEY 213
#define RIGHTALTKEY 214
#define RIGHTCTRLKEY 215
#define RIGHTSHIFTKEY 216
#define LEFTSHIFTKEY 217
#define ESCKEY 218
#define TABKEY 219
#define RETKEY 220
#define SPACEKEY 221
#define LINEFEEDKEY 222
#define BACKSPACEKEY 223
#define DELKEY 224
#define SEMICOLONKEY 225
#define PERIODKEY 226
#define COMMAKEY 227
#define QUOTEKEY 228
#define ACCENTGRAVEKEY 229
#define MINUSKEY 230
#define SLASHKEY 232
#define BACKSLASHKEY 233
#define EQUALKEY 234
#define LEFTBRACKETKEY 235
#define RIGHTBRACKETKEY 236
#define LEFTARROWKEY 137
#define DOWNARROWKEY 138
#define RIGHTARROWKEY 139
#define UPARROWKEY 140
#define PAD0 150
#define PAD1 151
#define PAD2 152
#define PAD3 153
#define PAD4 154
#define PAD5 155
#define PAD6 156
#define PAD7 157
#define PAD8 158
#define PAD9 159
#define PADPERIOD 199
#define PADSLASHKEY 161
#define PADASTERKEY 160
#define PADMINUS 162
#define PADENTER 163
#define PADPLUSKEY 164
#define F1KEY 300
#define F2KEY 301
#define F3KEY 302
#define F4KEY 303
#define F5KEY 304
#define F6KEY 305
#define F7KEY 306
#define F8KEY 307
#define F9KEY 308
#define F10KEY 309
#define F11KEY 310
#define F12KEY 311
#define PAUSEKEY 165
#define INSERTKEY 166
#define HOMEKEY 167
#define PAGEUPKEY 168
#define PAGEDOWNKEY 169
#define ENDKEY 170
#define UNKNOWNKEY 171
#define COMMANDKEY 172
#define GRLESSKEY 173
/* used as fake leftmouse events, special handled in interface.c */
#define BUT_ACTIVATE 200
#define BUT_NEXT 201
#define BUT_PREV 202
/* **************** BLENDER QUEUE EVENTS ********************* */
#define CHANGED 0x4000
#define DRAWEDGES 0x4001
#define AFTERQUEUE 0x4002
#define BACKBUFDRAW 0x4003
#define EXECUTE 0x4004
#define IGNORE_REDRAW 0x4005
#define LOAD_FILE 0x4006
#define RESHAPE 0x4007
#define UI_BUT_EVENT 0x4008
#define AUTOSAVE_FILE 0x4009
#define UNDOPUSH 0x400A
/* REDRAWVIEW3D has to be the first one (lowest number) for buttons! */
#define REDRAWVIEW3D 0x4010
#define REDRAWVIEWCAM 0x4011
#define REDRAWVIEW3D_Z 0x4012
#define REDRAWALL 0x4013
#define REDRAWHEADERS 0x4014
#define REDRAWBUTSHEAD 0x4015
#define REDRAWBUTSALL 0x4016
#define REDRAWBUTSSCENE 0x4017
#define REDRAWBUTSOBJECT 0x4018
#define REDRAWBUTSEDIT 0x4019
#define REDRAWBUTSSCRIPT 0x401A
#define REDRAWBUTSLOGIC 0x401B
#define REDRAWBUTSSHADING 0x401C
#define REDRAWBUTSGAME 0x401D
#define REDRAWBUTSEFFECTS 0x401D
#define REDRAWINFO 0x4021
#define RENDERPREVIEW 0x4022
#define REDRAWIPO 0x4023
#define REDRAWDATASELECT 0x4024
#define REDRAWSEQ 0x4025
#define REDRAWIMAGE 0x4026
#define REDRAWOOPS 0x4027
#define REDRAWIMASEL 0x4028
#define AFTERIMASELIMA 0x4029
#define AFTERIMASELGET 0x402A
#define AFTERIMAWRITE 0x402B
#define IMALEFTMOUSE 0x402C
#define AFTERPIBREAD 0x402D
#define REDRAWTEXT 0x402E
#define REDRAWSOUND 0x402F
#define REDRAWACTION 0x4030
#define REDRAWNLA 0x4031
#define REDRAWSCRIPT 0x4032
#define REDRAWTIME 0x4033
#define REDRAWBUTSCONSTRAINT 0x4034
#define ONLOAD_SCRIPT 0x4035
#define SCREEN_HANDLER 0x4036
#define REDRAWANIM 0x4037
#define REDRAWNODE 0x4038
#define RECALC_COMPOSITE 0x4039
#define REDRAWMARKER 0x4040 /* all views that display markers */
#define REDRAWVIEW3D_IMAGE 0x4041
#endif /* WM_EVENT_TYPES_H */

36
source/blender/windowmanager/wm_files.h Normal file
View File

@@ -0,0 +1,36 @@
/**
* $Id:
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_FILES_H
#define WM_FILES_H
extern void read_Blog(void);
extern void delete_autosave(void);
#endif /* WM_FILES_H */

59
source/blender/windowmanager/wm_window.h Normal file
View File

@@ -0,0 +1,59 @@
/**
* $Id: wm_window.h
*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* The Original Code is Copyright (C) 2007 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef WM_WINDOW_H
#define WM_WINDOW_H
struct bScreen;
/* *************** internal api ************** */
void wm_ghost_init (bContext *C);
wmWindow *wm_window_new (bContext *C, struct bScreen *screen);
void wm_window_free (bContext *C, wmWindow *win);
void wm_window_add_ghostwindows (wmWindowManager *wm);
void wm_window_process_events (int wait_for_event);
void wm_window_make_drawable(bContext *C, wmWindow *win);
void wm_window_raise (wmWindow *win);
void wm_window_lower (wmWindow *win);
void wm_window_set_size (wmWindow *win, int width, int height);
void wm_window_get_size (wmWindow *win, int *width_r, int *height_r);
void wm_window_get_position (wmWindow *win, int *posx_r, int *posy_r);
void wm_window_set_title (wmWindow *win, char *title);
void wm_window_swap_buffers (wmWindow *win);
wmWindow *wm_window_copy (bContext *C, wmWindow *winorig);
/* *************** window operators ************** */
int wm_window_duplicate_op (bContext *C, wmOperator *op);
#endif /* WM_WINDOW_H */