← Back to branch summary

~siretart/ubuntu/utopic/blender/libav10

« back to all changes in this revision

Viewing changes to source/blender/editors/space_sequencer/space_sequencer.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-07-23 08:54:18 UTC
  • mfrom: (14.2.16 sid)
  • mto: (14.2.19 sid)
  • mto: This revision was merged to the branch mainline in revision 42.
  • Revision ID: package-import@ubuntu.com-20120723085418-9foz30v6afaf5ffs
Tags: 2.63a-2
http://bugs.debian.org/658075
* debian/: Cycles support added (Closes: #658075)
  For now, this top feature has been enabled only
  on [any-amd64 any-i386] architectures because
  of OpenImageIO failing on all others
* debian/: scripts installation path changed
  from /usr/lib to /usr/share:
  + debian/patches/: patchset re-worked for path changing
  + debian/control: "Breaks" field added on yafaray-exporter

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/editors/space_sequencer/space_sequencer.c
1
 
/**
2
 
 * $Id: space_sequencer.c 30594 2010-07-21 17:37:40Z blendix $
3
 
 *
 
1
/*
4
2
 * ***** BEGIN GPL LICENSE BLOCK *****
5
3
 *
6
4
 * This program is free software; you can redistribute it and/or
26
24
 * ***** END GPL LICENSE BLOCK *****
27
25
 */
28
26
 
 
27
/** \file blender/editors/space_sequencer/space_sequencer.c
 
28
 *  \ingroup spseq
 
29
 */
 
30
 
 
31
 
29
32
#include <string.h>
30
33
#include <stdio.h>
31
34
 
35
38
 
36
39
#include "BLI_blenlib.h"
37
40
#include "BLI_math.h"
38
 
#include "BLI_path_util.h"
 
41
#include "BLI_utildefines.h"
39
42
 
40
43
#include "BKE_context.h"
41
44
#include "BKE_screen.h"
42
45
#include "BKE_sequencer.h"
43
46
#include "BKE_global.h"
44
47
 
 
48
#include "ED_space_api.h"
 
49
#include "ED_sequencer.h"
45
50
#include "ED_screen.h"
46
51
#include "ED_view3d.h" /* only for sequencer view3d drawing callback */
47
52
 
51
56
#include "UI_resources.h"
52
57
#include "UI_view2d.h"
53
58
 
54
 
#include "sequencer_intern.h"   // own include
 
59
#include "sequencer_intern.h"   // own include
55
60
 
56
61
/* ******************** manage regions ********************* */
57
62
 
58
63
ARegion *sequencer_has_buttons_region(ScrArea *sa)
59
64
{
60
65
        ARegion *ar, *arnew;
61
 
        
62
 
        for(ar= sa->regionbase.first; ar; ar= ar->next)
63
 
                if(ar->regiontype==RGN_TYPE_UI)
64
 
                        return ar;
 
66
 
 
67
        ar = BKE_area_find_region_type(sa, RGN_TYPE_UI);
 
68
        if (ar) return ar;
65
69
        
66
70
        /* add subdiv level; after header */
67
 
        for(ar= sa->regionbase.first; ar; ar= ar->next)
68
 
                if(ar->regiontype==RGN_TYPE_HEADER)
69
 
                        break;
70
 
        
 
71
        ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
 
72
 
71
73
        /* is error! */
72
 
        if(ar==NULL) return NULL;
 
74
        if (ar == NULL) return NULL;
73
75
        
74
 
        arnew= MEM_callocN(sizeof(ARegion), "buttons for sequencer");
 
76
        arnew = MEM_callocN(sizeof(ARegion), "buttons for sequencer");
75
77
        
76
78
        BLI_insertlinkafter(&sa->regionbase, ar, arnew);
77
 
        arnew->regiontype= RGN_TYPE_UI;
78
 
        arnew->alignment= RGN_ALIGN_RIGHT;
 
79
        arnew->regiontype = RGN_TYPE_UI;
 
80
        arnew->alignment = RGN_ALIGN_RIGHT;
79
81
        
80
82
        arnew->flag = RGN_FLAG_HIDDEN;
81
83
        
82
84
        return arnew;
83
85
}
84
86
 
85
 
ARegion *sequencer_find_region(ScrArea *sa, short type)
 
87
static ARegion *sequencer_find_region(ScrArea *sa, short type)
86
88
{
87
 
        ARegion *ar=NULL;
 
89
        ARegion *ar = NULL;
88
90
        
89
 
        for(ar= sa->regionbase.first; ar; ar= ar->next)
90
 
                if(ar->regiontype==type)
 
91
        for (ar = sa->regionbase.first; ar; ar = ar->next)
 
92
                if (ar->regiontype == type)
91
93
                        return ar;
92
94
 
93
95
        return ar;
94
96
}
95
97
 
96
 
void ED_sequencer_update_view(bContext *C, int view)
97
 
{
98
 
        ScrArea *sa= CTX_wm_area(C);
99
 
        
100
 
        ARegion *ar_main= sequencer_find_region(sa, RGN_TYPE_WINDOW);
101
 
        ARegion *ar_preview= sequencer_find_region(sa, RGN_TYPE_PREVIEW);
102
 
 
103
 
        switch (view) {
104
 
                case SEQ_VIEW_SEQUENCE:
105
 
                        if (ar_main && (ar_main->flag & RGN_FLAG_HIDDEN)) {
106
 
                                ar_main->flag &= ~RGN_FLAG_HIDDEN;
107
 
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
108
 
                        }
109
 
                        if (ar_preview && !(ar_preview->flag & RGN_FLAG_HIDDEN)) {
110
 
                                ar_preview->flag |= RGN_FLAG_HIDDEN;
111
 
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
112
 
                                WM_event_remove_handlers(C, &ar_preview->handlers);
113
 
                        }
114
 
                        if (ar_main) ar_main->alignment= RGN_ALIGN_NONE;
115
 
                        if (ar_preview) ar_preview->alignment= RGN_ALIGN_NONE;
116
 
                        break;
117
 
                case SEQ_VIEW_PREVIEW:
118
 
                        if (ar_main && !(ar_main->flag & RGN_FLAG_HIDDEN)) {
119
 
                                ar_main->flag |= RGN_FLAG_HIDDEN;
120
 
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
121
 
                                WM_event_remove_handlers(C, &ar_main->handlers);
122
 
                        }
123
 
                        if (ar_preview && (ar_preview->flag & RGN_FLAG_HIDDEN)) {
124
 
                                ar_preview->flag &= ~RGN_FLAG_HIDDEN;
125
 
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
126
 
                                ar_preview->v2d.cur = ar_preview->v2d.tot;
127
 
                        }
128
 
                        if (ar_main) ar_main->alignment= RGN_ALIGN_NONE;
129
 
                        if (ar_preview) ar_preview->alignment= RGN_ALIGN_NONE;
130
 
                        break;
131
 
                case SEQ_VIEW_SEQUENCE_PREVIEW:
132
 
                        if (ar_main && (ar_main->flag & RGN_FLAG_HIDDEN)) {
133
 
                                ar_main->flag &= ~RGN_FLAG_HIDDEN;
134
 
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
135
 
                        }
136
 
                        if (ar_preview && (ar_preview->flag & RGN_FLAG_HIDDEN)) {
137
 
                                ar_preview->flag &= ~RGN_FLAG_HIDDEN;
138
 
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
139
 
                                ar_preview->v2d.cur = ar_preview->v2d.tot;
140
 
                        }
141
 
                        if (ar_main) ar_main->alignment= RGN_ALIGN_NONE;
142
 
                        if (ar_preview) ar_preview->alignment= RGN_ALIGN_TOP;
143
 
                        break;
144
 
        }
145
 
 
146
 
        ED_area_initialize(CTX_wm_manager(C), CTX_wm_window(C), sa);
147
 
        ED_area_tag_redraw(sa);
148
 
}
149
 
 
150
 
 
151
98
/* ******************** default callbacks for sequencer space ***************** */
152
99
 
153
100
static SpaceLink *sequencer_new(const bContext *C)
154
101
{
155
 
        Scene *scene= CTX_data_scene(C);
 
102
        Scene *scene = CTX_data_scene(C);
156
103
        ARegion *ar;
157
104
        SpaceSeq *sseq;
158
105
        
159
 
        sseq= MEM_callocN(sizeof(SpaceSeq), "initsequencer");
160
 
        sseq->spacetype= SPACE_SEQ;
161
 
        sseq->zoom= 4;
 
106
        sseq = MEM_callocN(sizeof(SpaceSeq), "initsequencer");
 
107
        sseq->spacetype = SPACE_SEQ;
162
108
        sseq->chanshown = 0;
163
109
        sseq->view = SEQ_VIEW_SEQUENCE;
164
110
        sseq->mainb = SEQ_DRAW_IMG_IMBUF;
165
111
        /* header */
166
 
        ar= MEM_callocN(sizeof(ARegion), "header for sequencer");
 
112
        ar = MEM_callocN(sizeof(ARegion), "header for sequencer");
167
113
        
168
114
        BLI_addtail(&sseq->regionbase, ar);
169
 
        ar->regiontype= RGN_TYPE_HEADER;
170
 
        ar->alignment= RGN_ALIGN_BOTTOM;
 
115
        ar->regiontype = RGN_TYPE_HEADER;
 
116
        ar->alignment = RGN_ALIGN_BOTTOM;
171
117
        
172
118
        /* buttons/list view */
173
 
        ar= MEM_callocN(sizeof(ARegion), "buttons for sequencer");
 
119
        ar = MEM_callocN(sizeof(ARegion), "buttons for sequencer");
174
120
        
175
121
        BLI_addtail(&sseq->regionbase, ar);
176
 
        ar->regiontype= RGN_TYPE_UI;
177
 
        ar->alignment= RGN_ALIGN_RIGHT;
 
122
        ar->regiontype = RGN_TYPE_UI;
 
123
        ar->alignment = RGN_ALIGN_RIGHT;
178
124
        ar->flag = RGN_FLAG_HIDDEN;
179
125
        
180
126
        /* preview area */
181
127
        /* NOTE: if you change values here, also change them in sequencer_init_preview_region */
182
 
        ar= MEM_callocN(sizeof(ARegion), "preview area for sequencer");
 
128
        ar = MEM_callocN(sizeof(ARegion), "preview area for sequencer");
183
129
        BLI_addtail(&sseq->regionbase, ar);
184
 
        ar->regiontype= RGN_TYPE_PREVIEW;
185
 
        ar->alignment= RGN_ALIGN_TOP;
 
130
        ar->regiontype = RGN_TYPE_PREVIEW;
 
131
        ar->alignment = RGN_ALIGN_TOP;
186
132
        ar->flag |= RGN_FLAG_HIDDEN;
187
133
        /* for now, aspect ratio should be maintained, and zoom is clamped within sane default limits */
188
 
        ar->v2d.keepzoom= V2D_KEEPASPECT | V2D_KEEPZOOM;
189
 
        ar->v2d.minzoom= 0.00001f;
190
 
        ar->v2d.maxzoom= 100000.0f;
191
 
        ar->v2d.tot.xmin= -960.0f; /* 1920 width centered */
192
 
        ar->v2d.tot.ymin= -540.0f; /* 1080 height centered */
193
 
        ar->v2d.tot.xmax= 960.0f;
194
 
        ar->v2d.tot.ymax= 540.0f;
195
 
        ar->v2d.min[0]= 0.0f;
196
 
        ar->v2d.min[1]= 0.0f;
197
 
        ar->v2d.max[0]= 12000.0f;
198
 
        ar->v2d.max[1]= 12000.0f;
199
 
        ar->v2d.cur= ar->v2d.tot;
200
 
        ar->v2d.align= V2D_ALIGN_FREE; 
201
 
        ar->v2d.keeptot= V2D_KEEPTOT_FREE;
 
134
        ar->v2d.keepzoom = V2D_KEEPASPECT | V2D_KEEPZOOM;
 
135
        ar->v2d.minzoom = 0.00001f;
 
136
        ar->v2d.maxzoom = 100000.0f;
 
137
        ar->v2d.tot.xmin = -960.0f; /* 1920 width centered */
 
138
        ar->v2d.tot.ymin = -540.0f; /* 1080 height centered */
 
139
        ar->v2d.tot.xmax = 960.0f;
 
140
        ar->v2d.tot.ymax = 540.0f;
 
141
        ar->v2d.min[0] = 0.0f;
 
142
        ar->v2d.min[1] = 0.0f;
 
143
        ar->v2d.max[0] = 12000.0f;
 
144
        ar->v2d.max[1] = 12000.0f;
 
145
        ar->v2d.cur = ar->v2d.tot;
 
146
        ar->v2d.align = V2D_ALIGN_FREE;
 
147
        ar->v2d.keeptot = V2D_KEEPTOT_FREE;
202
148
 
203
149
 
204
150
        /* main area */
205
 
        ar= MEM_callocN(sizeof(ARegion), "main area for sequencer");
 
151
        ar = MEM_callocN(sizeof(ARegion), "main area for sequencer");
206
152
        
207
153
        BLI_addtail(&sseq->regionbase, ar);
208
 
        ar->regiontype= RGN_TYPE_WINDOW;
 
154
        ar->regiontype = RGN_TYPE_WINDOW;
209
155
        
210
156
        
211
157
        /* seq space goes from (0,8) to (0, efra) */
212
158
        
213
 
        ar->v2d.tot.xmin= 0.0f;
214
 
        ar->v2d.tot.ymin= 0.0f;
215
 
        ar->v2d.tot.xmax= scene->r.efra;
216
 
        ar->v2d.tot.ymax= 8.0f;
217
 
        
218
 
        ar->v2d.cur= ar->v2d.tot;
219
 
        
220
 
        ar->v2d.min[0]= 10.0f;
221
 
        ar->v2d.min[1]= 4.0f;
222
 
        
223
 
        ar->v2d.max[0]= MAXFRAMEF;
224
 
        ar->v2d.max[1]= MAXSEQ;
225
 
        
226
 
        ar->v2d.minzoom= 0.01f;
227
 
        ar->v2d.maxzoom= 100.0f;
228
 
        
229
 
        ar->v2d.scroll |= (V2D_SCROLL_BOTTOM|V2D_SCROLL_SCALE_HORIZONTAL);
230
 
        ar->v2d.scroll |= (V2D_SCROLL_LEFT|V2D_SCROLL_SCALE_VERTICAL);
231
 
        ar->v2d.keepzoom= 0;
232
 
        ar->v2d.keeptot= 0;
233
 
        ar->v2d.align= V2D_ALIGN_NO_NEG_Y;
 
159
        ar->v2d.tot.xmin = 0.0f;
 
160
        ar->v2d.tot.ymin = 0.0f;
 
161
        ar->v2d.tot.xmax = scene->r.efra;
 
162
        ar->v2d.tot.ymax = 8.0f;
 
163
        
 
164
        ar->v2d.cur = ar->v2d.tot;
 
165
        
 
166
        ar->v2d.min[0] = 10.0f;
 
167
        ar->v2d.min[1] = 0.5f;
 
168
        
 
169
        ar->v2d.max[0] = MAXFRAMEF;
 
170
        ar->v2d.max[1] = MAXSEQ;
 
171
        
 
172
        ar->v2d.minzoom = 0.01f;
 
173
        ar->v2d.maxzoom = 100.0f;
 
174
 
 
175
        ar->v2d.scroll |= (V2D_SCROLL_BOTTOM | V2D_SCROLL_SCALE_HORIZONTAL);
 
176
        ar->v2d.scroll |= (V2D_SCROLL_LEFT | V2D_SCROLL_SCALE_VERTICAL);
 
177
        ar->v2d.keepzoom = 0;
 
178
        ar->v2d.keeptot = 0;
 
179
        ar->v2d.align = V2D_ALIGN_NO_NEG_Y;
234
180
 
235
181
        return (SpaceLink *)sseq;
236
182
}
237
183
 
238
184
/* not spacelink itself */
239
 
static void sequencer_free(SpaceLink *sl)
 
185
static void sequencer_free(SpaceLink *UNUSED(sl))
240
186
{       
241
187
//      SpaceSeq *sseq= (SpaceSequencer*) sl;
242
188
        
243
 
// XXX  if(sseq->gpd) free_gpencil_data(sseq->gpd);
 
189
// XXX  if (sseq->gpd) free_gpencil_data(sseq->gpd);
244
190
 
245
191
}
246
192
 
247
193
 
248
194
/* spacetype; init callback */
249
 
static void sequencer_init(struct wmWindowManager *wm, ScrArea *sa)
 
195
static void sequencer_init(struct wmWindowManager *UNUSED(wm), ScrArea *UNUSED(sa))
250
196
{
251
197
        
252
198
}
253
199
 
 
200
static void sequencer_refresh(const bContext *C, ScrArea *sa)
 
201
{
 
202
        wmWindowManager *wm = CTX_wm_manager(C);
 
203
        wmWindow *window = CTX_wm_window(C);
 
204
        SpaceSeq *sseq = (SpaceSeq *)sa->spacedata.first;
 
205
        ARegion *ar_main = sequencer_find_region(sa, RGN_TYPE_WINDOW);
 
206
        ARegion *ar_preview = sequencer_find_region(sa, RGN_TYPE_PREVIEW);
 
207
        int view_changed = 0;
 
208
 
 
209
        switch (sseq->view) {
 
210
                case SEQ_VIEW_SEQUENCE:
 
211
                        if (ar_main && (ar_main->flag & RGN_FLAG_HIDDEN)) {
 
212
                                ar_main->flag &= ~RGN_FLAG_HIDDEN;
 
213
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
 
214
                                view_changed = 1;
 
215
                        }
 
216
                        if (ar_preview && !(ar_preview->flag & RGN_FLAG_HIDDEN)) {
 
217
                                ar_preview->flag |= RGN_FLAG_HIDDEN;
 
218
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
 
219
                                WM_event_remove_handlers((bContext *)C, &ar_preview->handlers);
 
220
                                view_changed = 1;
 
221
                        }
 
222
                        if (ar_main && ar_main->alignment != RGN_ALIGN_NONE) {
 
223
                                ar_main->alignment = RGN_ALIGN_NONE;
 
224
                                view_changed = 1;
 
225
                        }
 
226
                        if (ar_preview && ar_preview->alignment != RGN_ALIGN_NONE) {
 
227
                                ar_preview->alignment = RGN_ALIGN_NONE;
 
228
                                view_changed = 1;
 
229
                        }
 
230
                        break;
 
231
                case SEQ_VIEW_PREVIEW:
 
232
                        if (ar_main && !(ar_main->flag & RGN_FLAG_HIDDEN)) {
 
233
                                ar_main->flag |= RGN_FLAG_HIDDEN;
 
234
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
 
235
                                WM_event_remove_handlers((bContext *)C, &ar_main->handlers);
 
236
                                view_changed = 1;
 
237
                        }
 
238
                        if (ar_preview && (ar_preview->flag & RGN_FLAG_HIDDEN)) {
 
239
                                ar_preview->flag &= ~RGN_FLAG_HIDDEN;
 
240
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
 
241
                                ar_preview->v2d.cur = ar_preview->v2d.tot;
 
242
                                view_changed = 1;
 
243
                        }
 
244
                        if (ar_main && ar_main->alignment != RGN_ALIGN_NONE) {
 
245
                                ar_main->alignment = RGN_ALIGN_NONE;
 
246
                                view_changed = 1;
 
247
                        }
 
248
                        if (ar_preview && ar_preview->alignment != RGN_ALIGN_NONE) {
 
249
                                ar_preview->alignment = RGN_ALIGN_NONE;
 
250
                                view_changed = 1;
 
251
                        }
 
252
                        break;
 
253
                case SEQ_VIEW_SEQUENCE_PREVIEW:
 
254
                        if (ar_main && (ar_main->flag & RGN_FLAG_HIDDEN)) {
 
255
                                ar_main->flag &= ~RGN_FLAG_HIDDEN;
 
256
                                ar_main->v2d.flag &= ~V2D_IS_INITIALISED;
 
257
                                view_changed = 1;
 
258
                        }
 
259
                        if (ar_preview && (ar_preview->flag & RGN_FLAG_HIDDEN)) {
 
260
                                ar_preview->flag &= ~RGN_FLAG_HIDDEN;
 
261
                                ar_preview->v2d.flag &= ~V2D_IS_INITIALISED;
 
262
                                ar_preview->v2d.cur = ar_preview->v2d.tot;
 
263
                                view_changed = 1;
 
264
                        }
 
265
                        if (ar_main && ar_main->alignment != RGN_ALIGN_NONE) {
 
266
                                ar_main->alignment = RGN_ALIGN_NONE;
 
267
                                view_changed = 1;
 
268
                        }
 
269
                        if (ar_preview && ar_preview->alignment != RGN_ALIGN_TOP) {
 
270
                                ar_preview->alignment = RGN_ALIGN_TOP;
 
271
                                view_changed = 1;
 
272
                        }
 
273
                        break;
 
274
        }
 
275
 
 
276
        if (view_changed) {
 
277
                ED_area_initialize(wm, window, sa);
 
278
                ED_area_tag_redraw(sa);
 
279
        }
 
280
}
 
281
 
254
282
static SpaceLink *sequencer_duplicate(SpaceLink *sl)
255
283
{
256
 
        SpaceSeq *sseqn= MEM_dupallocN(sl);
 
284
        SpaceSeq *sseqn = MEM_dupallocN(sl);
257
285
        
258
286
        /* clear or remove stuff from old */
259
287
// XXX  sseq->gpd= gpencil_data_duplicate(sseq->gpd);
272
300
        
273
301
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_CUSTOM, ar->winx, ar->winy);
274
302
        
275
 
        keymap= WM_keymap_find(wm->defaultconf, "SequencerCommon", SPACE_SEQ, 0);
 
303
        keymap = WM_keymap_find(wm->defaultconf, "SequencerCommon", SPACE_SEQ, 0);
276
304
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
277
305
        
278
306
        /* own keymap */
279
 
        keymap= WM_keymap_find(wm->defaultconf, "Sequencer", SPACE_SEQ, 0);
 
307
        keymap = WM_keymap_find(wm->defaultconf, "Sequencer", SPACE_SEQ, 0);
280
308
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
281
309
        
282
310
        /* add drop boxes */
283
 
        lb= WM_dropboxmap_find("Sequencer", SPACE_SEQ, RGN_TYPE_WINDOW);
 
311
        lb = WM_dropboxmap_find("Sequencer", SPACE_SEQ, RGN_TYPE_WINDOW);
284
312
        
285
313
        WM_event_add_dropbox_handler(&ar->handlers, lb);
286
314
        
296
324
 
297
325
/* ************* dropboxes ************* */
298
326
 
299
 
static int image_drop_poll(bContext *C, wmDrag *drag, wmEvent *event)
300
 
{
301
 
        if(drag->type==WM_DRAG_PATH)
302
 
                if(ELEM(drag->icon, ICON_FILE_IMAGE, ICON_FILE_BLANK))  /* rule might not work? */
303
 
                        return 1;
304
 
        return 0;
305
 
}
306
 
 
307
 
static int movie_drop_poll(bContext *C, wmDrag *drag, wmEvent *event)
308
 
{
309
 
        if(drag->type==WM_DRAG_PATH)
310
 
                if(ELEM3(drag->icon, 0, ICON_FILE_MOVIE, ICON_FILE_BLANK))      /* rule might not work? */
311
 
                        return 1;
312
 
        return 0;
313
 
}
314
 
 
315
 
static int sound_drop_poll(bContext *C, wmDrag *drag, wmEvent *event)
316
 
{
317
 
        if(drag->type==WM_DRAG_PATH)
318
 
                if(ELEM(drag->icon, ICON_FILE_SOUND, ICON_FILE_BLANK))  /* rule might not work? */
 
327
static int image_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(event))
 
328
{
 
329
        if (drag->type == WM_DRAG_PATH)
 
330
                if (ELEM(drag->icon, ICON_FILE_IMAGE, ICON_FILE_BLANK)) /* rule might not work? */
 
331
                        return 1;
 
332
        return 0;
 
333
}
 
334
 
 
335
static int movie_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(event))
 
336
{
 
337
        if (drag->type == WM_DRAG_PATH)
 
338
                if (ELEM3(drag->icon, 0, ICON_FILE_MOVIE, ICON_FILE_BLANK)) /* rule might not work? */
 
339
                        return 1;
 
340
        return 0;
 
341
}
 
342
 
 
343
static int sound_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(event))
 
344
{
 
345
        if (drag->type == WM_DRAG_PATH)
 
346
                if (ELEM(drag->icon, ICON_FILE_SOUND, ICON_FILE_BLANK)) /* rule might not work? */
319
347
                        return 1;
320
348
        return 0;
321
349
}
323
351
static void sequencer_drop_copy(wmDrag *drag, wmDropBox *drop)
324
352
{
325
353
        /* copy drag path to properties */
326
 
        if(RNA_struct_find_property(drop->ptr, "filepath"))
 
354
        if (RNA_struct_find_property(drop->ptr, "filepath"))
327
355
                RNA_string_set(drop->ptr, "filepath", drag->path);
328
356
 
329
 
        if(RNA_struct_find_property(drop->ptr, "directory")) {
 
357
        if (RNA_struct_find_property(drop->ptr, "directory")) {
330
358
                PointerRNA itemptr;
331
359
                char dir[FILE_MAX], file[FILE_MAX];
332
360
 
333
 
                BLI_split_dirfile(drag->path, dir, file);
 
361
                BLI_split_dirfile(drag->path, dir, file, sizeof(dir), sizeof(file));
334
362
                
335
363
                RNA_string_set(drop->ptr, "directory", dir);
336
364
 
 
365
                RNA_collection_clear(drop->ptr, "files");
337
366
                RNA_collection_add(drop->ptr, "files", &itemptr);
338
367
                RNA_string_set(&itemptr, "name", file);
339
368
        }
342
371
/* this region dropbox definition */
343
372
static void sequencer_dropboxes(void)
344
373
{
345
 
        ListBase *lb= WM_dropboxmap_find("Sequencer", SPACE_SEQ, RGN_TYPE_WINDOW);
 
374
        ListBase *lb = WM_dropboxmap_find("Sequencer", SPACE_SEQ, RGN_TYPE_WINDOW);
346
375
        
347
376
        WM_dropbox_add(lb, "SEQUENCER_OT_image_strip_add", image_drop_poll, sequencer_drop_copy);
348
377
        WM_dropbox_add(lb, "SEQUENCER_OT_movie_strip_add", movie_drop_poll, sequencer_drop_copy);
352
381
/* ************* end drop *********** */
353
382
 
354
383
/* add handlers, stuff you only do once or on area/region changes */
355
 
static void sequencer_header_area_init(wmWindowManager *wm, ARegion *ar)
 
384
static void sequencer_header_area_init(wmWindowManager *UNUSED(wm), ARegion *ar)
356
385
{
357
386
        ED_region_header_init(ar);
358
387
}
365
394
static void sequencer_main_area_listener(ARegion *ar, wmNotifier *wmn)
366
395
{
367
396
        /* context changes */
368
 
        switch(wmn->category) {
 
397
        switch (wmn->category) {
369
398
                case NC_SCENE:
370
 
                        switch(wmn->data) {
 
399
                        switch (wmn->data) {
371
400
                                case ND_FRAME:
372
401
                                case ND_FRAME_RANGE:
373
402
                                case ND_MARKERS:
 
403
                                case ND_RENDER_OPTIONS: /* for FPS and FPS Base */
374
404
                                case ND_SEQUENCER:
375
405
                                        ED_region_tag_redraw(ar);
376
406
                                        break;
377
407
                        }
378
408
                        break;
379
409
                case NC_SPACE:
380
 
                        if(wmn->data == ND_SPACE_SEQUENCER)
 
410
                        if (wmn->data == ND_SPACE_SEQUENCER)
381
411
                                ED_region_tag_redraw(ar);
382
412
                        break;
383
413
                case NC_ID:
384
 
                        if(wmn->action == NA_RENAME)
 
414
                        if (wmn->action == NA_RENAME)
385
415
                                ED_region_tag_redraw(ar);
386
416
                        break;
387
417
        }
394
424
 
395
425
        UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_CUSTOM, ar->winx, ar->winy);
396
426
        
397
 
        keymap= WM_keymap_find(wm->defaultconf, "SequencerCommon", SPACE_SEQ, 0);
 
427
        keymap = WM_keymap_find(wm->defaultconf, "SequencerCommon", SPACE_SEQ, 0);
398
428
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
399
429
 
400
430
        /* own keymap */
401
 
        keymap= WM_keymap_find(wm->defaultconf, "SequencerPreview", SPACE_SEQ, 0);
 
431
        keymap = WM_keymap_find(wm->defaultconf, "SequencerPreview", SPACE_SEQ, 0);
402
432
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
403
433
}
404
434
 
405
435
static void sequencer_preview_area_draw(const bContext *C, ARegion *ar)
406
436
{
407
 
        ScrArea *sa= CTX_wm_area(C);
408
 
        SpaceSeq *sseq= sa->spacedata.first;
409
 
        Scene *scene= CTX_data_scene(C);
 
437
        ScrArea *sa = CTX_wm_area(C);
 
438
        SpaceSeq *sseq = sa->spacedata.first;
 
439
        Scene *scene = CTX_data_scene(C);
410
440
        
411
441
        /* XXX temp fix for wrong setting in sseq->mainb */
412
442
        if (sseq->mainb == SEQ_DRAW_SEQUENCE) sseq->mainb = SEQ_DRAW_IMG_IMBUF;
413
443
 
414
444
        draw_image_seq(C, scene, ar, sseq, scene->r.cfra, 0);
415
445
 
416
 
        if(scene->ed && scene->ed->over_flag & SEQ_EDIT_OVERLAY_SHOW && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
 
446
        if (scene->ed && scene->ed->over_flag & SEQ_EDIT_OVERLAY_SHOW && sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
417
447
                int over_cfra;
418
448
 
419
 
                if(scene->ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
420
 
                        over_cfra= scene->ed->over_cfra;
 
449
                if (scene->ed->over_flag & SEQ_EDIT_OVERLAY_ABS)
 
450
                        over_cfra = scene->ed->over_cfra;
421
451
                else
422
 
                        over_cfra= scene->r.cfra + scene->ed->over_ofs;
 
452
                        over_cfra = scene->r.cfra + scene->ed->over_ofs;
423
453
 
424
 
                if(over_cfra != scene->r.cfra)
 
454
                if (over_cfra != scene->r.cfra)
425
455
                        draw_image_seq(C, scene, ar, sseq, scene->r.cfra, over_cfra - scene->r.cfra);
426
456
        }
427
457
 
430
460
static void sequencer_preview_area_listener(ARegion *ar, wmNotifier *wmn)
431
461
{
432
462
        /* context changes */
433
 
        switch(wmn->category) {
 
463
        switch (wmn->category) {
434
464
                case NC_SCENE:
435
 
                        switch(wmn->data) {
 
465
                        switch (wmn->data) {
436
466
                                case ND_FRAME:
437
467
                                case ND_MARKERS:
438
468
                                case ND_SEQUENCER:
 
469
                                case ND_RENDER_OPTIONS:
439
470
                                        ED_region_tag_redraw(ar);
440
471
                                        break;
441
472
                        }
442
473
                        break;
443
474
                case NC_SPACE:
444
 
                        if(wmn->data == ND_SPACE_SEQUENCER)
 
475
                        if (wmn->data == ND_SPACE_SEQUENCER)
445
476
                                ED_region_tag_redraw(ar);
446
477
                        break;
447
478
                case NC_ID:
448
 
                        switch(wmn->data) {
 
479
                        switch (wmn->data) {
449
480
                                case NA_RENAME:
450
481
                                        ED_region_tag_redraw(ar);
451
482
                                        break;
472
503
static void sequencer_buttons_area_listener(ARegion *ar, wmNotifier *wmn)
473
504
{
474
505
        /* context changes */
475
 
        switch(wmn->category) {
 
506
        switch (wmn->category) {
476
507
                case NC_SCENE:
477
 
                switch(wmn->data) {
478
 
                        case ND_FRAME:
479
 
                        case ND_SEQUENCER:
480
 
                                ED_region_tag_redraw(ar);
481
 
                                break;
482
 
                }
483
 
                break;
 
508
                        switch (wmn->data) {
 
509
                                case ND_FRAME:
 
510
                                case ND_SEQUENCER:
 
511
                                        ED_region_tag_redraw(ar);
 
512
                                        break;
 
513
                        }
 
514
                        break;
484
515
                case NC_SPACE:
485
 
                        if(wmn->data == ND_SPACE_SEQUENCER)
 
516
                        if (wmn->data == ND_SPACE_SEQUENCER)
486
517
                                ED_region_tag_redraw(ar);
487
518
                        break;
488
519
                case NC_ID:
489
 
                        if(wmn->action == NA_RENAME)
 
520
                        if (wmn->action == NA_RENAME)
490
521
                                ED_region_tag_redraw(ar);
491
522
                        break;
492
523
        }
496
527
/* only called once, from space/spacetypes.c */
497
528
void ED_spacetype_sequencer(void)
498
529
{
499
 
        SpaceType *st= MEM_callocN(sizeof(SpaceType), "spacetype sequencer");
 
530
        SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype sequencer");
500
531
        ARegionType *art;
501
532
        
502
 
        st->spaceid= SPACE_SEQ;
 
533
        st->spaceid = SPACE_SEQ;
503
534
        strncpy(st->name, "Sequencer", BKE_ST_MAXNAME);
504
535
        
505
 
        st->new= sequencer_new;
506
 
        st->free= sequencer_free;
507
 
        st->init= sequencer_init;
508
 
        st->duplicate= sequencer_duplicate;
509
 
        st->operatortypes= sequencer_operatortypes;
510
 
        st->keymap= sequencer_keymap;
511
 
        st->dropboxes= sequencer_dropboxes;
 
536
        st->new = sequencer_new;
 
537
        st->free = sequencer_free;
 
538
        st->init = sequencer_init;
 
539
        st->duplicate = sequencer_duplicate;
 
540
        st->operatortypes = sequencer_operatortypes;
 
541
        st->keymap = sequencer_keymap;
 
542
        st->dropboxes = sequencer_dropboxes;
 
543
        st->refresh = sequencer_refresh;
512
544
 
513
545
        /* regions: main window */
514
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
 
546
        art = MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
515
547
        art->regionid = RGN_TYPE_WINDOW;
516
 
        art->init= sequencer_main_area_init;
517
 
        art->draw= sequencer_main_area_draw;
518
 
        art->listener= sequencer_main_area_listener;
519
 
        art->keymapflag= ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_ANIMATION;
 
548
        art->init = sequencer_main_area_init;
 
549
        art->draw = sequencer_main_area_draw;
 
550
        art->listener = sequencer_main_area_listener;
 
551
        art->keymapflag = ED_KEYMAP_VIEW2D | ED_KEYMAP_MARKERS | ED_KEYMAP_FRAMES | ED_KEYMAP_ANIMATION;
520
552
 
521
553
        BLI_addhead(&st->regiontypes, art);
522
554
 
523
555
        /* preview */
524
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
 
556
        art = MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
525
557
        art->regionid = RGN_TYPE_PREVIEW;
526
558
        art->prefsizey = 240; // XXX
527
 
        art->init= sequencer_preview_area_init;
528
 
        art->draw= sequencer_preview_area_draw;
529
 
        art->listener= sequencer_preview_area_listener;
530
 
        art->keymapflag= ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_ANIMATION;
 
559
        art->init = sequencer_preview_area_init;
 
560
        art->draw = sequencer_preview_area_draw;
 
561
        art->listener = sequencer_preview_area_listener;
 
562
        art->keymapflag = ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_ANIMATION;
531
563
        BLI_addhead(&st->regiontypes, art);
532
564
        
533
565
        /* regions: listview/buttons */
534
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
 
566
        art = MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
535
567
        art->regionid = RGN_TYPE_UI;
536
 
        art->prefsizex= 220; // XXX
537
 
        art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_FRAMES;
538
 
        art->listener= sequencer_buttons_area_listener;
539
 
        art->init= sequencer_buttons_area_init;
540
 
        art->draw= sequencer_buttons_area_draw;
 
568
        art->prefsizex = 220; // XXX
 
569
        art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
 
570
        art->listener = sequencer_buttons_area_listener;
 
571
        art->init = sequencer_buttons_area_init;
 
572
        art->draw = sequencer_buttons_area_draw;
541
573
        BLI_addhead(&st->regiontypes, art);
542
 
        
543
 
        /* Keep as python only for now
544
 
        sequencer_buttons_register(art);
545
 
        */
546
574
 
547
575
        /* regions: header */
548
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
 
576
        art = MEM_callocN(sizeof(ARegionType), "spacetype sequencer region");
549
577
        art->regionid = RGN_TYPE_HEADER;
550
 
        art->prefsizey= HEADERY;
551
 
        art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_HEADER;
 
578
        art->prefsizey = HEADERY;
 
579
        art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
552
580
        
553
 
        art->init= sequencer_header_area_init;
554
 
        art->draw= sequencer_header_area_draw;
555
 
        art->listener= sequencer_main_area_listener;
 
581
        art->init = sequencer_header_area_init;
 
582
        art->draw = sequencer_header_area_draw;
 
583
        art->listener = sequencer_main_area_listener;
556
584
        
557
585
        BLI_addhead(&st->regiontypes, art);
558
586
        
559
587
        BKE_spacetype_register(st);
560
588
 
561
589
        /* set the sequencer callback when not in background mode */
562
 
        if(G.background==0) {
563
 
                sequencer_view3d_cb= ED_view3d_draw_offscreen_imbuf_simple;
 
590
        if (G.background == 0) {
 
591
                sequencer_view3d_cb = ED_view3d_draw_offscreen_imbuf_simple;
564
592
        }
565
593
}
566
594