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_math.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 precision 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 = active_seq_get(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         /* preview range */
 982         UI_view2d_view_ortho(C, v2d);
 983         ANIM_draw_previewrange(C, v2d);
 984
 985         /* reset view matrix */
 986         UI_view2d_view_restore(C);
 987
 988         /* scrollers */
 989         scrollers= UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_SECONDSSEQ, V2D_GRID_CLAMP, V2D_UNIT_VALUES, V2D_GRID_CLAMP);
 990         UI_view2d_scrollers_draw(C, v2d, scrollers);
 991         UI_view2d_scrollers_free(scrollers);
 992 }
 993
 994