[#19688] pressing O and alt+O doesn't toggle proportional edit mode when editing...
[blender-staging.git] / source / blender / editors / space_sequencer / sequencer_draw.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation, 2003-2009
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include <string.h>
29 #include <math.h>
30
31 #include "MEM_guardedalloc.h"
32
33 #include "BLI_blenlib.h"
34 #include "BLI_arithb.h"
35
36 #include "IMB_imbuf_types.h"
37
38 #include "DNA_gpencil_types.h"
39 #include "DNA_sequence_types.h"
40 #include "DNA_scene_types.h"
41 #include "DNA_screen_types.h"
42 #include "DNA_space_types.h"
43 #include "DNA_view2d_types.h"
44 #include "DNA_userdef_types.h"
45
46 #include "BKE_context.h"
47 #include "BKE_global.h"
48 #include "BKE_plugin_types.h"
49 #include "BKE_sequence.h"
50 #include "BKE_scene.h"
51 #include "BKE_utildefines.h"
52  
53 #include "IMB_imbuf_types.h"
54 #include "IMB_imbuf.h"
55
56 #include "BIF_gl.h"
57 #include "BIF_glutil.h"
58
59 #include "ED_anim_api.h"
60 #include "ED_space_api.h"
61 #include "ED_sequencer.h"
62 #include "ED_types.h"
63
64 #include "UI_interface.h"
65 #include "UI_resources.h"
66 #include "UI_view2d.h"
67
68 /* own include */
69 #include "sequencer_intern.h"
70
71 #define SEQ_LEFTHANDLE          1
72 #define SEQ_RIGHTHANDLE 2
73
74
75 /* Note, Dont use WHILE_SEQ while drawing! - it messes up transform, - Campbell */
76
77 int no_rightbox=0, no_leftbox= 0;
78 static void draw_shadedstrip(Sequence *seq, char *col, float x1, float y1, float x2, float y2);
79
80
81 static void draw_cfra_seq(View2D *v2d, int cfra)
82 {
83         glColor3ub(0x30, 0x90, 0x50);
84         glLineWidth(2.0);
85         glBegin(GL_LINES);
86         glVertex2f(cfra, v2d->cur.ymin);
87         glVertex2f(cfra, v2d->cur.ymax);
88         glEnd();
89         glLineWidth(1.0);
90 }
91
92 static void get_seq_color3ubv(Scene *curscene, Sequence *seq, char *col)
93 {
94         char blendcol[3];
95         float hsv[3], rgb[3];
96         SolidColorVars *colvars = (SolidColorVars *)seq->effectdata;
97
98         switch(seq->type) {
99         case SEQ_IMAGE:
100                 UI_GetThemeColor3ubv(TH_SEQ_IMAGE, col);
101                 break;
102         case SEQ_META:
103                 UI_GetThemeColor3ubv(TH_SEQ_META, col);
104                 break;
105         case SEQ_MOVIE:
106                 UI_GetThemeColor3ubv(TH_SEQ_MOVIE, col);
107                 break;
108         case SEQ_SCENE:
109                 UI_GetThemeColor3ubv(TH_SEQ_SCENE, col);
110                 
111                 if(seq->scene==curscene) {
112                         UI_GetColorPtrBlendShade3ubv(col, col, col, 1.0, 20);
113                 }
114                 break;
115
116         /* transitions */
117         case SEQ_CROSS:
118         case SEQ_GAMCROSS:
119         case SEQ_WIPE:
120                 /* slightly offset hue to distinguish different effects */
121                 UI_GetThemeColor3ubv(TH_SEQ_TRANSITION, col);
122                 
123                 rgb[0] = col[0]/255.0; rgb[1] = col[1]/255.0; rgb[2] = col[2]/255.0; 
124                 rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2);
125                 
126                 if (seq->type == SEQ_CROSS)             hsv[0]+= 0.04;
127                 if (seq->type == SEQ_GAMCROSS)  hsv[0]+= 0.08;
128                 if (seq->type == SEQ_WIPE)              hsv[0]+= 0.12;
129                 
130                 if(hsv[0]>1.0) hsv[0]-=1.0; else if(hsv[0]<0.0) hsv[0]+= 1.0;
131                 hsv_to_rgb(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2);
132                 col[0] = (char)(rgb[0]*255); col[1] = (char)(rgb[1]*255); col[2] = (char)(rgb[2]*255); 
133                 break;
134                 
135         /* effects */
136         case SEQ_TRANSFORM:
137         case SEQ_SPEED:
138         case SEQ_ADD:
139         case SEQ_SUB:
140         case SEQ_MUL:
141         case SEQ_ALPHAOVER:
142         case SEQ_ALPHAUNDER:
143         case SEQ_OVERDROP:
144         case SEQ_GLOW:
145                 /* slightly offset hue to distinguish different effects */
146                 UI_GetThemeColor3ubv(TH_SEQ_EFFECT, col);
147                 
148                 rgb[0] = col[0]/255.0; rgb[1] = col[1]/255.0; rgb[2] = col[2]/255.0; 
149                 rgb_to_hsv(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2);
150                 
151                 if (seq->type == SEQ_ADD)               hsv[0]+= 0.04;
152                 if (seq->type == SEQ_SUB)               hsv[0]+= 0.08;
153                 if (seq->type == SEQ_MUL)               hsv[0]+= 0.12;
154                 if (seq->type == SEQ_ALPHAOVER) hsv[0]+= 0.16;
155                 if (seq->type == SEQ_ALPHAUNDER)        hsv[0]+= 0.20;
156                 if (seq->type == SEQ_OVERDROP)  hsv[0]+= 0.24;
157                 if (seq->type == SEQ_GLOW)              hsv[0]+= 0.28;
158                 if (seq->type == SEQ_TRANSFORM)         hsv[0]+= 0.36;
159
160                 if(hsv[0]>1.0) hsv[0]-=1.0; else if(hsv[0]<0.0) hsv[0]+= 1.0;
161                 hsv_to_rgb(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2);
162                 col[0] = (char)(rgb[0]*255); col[1] = (char)(rgb[1]*255); col[2] = (char)(rgb[2]*255); 
163                 break;
164         case SEQ_COLOR:
165                 if (colvars->col) {
166                         col[0]= (char)(colvars->col[0]*255);
167                         col[1]= (char)(colvars->col[1]*255);
168                         col[2]= (char)(colvars->col[2]*255);
169                 } else {
170                         col[0] = col[1] = col[2] = 128;
171                 }
172                 break;
173         case SEQ_PLUGIN:
174                 UI_GetThemeColor3ubv(TH_SEQ_PLUGIN, col);
175                 break;
176         case SEQ_SOUND:
177                 UI_GetThemeColor3ubv(TH_SEQ_AUDIO, col);
178                 blendcol[0] = blendcol[1] = blendcol[2] = 128;
179                 if(seq->flag & SEQ_MUTE) UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.5, 20);
180                 break;
181         default:
182                 col[0] = 10; col[1] = 255; col[2] = 40;
183         }
184 }
185
186 static void drawmeta_contents(Scene *scene, Sequence *seqm, float x1, float y1, float x2, float y2)
187 {
188         /* Note, this used to use WHILE_SEQ, but it messes up the seq->depth value, (needed by transform when doing overlap checks)
189          * so for now, just use the meta's immediate children, could be fixed but its only drawing - Campbell */
190         Sequence *seq;
191         float dx;
192         int nr;
193         char col[3];
194         
195         nr= BLI_countlist(&seqm->seqbase);
196
197         dx= (x2-x1)/nr;
198
199         if (seqm->flag & SEQ_MUTE) {
200                 glEnable(GL_POLYGON_STIPPLE);
201                 glPolygonStipple(stipple_halftone);
202                 
203                 glEnable(GL_LINE_STIPPLE);
204                 glLineStipple(1, 0x8888);
205         }
206         
207         for (seq= seqm->seqbase.first; seq; seq= seq->next) {
208                 get_seq_color3ubv(scene, seq, col);
209                 
210                 glColor3ubv((GLubyte *)col);
211
212                 glRectf(x1,  y1,  x1+0.9*dx,  y2);
213                 
214                 UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -30);
215                 glColor3ubv((GLubyte *)col);
216
217                 fdrawbox(x1,  y1,  x1+0.9*dx,  y2);
218                 
219                 x1+= dx;
220         }
221         
222         if (seqm->flag & SEQ_MUTE) {
223                 glDisable(GL_POLYGON_STIPPLE);
224                 glDisable(GL_LINE_STIPPLE);
225         }
226 }
227
228 /* draw a handle, for each end of a sequence strip */
229 static void draw_seq_handle(View2D *v2d, Sequence *seq, float pixelx, short direction)
230 {
231         float v1[2], v2[2], v3[2], rx1=0, rx2=0; //for triangles and rect
232         float x1, x2, y1, y2;
233         float handsize;
234         float minhandle, maxhandle;
235         char str[32];
236         unsigned int whichsel=0;
237         
238         x1= seq->startdisp;
239         x2= seq->enddisp;
240         
241         y1= seq->machine+SEQ_STRIP_OFSBOTTOM;
242         y2= seq->machine+SEQ_STRIP_OFSTOP;
243         
244         /* clamp handles to defined size in pixel space */
245         handsize = seq->handsize;
246         minhandle = 7;
247         maxhandle = 40;
248         CLAMP(handsize, minhandle*pixelx, maxhandle*pixelx);
249         
250         /* set up co-ordinates/dimensions for either left or right handle */
251         if (direction == SEQ_LEFTHANDLE) {      
252                 rx1 = x1;
253                 rx2 = x1+handsize*0.75;
254                 
255                 v1[0]= x1+handsize/4; v1[1]= y1+( ((y1+y2)/2.0 - y1)/2);
256                 v2[0]= x1+handsize/4; v2[1]= y2-( ((y1+y2)/2.0 - y1)/2);
257                 v3[0]= v2[0] + handsize/4; v3[1]= (y1+y2)/2.0;
258                 
259                 whichsel = SEQ_LEFTSEL;
260         } else if (direction == SEQ_RIGHTHANDLE) {      
261                 rx1 = x2-handsize*0.75;
262                 rx2 = x2;
263                 
264                 v1[0]= x2-handsize/4; v1[1]= y1+( ((y1+y2)/2.0 - y1)/2);
265                 v2[0]= x2-handsize/4; v2[1]= y2-( ((y1+y2)/2.0 - y1)/2);
266                 v3[0]= v2[0] - handsize/4; v3[1]= (y1+y2)/2.0;
267                 
268                 whichsel = SEQ_RIGHTSEL;
269         }
270         
271         /* draw! */
272         if(seq->type < SEQ_EFFECT || 
273            get_sequence_effect_num_inputs(seq->type) == 0) {
274                 glEnable( GL_BLEND );
275                 
276                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
277                 
278                 if(seq->flag & whichsel) glColor4ub(0, 0, 0, 80);
279                 else if (seq->flag & SELECT) glColor4ub(255, 255, 255, 30);
280                 else glColor4ub(0, 0, 0, 22);
281                 
282                 glRectf(rx1, y1, rx2, y2);
283                 
284                 if(seq->flag & whichsel) glColor4ub(255, 255, 255, 200);
285                 else glColor4ub(0, 0, 0, 50);
286                 
287                 glEnable( GL_POLYGON_SMOOTH );
288                 glBegin(GL_TRIANGLES);
289                 glVertex2fv(v1); glVertex2fv(v2); glVertex2fv(v3);
290                 glEnd();
291                 
292                 glDisable( GL_POLYGON_SMOOTH );
293                 glDisable( GL_BLEND );
294         }
295         
296         if(G.moving || (seq->flag & whichsel)) {
297                 cpack(0xFFFFFF);
298                 if (direction == SEQ_LEFTHANDLE) {
299                         sprintf(str, "%d", seq->startdisp);
300                         x1= rx1;
301                         y1 -= 0.45;
302                 } else {
303                         sprintf(str, "%d", seq->enddisp - 1);
304                         x1= x2 - handsize*0.75;
305                         y1= y2 + 0.05;
306                 }
307                 UI_view2d_text_cache_add(v2d, x1, y1, str);
308         }       
309 }
310
311 static void draw_seq_extensions(Scene *scene, SpaceSeq *sseq, Sequence *seq)
312 {
313         float x1, x2, y1, y2, pixely, a;
314         char col[3], blendcol[3];
315         View2D *v2d;
316         
317         if(seq->type >= SEQ_EFFECT) return;
318
319         x1= seq->startdisp;
320         x2= seq->enddisp;
321         
322         y1= seq->machine+SEQ_STRIP_OFSBOTTOM;
323         y2= seq->machine+SEQ_STRIP_OFSTOP;
324         
325         v2d = &sseq->v2d;
326         pixely = (v2d->cur.ymax - v2d->cur.ymin)/(v2d->mask.ymax - v2d->mask.ymin);
327         
328         blendcol[0] = blendcol[1] = blendcol[2] = 120;
329
330         if(seq->startofs) {
331                 glEnable( GL_BLEND );
332                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
333                 
334                 get_seq_color3ubv(scene, seq, col);
335                 
336                 if (seq->flag & SELECT) {
337                         UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.3, -40);
338                         glColor4ub(col[0], col[1], col[2], 170);
339                 } else {
340                         UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.6, 0);
341                         glColor4ub(col[0], col[1], col[2], 110);
342                 }
343                 
344                 glRectf((float)(seq->start), y1-SEQ_STRIP_OFSBOTTOM, x1, y1);
345                 
346                 if (seq->flag & SELECT) glColor4ub(col[0], col[1], col[2], 255);
347                 else glColor4ub(col[0], col[1], col[2], 160);
348
349                 fdrawbox((float)(seq->start), y1-SEQ_STRIP_OFSBOTTOM, x1, y1);  //outline
350                 
351                 glDisable( GL_BLEND );
352         }
353         if(seq->endofs) {
354                 glEnable( GL_BLEND );
355                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
356                 
357                 get_seq_color3ubv(scene, seq, col);
358                 
359                 if (seq->flag & SELECT) {
360                         UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.3, -40);
361                         glColor4ub(col[0], col[1], col[2], 170);
362                 } else {
363                         UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.6, 0);
364                         glColor4ub(col[0], col[1], col[2], 110);
365                 }
366                 
367                 glRectf(x2, y2, (float)(seq->start+seq->len), y2+SEQ_STRIP_OFSBOTTOM);
368                 
369                 if (seq->flag & SELECT) glColor4ub(col[0], col[1], col[2], 255);
370                 else glColor4ub(col[0], col[1], col[2], 160);
371
372                 fdrawbox(x2, y2, (float)(seq->start+seq->len), y2+SEQ_STRIP_OFSBOTTOM); //outline
373                 
374                 glDisable( GL_BLEND );
375         }
376         if(seq->startstill) {
377                 get_seq_color3ubv(scene, seq, col);
378                 UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.75, 40);
379                 glColor3ubv((GLubyte *)col);
380                 
381                 draw_shadedstrip(seq, col, x1, y1, (float)(seq->start), y2);
382                 
383                 /* feint pinstripes, helps see exactly which is extended and which isn't,
384                 * especially when the extension is very small */ 
385                 if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 24);
386                 else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -16);
387                 
388                 glColor3ubv((GLubyte *)col);
389                 
390                 for(a=y1; a< y2; a+= pixely*2.0 ) {
391                         fdrawline(x1,  a,  (float)(seq->start),  a);
392                 }
393         }
394         if(seq->endstill) {
395                 get_seq_color3ubv(scene, seq, col);
396                 UI_GetColorPtrBlendShade3ubv(col, blendcol, col, 0.75, 40);
397                 glColor3ubv((GLubyte *)col);
398                 
399                 draw_shadedstrip(seq, col, (float)(seq->start+seq->len), y1, x2, y2);
400                 
401                 /* feint pinstripes, helps see exactly which is extended and which isn't,
402                 * especially when the extension is very small */ 
403                 if (seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 24);
404                 else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -16);
405                 
406                 glColor3ubv((GLubyte *)col);
407                 
408                 for(a=y1; a< y2; a+= pixely*2.0 ) {
409                         fdrawline((float)(seq->start+seq->len),  a,  x2,  a);
410                 }
411         }
412 }
413
414 /* draw info text on a sequence strip */
415 static void draw_seq_text(View2D *v2d, Sequence *seq, float x1, float x2, float y1, float y2, char *background_col)
416 {
417         rctf rect;
418         char str[32 + FILE_MAXDIR+FILE_MAXFILE];
419         
420         if(seq->name[2]) {
421                 sprintf(str, "%d | %s: %s", seq->len, give_seqname(seq), seq->name+2);
422         }
423         else{
424                 if(seq->type == SEQ_META) {
425                         sprintf(str, "%d | %s", seq->len, give_seqname(seq));
426                 }
427                 else if(seq->type == SEQ_SCENE) {
428                         if(seq->scene) sprintf(str, "%d | %s: %s", seq->len, give_seqname(seq), seq->scene->id.name+2);
429                         else sprintf(str, "%d | %s", seq->len, give_seqname(seq));
430                         
431                 }
432                 else if(seq->type == SEQ_IMAGE) {
433                         sprintf(str, "%d | %s%s", seq->len, seq->strip->dir, seq->strip->stripdata->name);
434                 }
435                 else if(seq->type & SEQ_EFFECT) {
436                         int can_float = (seq->type != SEQ_PLUGIN)
437                                 || (seq->plugin && seq->plugin->version >= 4);
438
439                         if(seq->seq3!=seq->seq2 && seq->seq1!=seq->seq3)
440                                 sprintf(str, "%d | %s: %d>%d (use %d)%s", seq->len, give_seqname(seq), seq->seq1->machine, seq->seq2->machine, seq->seq3->machine, can_float ? "" : " No float, upgrade plugin!");
441                         else if (seq->seq1 && seq->seq2)
442                                 sprintf(str, "%d | %s: %d>%d%s", seq->len, give_seqname(seq), seq->seq1->machine, seq->seq2->machine, can_float ? "" : " No float, upgrade plugin!");
443                         else 
444                                 sprintf(str, "%d | %s", seq->len, give_seqname(seq));
445                 }
446                 else if (seq->type == SEQ_SOUND) {
447                         sprintf(str, "%d | %s", seq->len, seq->sound->name);
448                 }
449                 else if (seq->type == SEQ_MOVIE) {
450                         sprintf(str, "%d | %s%s", seq->len, seq->strip->dir, seq->strip->stripdata->name);
451                 }
452         }
453         
454         if(seq->flag & SELECT){
455                 cpack(0xFFFFFF);
456         }else if ((((int)background_col[0] + (int)background_col[1] + (int)background_col[2]) / 3) < 50){
457                 cpack(0x505050); /* use lighter text colour for dark background */
458         }else{
459                 cpack(0);
460         }
461         
462         rect.xmin= x1;
463         rect.ymin= y1;
464         rect.xmax= x2;
465         rect.ymax= y2;
466         UI_view2d_text_cache_rectf(v2d, &rect, str);
467 }
468
469 /* draws a shaded strip, made from gradient + flat color + gradient */
470 static void draw_shadedstrip(Sequence *seq, char *col, float x1, float y1, float x2, float y2)
471 {
472         float ymid1, ymid2;
473         
474         if (seq->flag & SEQ_MUTE) {
475                 glEnable(GL_POLYGON_STIPPLE);
476                 glPolygonStipple(stipple_halftone);
477         }
478         
479         ymid1 = (y2-y1)*0.25 + y1;
480         ymid2 = (y2-y1)*0.65 + y1;
481         
482         glShadeModel(GL_SMOOTH);
483         glBegin(GL_QUADS);
484         
485         if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -50);
486         else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 0);
487         
488         glColor3ubv((GLubyte *)col);
489         
490         glVertex2f(x1,y1);
491         glVertex2f(x2,y1);
492         
493         if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 5);
494         else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -5);
495
496         glColor3ubv((GLubyte *)col);
497         
498         glVertex2f(x2,ymid1);
499         glVertex2f(x1,ymid1);
500         
501         glEnd();
502         
503         glRectf(x1,  ymid1,  x2,  ymid2);
504         
505         glBegin(GL_QUADS);
506         
507         glVertex2f(x1,ymid2);
508         glVertex2f(x2,ymid2);
509         
510         if(seq->flag & SELECT) UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, -15);
511         else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 25);
512         
513         glColor3ubv((GLubyte *)col);
514         
515         glVertex2f(x2,y2);
516         glVertex2f(x1,y2);
517         
518         glEnd();
519         
520         if (seq->flag & SEQ_MUTE) {
521                 glDisable(GL_POLYGON_STIPPLE);
522         }
523 }
524
525 /*
526 Draw a sequence strip, bounds check alredy made
527 ARegion is currently only used to get the windows width in pixels
528 so wave file sample drawing precission is zoom adjusted
529 */
530 static void draw_seq_strip(Scene *scene, ARegion *ar, SpaceSeq *sseq, Sequence *seq, int outline_tint, float pixelx)
531 {
532         // XXX
533         extern void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown);
534         View2D *v2d= &ar->v2d;
535         float x1, x2, y1, y2;
536         char col[3], background_col[3], is_single_image;
537
538         /* we need to know if this is a single image/color or not for drawing */
539         is_single_image = (char)check_single_seq(seq);
540         
541         /* body */
542         if(seq->startstill) x1= seq->start;
543         else x1= seq->startdisp;
544         y1= seq->machine+SEQ_STRIP_OFSBOTTOM;
545         if(seq->endstill) x2= seq->start+seq->len;
546         else x2= seq->enddisp;
547         y2= seq->machine+SEQ_STRIP_OFSTOP;
548         
549         
550         /* get the correct color per strip type*/
551         //get_seq_color3ubv(scene, seq, col);
552         get_seq_color3ubv(scene, seq, background_col);
553         
554         /* draw the main strip body */
555         if (is_single_image) /* single image */
556                 draw_shadedstrip(seq, background_col, seq_tx_get_final_left(seq, 0), y1, seq_tx_get_final_right(seq, 0), y2);
557         else /* normal operation */
558                 draw_shadedstrip(seq, background_col, x1, y1, x2, y2);
559         
560         /* draw additional info and controls */
561         if (!is_single_image)
562                 draw_seq_extensions(scene, sseq, seq);
563         
564         draw_seq_handle(v2d, seq, pixelx, SEQ_LEFTHANDLE);
565         draw_seq_handle(v2d, seq, pixelx, SEQ_RIGHTHANDLE);
566         
567         /* draw the strip outline */
568         x1= seq->startdisp;
569         x2= seq->enddisp;
570         
571         get_seq_color3ubv(scene, seq, col);
572         if (G.moving && (seq->flag & SELECT)) {
573                 if(seq->flag & SEQ_OVERLAP) {
574                         col[0]= 255; col[1]= col[2]= 40;
575                 } else UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, 120);
576         }
577
578         UI_GetColorPtrBlendShade3ubv(col, col, col, 0.0, outline_tint);
579         
580         glColor3ubv((GLubyte *)col);
581         
582         if (seq->flag & SEQ_MUTE) {
583                 glEnable(GL_LINE_STIPPLE);
584                 glLineStipple(1, 0x8888);
585         }
586         
587         gl_round_box_shade(GL_LINE_LOOP, x1, y1, x2, y2, 0.0, 0.1, 0.0);
588         
589         if (seq->flag & SEQ_MUTE) {
590                 glDisable(GL_LINE_STIPPLE);
591         }
592         
593         /* calculate if seq is long enough to print a name */
594         x1= seq->startdisp+seq->handsize;
595         x2= seq->enddisp-seq->handsize;
596
597         /* but first the contents of a meta */
598         if(seq->type==SEQ_META) drawmeta_contents(scene, seq, x1, y1+0.15, x2, y2-0.15);
599
600         /* info text on the strip */
601         if(x1<v2d->cur.xmin) x1= v2d->cur.xmin;
602         else if(x1>v2d->cur.xmax) x1= v2d->cur.xmax;
603         if(x2<v2d->cur.xmin) x2= v2d->cur.xmin;
604         else if(x2>v2d->cur.xmax) x2= v2d->cur.xmax;
605
606         /* nice text here would require changing the view matrix for texture text */
607         if( (x2-x1) / pixelx > 32) {
608                 draw_seq_text(v2d, seq, x1, x2, y1, y2, background_col);
609         }
610 }
611
612 static Sequence *special_seq_update= 0;
613
614 void set_special_seq_update(int val)
615 {
616 //      int x;
617
618         /* if mouse over a sequence && LEFTMOUSE */
619         if(val) {
620 // XXX          special_seq_update= find_nearest_seq(&x);
621         }
622         else special_seq_update= 0;
623 }
624
625
626 static void draw_image_seq(Scene *scene, ARegion *ar, SpaceSeq *sseq)
627 {
628         extern void gl_round_box(int mode, float minx, float miny, float maxx, float maxy, float rad);
629         struct ImBuf *ibuf;
630         int x1, y1, rectx, recty;
631         int free_ibuf = 0;
632         static int recursive= 0;
633         float zoom;
634         float zoomx, zoomy;
635         float render_size = 0.0;
636         float proxy_size = 100.0;
637
638         glClearColor(0.0, 0.0, 0.0, 0.0);
639         glClear(GL_COLOR_BUFFER_BIT);
640
641         render_size = sseq->render_size;
642         if (render_size == 0) {
643                 render_size = scene->r.size;
644         } else {
645                 proxy_size = render_size;
646         }
647         if (render_size < 0) {
648                 return;
649         }
650
651         rectx= (render_size*scene->r.xsch)/100;
652         recty= (render_size*scene->r.ysch)/100;
653
654         /* BIG PROBLEM: the give_ibuf_seq() can call a rendering, which in turn calls redraws...
655            this shouldn't belong in a window drawing....
656            So: solve this once event based. 
657            Now we check for recursion, space type and active area again (ton) */
658         
659         if(recursive)
660                 return;
661         else {
662                 recursive= 1;
663                 if (special_seq_update) {
664                         ibuf= give_ibuf_seq_direct(scene, rectx, recty, (scene->r.cfra), proxy_size, special_seq_update);
665                 } 
666                 else if (!U.prefetchframes) { // XXX || (G.f & G_PLAYANIM) == 0) {
667                         ibuf= (ImBuf *)give_ibuf_seq(scene, rectx, recty, (scene->r.cfra), sseq->chanshown, proxy_size);
668                 } 
669                 else {
670                         ibuf= (ImBuf *)give_ibuf_seq_threaded(scene, rectx, recty, (scene->r.cfra), sseq->chanshown, proxy_size);
671                 }
672                 recursive= 0;
673                 
674                 /* XXX HURMF! the give_ibuf_seq can call image display in this window */
675 //              if(sa->spacetype!=SPACE_SEQ)
676 //                      return;
677 //              if(sa!=curarea) {
678 //                      areawinset(sa->win);
679 //              }
680         }
681         
682         if(ibuf==NULL) 
683                 return;
684
685         if(ibuf->rect==NULL && ibuf->rect_float == NULL) 
686                 return;
687         
688         switch(sseq->mainb) {
689         case SEQ_DRAW_IMG_IMBUF:
690                 if (sseq->zebra != 0) {
691                         ibuf = make_zebra_view_from_ibuf(ibuf, sseq->zebra);
692                         free_ibuf = 1;
693                 }
694                 break;
695         case SEQ_DRAW_IMG_WAVEFORM:
696                 if ((sseq->flag & SEQ_DRAW_COLOR_SEPERATED) != 0) {
697                         ibuf = make_sep_waveform_view_from_ibuf(ibuf);
698                 } else {
699                         ibuf = make_waveform_view_from_ibuf(ibuf);
700                 }
701                 free_ibuf = 1;
702                 break;
703         case SEQ_DRAW_IMG_VECTORSCOPE:
704                 ibuf = make_vectorscope_view_from_ibuf(ibuf);
705                 free_ibuf = 1;
706                 break;
707         case SEQ_DRAW_IMG_HISTOGRAM:
708                 ibuf = make_histogram_view_from_ibuf(ibuf);
709                 free_ibuf = 1;
710                 break;
711         }
712
713         if(ibuf->rect_float && ibuf->rect==NULL)
714                 IMB_rect_from_float(ibuf);
715         
716         /* needed for gla draw */
717         glaDefine2DArea(&ar->winrct);
718         
719         zoom= SEQ_ZOOM_FAC(sseq->zoom);
720         if (sseq->mainb == SEQ_DRAW_IMG_IMBUF) {
721                 zoom /= proxy_size / 100.0;
722                 zoomx = zoom * ((float)scene->r.xasp / (float)scene->r.yasp);
723                 zoomy = zoom;
724         } else {
725                 zoomx = zoomy = zoom;
726         }
727
728         /* calc location */
729         x1= (ar->winx-zoomx*ibuf->x)/2 + sseq->xof;
730         y1= (ar->winy-zoomy*ibuf->y)/2 + sseq->yof;
731         
732         glPixelZoom(zoomx, zoomy);
733         
734         glaDrawPixelsSafe(x1, y1, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
735         
736         glPixelZoom(1.0, 1.0);
737
738         /* safety border */
739         if (sseq->mainb == SEQ_DRAW_IMG_IMBUF && 
740             (sseq->flag & SEQ_DRAW_SAFE_MARGINS) != 0) {
741                 float fac= 0.1;
742                 float x2 = x1 + ibuf->x * zoomx;
743                 float y2 = y1 + ibuf->y * zoomy;
744                 
745                 float a= fac*(x2-x1);
746                 x1+= a; 
747                 x2-= a;
748         
749                 a= fac*(y2-y1);
750                 y1+= a;
751                 y2-= a;
752         
753                 glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); 
754                 setlinestyle(3);
755
756                 UI_ThemeColorBlendShade(TH_WIRE, TH_BACK, 1.0, 0);
757                 
758                 uiSetRoundBox(15);
759                 gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, 12.0);
760
761                 setlinestyle(0);
762                 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
763         }
764         
765         /* draw grease-pencil (image aligned) */
766 //      if (sseq->flag & SEQ_DRAW_GPENCIL)
767 // XXX          draw_gpencil_2dimage(sa, ibuf);
768
769         if (free_ibuf) {
770                 IMB_freeImBuf(ibuf);
771         } 
772         
773         /* draw grease-pencil (screen aligned) */
774 //      if (sseq->flag & SEQ_DRAW_GPENCIL)
775 // XXX          draw_gpencil_2dview(sa, 0);
776         
777         /* ortho at pixel level sa */
778 // XXX  myortho2(-0.375, sa->winx-0.375, -0.375, sa->winy-0.375);
779         
780 }
781
782 void seq_reset_imageofs(SpaceSeq *sseq)
783 {
784         sseq->xof = sseq->yof = sseq->zoom = 0;
785 }
786
787
788 #if 0
789 /* XXX - these should really be made to use View2D instead of so wacko private system - Aligorith */
790
791 void seq_viewzoom(SpaceSeq *sseq, unsigned short event, int invert)
792 {
793
794         if(event==PAD1)
795                 sseq->zoom= 1.0;
796         else if(event==PAD2)
797                 sseq->zoom= (invert)? 2.0: 0.5;
798         else if(event==PAD4)
799                 sseq->zoom= (invert)? 4.0: 0.25;
800         else if(event==PAD8)
801                 sseq->zoom= (invert)? 8.0: 0.125;
802         
803         /* ensure pixel exact locations for draw */
804         sseq->xof= (int)sseq->xof;
805         sseq->yof= (int)sseq->yof;
806 }
807
808 void seq_viewmove(Scene *scene, ARegion *ar, SpaceSeq *sseq)
809 {       
810         short mval[2], mvalo[2];
811         short rectx, recty, xmin, xmax, ymin, ymax, pad;
812         int oldcursor;
813         Window *win;
814         
815         sa = sseq->area;
816         rectx= (scene->r.size*scene->r.xsch)/100;
817         recty= (scene->r.size*scene->r.ysch)/100;
818         
819         pad = 10;
820         xmin = -(ar->winx/2) - rectx/2 + pad;
821         xmax = ar->winx/2 + rectx/2 - pad;
822         ymin = -(ar->winy/2) - recty/2 + pad;
823         ymax = ar->winy/2 + recty/2 - pad;
824         
825         getmouseco_sc(mvalo);
826
827         oldcursor=get_cursor();
828         win=winlay_get_active_window();
829         
830         SetBlenderCursor(BC_NSEW_SCROLLCURSOR);
831         
832         while(get_mbut()&(L_MOUSE|M_MOUSE)) {
833                 
834                 getmouseco_sc(mval);
835                 
836                 if(mvalo[0]!=mval[0] || mvalo[1]!=mval[1]) {
837
838                         sseq->xof -= (mvalo[0]-mval[0]);
839                         sseq->yof -= (mvalo[1]-mval[1]);
840                         
841                         /* prevent dragging image outside of the window and losing it! */
842                         CLAMP(sseq->xof, xmin, xmax);
843                         CLAMP(sseq->yof, ymin, ymax);
844                         
845                         mvalo[0]= mval[0];
846                         mvalo[1]= mval[1];
847                         
848                 }
849         }
850 }
851 #endif
852
853 void drawprefetchseqspace(Scene *scene, ARegion *ar, SpaceSeq *sseq)
854 {
855         int rectx, recty;
856         int render_size = sseq->render_size;
857         int proxy_size = 100.0; 
858         if (render_size == 0) {
859                 render_size = scene->r.size;
860         } else {
861                 proxy_size = render_size;
862         }
863         if (render_size < 0) {
864                 return;
865         }
866
867         rectx= (render_size*scene->r.xsch)/100;
868         recty= (render_size*scene->r.ysch)/100;
869
870         if(sseq->mainb != SEQ_DRAW_SEQUENCE) {
871                 give_ibuf_prefetch_request(
872                         rectx, recty, (scene->r.cfra), sseq->chanshown,
873                         proxy_size);
874         }
875 }
876
877 void drawseqspace(const bContext *C, ARegion *ar)
878 {
879         ScrArea *sa= CTX_wm_area(C);
880         SpaceSeq *sseq= sa->spacedata.first;
881         Scene *scene= CTX_data_scene(C);
882         View2D *v2d= &ar->v2d;
883         View2DScrollers *scrollers;
884         Editing *ed= seq_give_editing(scene, FALSE);
885         Sequence *seq;
886         float col[3];
887         int i;
888
889         if(sseq->mainb != SEQ_DRAW_SEQUENCE) {
890                 draw_image_seq(scene, ar, sseq);
891                 return;
892         }
893
894         UI_GetThemeColor3fv(TH_BACK, col);
895         if(ed && ed->metastack.first) glClearColor(col[0], col[1], col[2]-0.1, 0.0);
896         else glClearColor(col[0], col[1], col[2], 0.0);
897
898         glClear(GL_COLOR_BUFFER_BIT);
899
900         UI_view2d_view_ortho(C, v2d);
901         
902         UI_ThemeColorShade(TH_BACK, -20);
903         glRectf(v2d->cur.xmin,  0.0,  v2d->cur.xmax,  1.0);
904
905         boundbox_seq(scene, &v2d->tot);
906         
907         /* Alternating horizontal stripes */
908         i= MAX2(1, ((int)v2d->cur.ymin)-1);
909
910         glBegin(GL_QUADS);
911         while (i<v2d->cur.ymax) {
912                 if (((int)i) & 1)
913                         UI_ThemeColorShade(TH_BACK, -15);
914                 else
915                         UI_ThemeColorShade(TH_BACK, -25);
916                 
917                 glVertex2f(v2d->cur.xmax, i);
918                 glVertex2f(v2d->cur.xmin, i);
919                 glVertex2f(v2d->cur.xmin, i+1);
920                 glVertex2f(v2d->cur.xmax, i+1);
921                 i+=1.0;
922         }
923         glEnd();
924         
925         /* Force grid lines */
926         i= MAX2(1, ((int)v2d->cur.ymin)-1);
927         glBegin(GL_LINES);
928
929         while (i<v2d->cur.ymax) {
930                 UI_ThemeColor(TH_GRID);
931                 glVertex2f(v2d->cur.xmax, i);
932                 glVertex2f(v2d->cur.xmin, i);
933                 i+=1.0;
934         }
935         glEnd();
936         
937         UI_view2d_constant_grid_draw(C, v2d);
938
939         draw_cfra_seq(v2d, scene->r.cfra);
940
941         /* sequences: first deselect */
942         if(ed) {
943                 Sequence *last_seq = get_last_seq(scene);
944                 int sel = 0, j;
945                 int outline_tint;
946                 float pixelx = (v2d->cur.xmax - v2d->cur.xmin)/(v2d->mask.xmax - v2d->mask.xmin);
947                 /* loop through twice, first unselected, then selected */
948                 for (j=0; j<2; j++) {
949                         seq= ed->seqbasep->first;
950                         if (j==0)       outline_tint = -150;
951                         else            outline_tint = -60;
952                         
953                         while(seq) { /* bound box test, dont draw outside the view */
954                                 if (  ((seq->flag & SELECT) == sel) ||
955                                                 seq == last_seq ||
956                                                 MIN2(seq->startdisp, seq->start) > v2d->cur.xmax ||
957                                                 MAX2(seq->enddisp, seq->start+seq->len) < v2d->cur.xmin ||
958                                                 seq->machine+1.0 < v2d->cur.ymin ||
959                                                 seq->machine > v2d->cur.ymax)
960                                 {
961                                         /* dont draw */
962                                 } else {
963                                         draw_seq_strip(scene, ar, sseq, seq, outline_tint, pixelx);
964                                 }
965                                 seq= seq->next;
966                         }
967                         sel= SELECT; /* draw selected next time round */
968                 }
969                 /* draw the last selected last, removes some overlapping error */
970                 if (last_seq) {
971                         draw_seq_strip(scene, ar, sseq, last_seq, 120, pixelx);
972                 }
973         }
974
975         /* text draw cached, in pixelspace now */
976         UI_view2d_text_cache_draw(ar);
977
978         /* Draw markers */
979 //      draw_markers_timespace(SCE_MARKERS, DRAW_MARKERS_LINES);
980         
981         /* reset view matrix */
982         UI_view2d_view_restore(C);
983
984         /* scrollers */
985         scrollers= UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_SECONDSSEQ, V2D_GRID_CLAMP, V2D_UNIT_VALUES, V2D_GRID_CLAMP);
986         UI_view2d_scrollers_draw(C, v2d, scrollers);
987         UI_view2d_scrollers_free(scrollers);
988 }
989
990