yet another attempt to deal with ffmpeg seeks, fred name/color change
[goodguy/history.git] / cinelerra-5.1 / cinelerra / timebar.C
1
2 /*
3  * CINELERRA
4  * Copyright (C) 1997-2014 Adam Williams <broadcast at earthling dot net>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (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
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  *
20  */
21
22 #include "bcsignals.h"
23 #include "clip.h"
24 #include "cplayback.h"
25 #include "cursors.h"
26 #include "cwindow.h"
27 #include "edl.h"
28 #include "edlsession.h"
29 #include "filexml.h"
30 #include "fonts.h"
31 #include "labels.h"
32 #include "labeledit.h"
33 #include "localsession.h"
34 #include "maincursor.h"
35 #include "mainundo.h"
36 #include "mbuttons.h"
37 #include "mwindow.h"
38 #include "mwindowgui.h"
39 #include "patchbay.h"
40 #include "preferences.h"
41 #include "recordlabel.h"
42 #include "localsession.h"
43 #include "mainsession.h"
44 #include "theme.h"
45 #include "timebar.h"
46 #include "timelinepane.h"
47 #include "trackcanvas.h"
48 #include "tracks.h"
49 #include "transportque.h"
50 #include "units.h"
51 #include "vframe.h"
52 #include "vwindow.h"
53 #include "vwindowgui.h"
54 #include "zoombar.h"
55
56
57 LabelGUI::LabelGUI(MWindow *mwindow, TimeBar *timebar,
58         int64_t pixel, int y,
59         double position, VFrame **data)
60  : BC_Toggle(translate_pixel(mwindow, pixel), y,
61                 data ? data : mwindow->theme->label_toggle, 0)
62 {
63         this->mwindow = mwindow;
64         this->timebar = timebar;
65         this->gui = 0;
66         this->pixel = pixel;
67         this->position = position;
68         this->label = 0;
69 }
70
71 LabelGUI::~LabelGUI()
72 {
73 }
74
75 int LabelGUI::get_y(MWindow *mwindow, TimeBar *timebar)
76 {
77         return timebar->get_h() -
78                 mwindow->theme->label_toggle[0]->get_h();
79 }
80
81 int LabelGUI::translate_pixel(MWindow *mwindow, int pixel)
82 {
83         int result = pixel - mwindow->theme->label_toggle[0]->get_w() / 2;
84         return result;
85 }
86
87 void LabelGUI::reposition(int flush)
88 {
89         reposition_window(translate_pixel(mwindow, pixel),
90                 BC_Toggle::get_y());
91 }
92
93 int LabelGUI::button_press_event()
94 {
95         int result = 0;
96
97         if( this->is_event_win() && get_buttonpress() == 3 ) {
98                 if( label ) {
99                         int cur_x, cur_y;
100                         get_abs_cursor_xy(cur_x, cur_y, 0);
101                         timebar->label_edit->start(label, cur_x, cur_y);
102                 }
103                 result = 1;
104         } else {
105                 result = BC_Toggle::button_press_event();
106         }
107         if( label )
108                 set_tooltip(this->label->textstr);
109         return result;
110 }
111
112 int LabelGUI::handle_event()
113 {
114         timebar->select_label(position);
115         return 1;
116 }
117
118
119 InPointGUI::InPointGUI(MWindow *mwindow, TimeBar *timebar,
120         int64_t pixel, double position)
121  : LabelGUI(mwindow, timebar,
122         pixel, get_y(mwindow, timebar),
123         position, mwindow->theme->in_point)
124 {
125 //printf("InPointGUI::InPointGUI %d %d\n", pixel, get_y(mwindow, timebar));
126 }
127 InPointGUI::~InPointGUI()
128 {
129 }
130 int InPointGUI::get_y(MWindow *mwindow, TimeBar *timebar)
131 {
132         int result;
133         result = timebar->get_h() -
134                 mwindow->theme->in_point[0]->get_h();
135         return result;
136 }
137
138
139 OutPointGUI::OutPointGUI(MWindow *mwindow, TimeBar *timebar,
140         int64_t pixel, double position)
141  : LabelGUI(mwindow, timebar,
142         pixel, get_y(mwindow, timebar),
143         position, mwindow->theme->out_point)
144 {
145 //printf("OutPointGUI::OutPointGUI %d %d\n", pixel, get_y(mwindow, timebar));
146 }
147 OutPointGUI::~OutPointGUI()
148 {
149 }
150 int OutPointGUI::get_y(MWindow *mwindow, TimeBar *timebar)
151 {
152         return timebar->get_h() -
153                 mwindow->theme->out_point[0]->get_h();
154 }
155
156
157 PresentationGUI::PresentationGUI(MWindow *mwindow, TimeBar *timebar,
158         int64_t pixel, double position)
159  : LabelGUI(mwindow, timebar, pixel, get_y(mwindow, timebar), position)
160 {
161 }
162 PresentationGUI::~PresentationGUI()
163 {
164 }
165
166 TimeBar::TimeBar(MWindow *mwindow, BC_WindowBase *gui,
167         int x, int y, int w, int h)
168  : BC_SubWindow(x, y, w, h)
169 {
170 //printf("TimeBar::TimeBar %d %d %d %d\n", x, y, w, h);
171         this->gui = gui;
172         this->mwindow = mwindow;
173         label_edit = new LabelEdit(mwindow, mwindow->awindow, 0);
174         pane = 0;
175         highlighted = 0;
176 }
177
178 TimeBar::~TimeBar()
179 {
180         delete in_point;
181         delete out_point;
182         delete label_edit;
183         labels.remove_all_objects();
184         presentations.remove_all_objects();
185 }
186
187 void TimeBar::create_objects()
188 {
189         in_point = 0;
190         out_point = 0;
191 //printf("TimeBar::create_objects %d\n", __LINE__);
192         current_operation = TIMEBAR_NONE;
193         set_cursor(UPRIGHT_ARROW_CURSOR, 0, 0);
194         update(0);
195 }
196
197
198 int64_t TimeBar::position_to_pixel(double position)
199 {
200         get_edl_length();
201         return (int64_t)(position / time_per_pixel);
202 }
203
204
205 double TimeBar::pixel_to_position(int pixel)
206 {
207         if( pane ) {
208                 pixel += mwindow->edl->local_session->view_start[pane->number];
209         }
210
211         return (double)pixel *
212                 mwindow->edl->local_session->zoom_sample /
213                 mwindow->edl->session->sample_rate;
214 }
215
216 void TimeBar::update_labels()
217 {
218         int output = 0;
219         EDL *edl = get_edl();
220
221         if( edl ) {
222                 for( Label *current=edl->labels->first; current; current=NEXT ) {
223                         int64_t pixel = position_to_pixel(current->position);
224                         if( pixel >= 0 && pixel < get_w()  ) {
225 // Create new label
226                                 if( output >= labels.total ) {
227                                         LabelGUI *new_label;
228                                         add_subwindow(new_label =
229                                                 new LabelGUI(mwindow,
230                                                         this,
231                                                         pixel,
232                                                         LabelGUI::get_y(mwindow, this),
233                                                         current->position));
234                                         new_label->set_cursor(INHERIT_CURSOR, 0, 0);
235                                         new_label->set_tooltip(current->textstr);
236                                         new_label->label = current;
237                                         labels.append(new_label);
238                                 }
239                                 else
240 // Reposition old label
241                                 {
242                                         LabelGUI *gui = labels.values[output];
243                                         if( gui->pixel != pixel ) {
244                                                 gui->pixel = pixel;
245                                                 gui->reposition(0);
246                                         }
247                                         else {
248                                                 gui->draw_face(1,0);
249                                         }
250
251                                         labels.values[output]->position = current->position;
252                                         labels.values[output]->set_tooltip(current->textstr);
253                                         labels.values[output]->label = current;
254                                 }
255
256                                 if( edl->local_session->get_selectionstart(1) <= current->position &&
257                                     edl->local_session->get_selectionend(1) >= current->position )
258                                         labels.values[output]->update(1);
259                                 else
260                                 if( labels.values[output]->get_value() )
261                                         labels.values[output]->update(0);
262
263                                 output++;
264                         }
265                 }
266         }
267
268 // Delete excess labels
269         while(labels.total > output)
270         {
271                 labels.remove_object();
272         }
273
274 // Get the labels to show
275         show_window(0);
276 }
277
278 void TimeBar::update_highlights()
279 {
280         for( int i = 0; i < labels.total; i++ ) {
281                 LabelGUI *label = labels.values[i];
282                 if( mwindow->edl->equivalent(label->position,
283                                 mwindow->edl->local_session->get_selectionstart(1)) ||
284                     mwindow->edl->equivalent(label->position,
285                                 mwindow->edl->local_session->get_selectionend(1)) ) {
286                         if( !label->get_value() ) label->update(1);
287                 }
288                 else
289                         if( label->get_value() ) label->update(0);
290         }
291
292         if( mwindow->edl->equivalent(mwindow->edl->local_session->get_inpoint(),
293                         mwindow->edl->local_session->get_selectionstart(1)) ||
294                 mwindow->edl->equivalent(mwindow->edl->local_session->get_inpoint(),
295                         mwindow->edl->local_session->get_selectionend(1)) ) {
296                 if( in_point ) in_point->update(1);
297         }
298         else
299                 if( in_point ) in_point->update(0);
300
301         if( mwindow->edl->equivalent(mwindow->edl->local_session->get_outpoint(),
302                         mwindow->edl->local_session->get_selectionstart(1)) ||
303                 mwindow->edl->equivalent(mwindow->edl->local_session->get_outpoint(),
304                         mwindow->edl->local_session->get_selectionend(1)) ) {
305                 if( out_point ) out_point->update(1);
306         }
307         else
308                 if( out_point ) out_point->update(0);
309 }
310
311 void TimeBar::update_points()
312 {
313         EDL *edl = get_edl();
314         int64_t pixel = !edl ? 0 :
315                 position_to_pixel(edl->local_session->get_inpoint());
316
317         if( in_point ) {
318                 if( edl && edl->local_session->inpoint_valid() &&
319                     pixel >= 0 && pixel < get_w() ) {
320                         if( !EQUIV(edl->local_session->get_inpoint(), in_point->position) ||
321                             in_point->pixel != pixel ) {
322                                 in_point->pixel = pixel;
323                                 in_point->position = edl->local_session->get_inpoint();
324                                 in_point->reposition(0);
325                         }
326                         else {
327                                 in_point->draw_face(1, 0);
328                         }
329                 }
330                 else {
331                         delete in_point;
332                         in_point = 0;
333                 }
334         }
335         else
336         if( edl && edl->local_session->inpoint_valid() &&
337             pixel >= 0 && pixel < get_w() ) {
338                 add_subwindow(in_point = new InPointGUI(mwindow,
339                         this, pixel, edl->local_session->get_inpoint()));
340                 in_point->set_cursor(ARROW_CURSOR, 0, 0);
341         }
342
343         pixel = !edl ? 0 :
344                  position_to_pixel(edl->local_session->get_outpoint());
345
346         if( out_point ) {
347                 if( edl && edl->local_session->outpoint_valid() &&
348                     pixel >= 0 && pixel < get_w()) {
349                         if( !EQUIV(edl->local_session->get_outpoint(), out_point->position) ||
350                             out_point->pixel != pixel ) {
351                                 out_point->pixel = pixel;
352                                 out_point->position = edl->local_session->get_outpoint();
353                                 out_point->reposition(0);
354                         }
355                         else {
356                                 out_point->draw_face(1, 0);
357                         }
358                 }
359                 else {
360                         delete out_point;
361                         out_point = 0;
362                 }
363         }
364         else
365         if( edl && edl->local_session->outpoint_valid() &&
366             pixel >= 0 && pixel < get_w() ) {
367                 add_subwindow(out_point = new OutPointGUI(mwindow,
368                         this, pixel, edl->local_session->get_outpoint()));
369                 out_point->set_cursor(ARROW_CURSOR, 0, 0);
370         }
371
372 //      flush();
373 }
374
375 void TimeBar::update_clock(double position)
376 {
377 }
378
379 void TimeBar::update(int flush)
380 {
381         draw_time();
382 // Need to redo these when range is drawn to get the background updated.
383         update_labels();
384         update_points();
385
386
387         EDL *edl = get_edl();
388         int64_t pixel = -1;
389         int x = get_relative_cursor_x();
390 // Draw highlight position
391         if( edl && (highlighted || current_operation == TIMEBAR_DRAG) &&
392             x >= 0 && x < get_w() ) {
393 //printf("TimeBar::update %d %d\n", __LINE__, x);
394                 double position = pixel_to_position(x);
395
396                 position = get_edl()->align_to_frame(position, 0);
397                 pixel = position_to_pixel(position);
398                 update_clock(position);
399         }
400
401         if( pixel < 0 ) {
402                 double position = test_highlight();
403                 if( position >= 0 ) pixel = position_to_pixel(position);
404         }
405
406
407         if( pixel >= 0 && pixel < get_w() ) {
408                 set_color(mwindow->theme->timebar_cursor_color);
409                 set_line_dashes(1);
410 //printf("TimeBar::update %d pane=%d pixel=%jd\n", __LINE__, pane->number, pixel);
411                 draw_line(pixel, 0, pixel, get_h());
412                 set_line_dashes(0);
413         }
414
415
416         if( edl ) {
417                 double playback_start = edl->local_session->playback_start;
418                 if( playback_start >= 0 ) {
419                         int64_t pixel = position_to_pixel(playback_start);
420                         set_color(mwindow->theme->timebar_cursor_color ^ 0x0000ff);
421                         draw_line(pixel, 0, pixel, get_h());
422                         double playback_end = edl->local_session->playback_end;
423                         if( playback_end > playback_start ) {
424                                 pixel = position_to_pixel(playback_end);
425                                 set_color(mwindow->theme->timebar_cursor_color ^ 0x00ff00);
426                                 draw_line(pixel, 0, pixel, get_h());
427                         }
428                 }
429
430                 double position = edl->local_session->get_selectionstart(1);
431                 int64_t pixel = position_to_pixel(position);
432 // Draw insertion point position.
433                 int color = mwindow->theme->timebar_cursor_color;
434                 if( mwindow->preferences->forward_render_displacement )
435                         color ^= 0x00ffff;
436                 set_color(color);
437                 draw_line(pixel, 0, pixel, get_h());
438         }
439
440         update_highlights();
441
442 // Get the labels to show
443         show_window(0);
444         flash(flush);
445 //printf("TimeBar::update %d this=%p %d\n", __LINE__, this, current_operation);
446 }
447
448
449
450 int TimeBar::delete_project()
451 {
452 //      labels->delete_all();
453         return 0;
454 }
455
456 int TimeBar::save(FileXML *xml)
457 {
458 //      labels->save(xml);
459         return 0;
460 }
461
462
463
464
465 void TimeBar::draw_time()
466 {
467 }
468
469 EDL* TimeBar::get_edl()
470 {
471         return mwindow->edl;
472 }
473
474
475
476 void TimeBar::draw_range()
477 {
478
479
480 //printf("TimeBar::draw_range %d %p\n", __LINE__, get_edl());
481         if( has_preview() && get_edl() ) {
482                 int x1, x2;
483                 get_preview_pixels(x1, x2);
484
485 //printf("TimeBar::draw_range %f %d %d\n", edl_length, x1, x2);
486                 draw_3segmenth(0, 0, x1, mwindow->theme->timebar_view_data);
487                 draw_top_background(get_parent(), x1, 0, x2 - x1, get_h());
488                 draw_3segmenth(x2, 0, get_w() - x2, mwindow->theme->timebar_view_data);
489
490                 set_color(BLACK);
491                 draw_line(x1, 0, x1, get_h());
492                 draw_line(x2, 0, x2, get_h());
493
494
495                 EDL *edl = get_edl();
496                 if( edl ) {
497                         int64_t pixel = position_to_pixel(
498                                 edl->local_session->get_selectionstart(1));
499 // Draw insertion point position if this timebar belongs to a window which
500 // has something other than the master EDL.
501                         set_color(mwindow->theme->timebar_cursor_color);
502                         draw_line(pixel, 0, pixel, get_h());
503                 }
504         }
505         else
506                 draw_top_background(get_parent(), 0, 0, get_w(), get_h());
507 }
508
509 void TimeBar::select_label(double position)
510 {
511 }
512
513
514
515 int TimeBar::draw()
516 {
517         return 0;
518 }
519
520 double TimeBar::get_edl_length()
521 {
522         edl_length = 0;
523
524         if( get_edl() ) {
525 //printf("TimeBar::get_edl_length 1 %f\n", get_edl()->tracks->total_playable_length());
526                 edl_length = get_edl()->tracks->total_playable_length();
527         }
528
529 //printf("TimeBar::get_edl_length 2\n");
530         if( !EQUIV(edl_length, 0) ) {
531 //printf("TimeBar::get_edl_length 3\n");
532                 time_per_pixel = edl_length / get_w();
533 //printf("TimeBar::get_edl_length 4\n");
534         }
535         else {
536                 time_per_pixel = 0;
537         }
538 //printf("TimeBar::get_edl_length 5\n");
539
540         return edl_length;
541 }
542
543 int TimeBar::get_preview_pixels(int &x1, int &x2)
544 {
545         x1 = 0;
546         x2 = 0;
547
548         get_edl_length();
549
550         if( get_edl() ) {
551                 if( !EQUIV(edl_length, 0) ) {
552                         if( get_edl()->local_session->preview_end <= 0 ||
553                             get_edl()->local_session->preview_end > edl_length )
554                                 get_edl()->local_session->preview_end = edl_length;
555                         if( get_edl()->local_session->preview_start >
556                                 get_edl()->local_session->preview_end )
557                                 get_edl()->local_session->preview_start = 0;
558                         x1 = (int)(get_edl()->local_session->preview_start / time_per_pixel);
559                         x2 = (int)(get_edl()->local_session->preview_end / time_per_pixel);
560                 }
561                 else {
562                         x1 = 0;
563                         x2 = get_w();
564                 }
565         }
566 // printf("TimeBar::get_preview_pixels %f %f %d %d\n",
567 //      get_edl()->local_session->preview_start,
568 //      get_edl()->local_session->preview_end,
569 //      x1,
570 //      x2);
571         return 0;
572 }
573
574
575 int TimeBar::test_preview(int buttonpress)
576 {
577         int result = 0;
578
579
580         if( get_edl() && cursor_inside() && buttonpress >= 0 ) {
581                 int x1, x2, x = get_relative_cursor_x();
582                 get_preview_pixels(x1, x2);
583 //printf("TimeBar::test_preview %d %d %d\n", x1, x2, x);
584 // Inside left handle
585                 if( x >= x1 - HANDLE_W && x < x1 + HANDLE_W &&
586 // Ignore left handle if both handles are up against the left side
587                     x2 > HANDLE_W ) {
588                         if( buttonpress ) {
589                                 current_operation = TIMEBAR_DRAG_LEFT;
590                                 start_position = get_edl()->local_session->preview_start;
591                                 start_cursor_x = x;
592                         }
593                         else if( get_cursor() != LEFT_CURSOR )
594                                 set_cursor(LEFT_CURSOR, 0, 1);
595                         result = 1;
596                 }
597 // Inside right handle
598                 else if( x >= x2 - HANDLE_W && x < x2 + HANDLE_W &&
599 // Ignore right handle if both handles are up against the right side
600                     x1 < get_w() - HANDLE_W ) {
601                         if( buttonpress ) {
602                                 current_operation = TIMEBAR_DRAG_RIGHT;
603                                 start_position = get_edl()->local_session->preview_end;
604                                 start_cursor_x = x;
605                         }
606                         else if( get_cursor() != RIGHT_CURSOR )
607                                 set_cursor(RIGHT_CURSOR, 0, 1);
608                         result = 1;
609                 }
610 // Inside preview
611                 else if( get_button_down() && get_buttonpress() == 3 &&
612                     x >= x1 && x < x2 ) {
613                         if( buttonpress ) {
614                                 current_operation = TIMEBAR_DRAG_CENTER;
615                                 starting_start_position = get_edl()->local_session->preview_start;
616                                 starting_end_position = get_edl()->local_session->preview_end;
617                                 start_cursor_x = x;
618                         }
619                         if( get_cursor() != HSEPARATE_CURSOR )
620                                 set_cursor(HSEPARATE_CURSOR, 0, 1);
621                         result = 1;
622                 }
623         }
624
625         if( !result && get_cursor() != ARROW_CURSOR )
626                 set_cursor(ARROW_CURSOR, 0, 1);
627
628
629         return result;
630 }
631
632 int TimeBar::move_preview(int &redraw)
633 {
634         int result = 0, x = get_relative_cursor_x();
635
636         if( current_operation == TIMEBAR_DRAG_LEFT ) {
637                 get_edl()->local_session->preview_start =
638                         start_position + time_per_pixel * (x - start_cursor_x);
639                 CLAMP(get_edl()->local_session->preview_start,
640                         0,
641                         get_edl()->local_session->preview_end);
642                 result = 1;
643         }
644         else
645         if( current_operation == TIMEBAR_DRAG_RIGHT ) {
646                 get_edl()->local_session->preview_end =
647                         start_position + time_per_pixel * (x - start_cursor_x);
648                 CLAMP(get_edl()->local_session->preview_end,
649                         get_edl()->local_session->preview_start,
650                         edl_length);
651                 result = 1;
652         }
653         else
654         if( current_operation == TIMEBAR_DRAG_CENTER ) {
655                 double dt = time_per_pixel * (x - start_cursor_x);
656                 get_edl()->local_session->preview_start = starting_start_position + dt;
657                 get_edl()->local_session->preview_end = starting_end_position + dt;
658                 if( get_edl()->local_session->preview_start < 0 ) {
659                         get_edl()->local_session->preview_end -= get_edl()->local_session->preview_start;
660                         get_edl()->local_session->preview_start = 0;
661                 }
662                 else
663                 if( get_edl()->local_session->preview_end > edl_length ) {
664                         get_edl()->local_session->preview_start -= get_edl()->local_session->preview_end - edl_length;
665                         get_edl()->local_session->preview_end = edl_length;
666                 }
667                 result = 1;
668         }
669
670 //printf("TimeBar::move_preview %d %d\n", __LINE__, current_operation);
671
672         if( result ) {
673                 update_preview();
674                 redraw = 1;
675         }
676 //printf("TimeBar::move_preview %d %d\n", __LINE__, current_operation);
677
678         return result;
679 }
680
681 void TimeBar::update_preview()
682 {
683 }
684
685 int TimeBar::samplemovement()
686 {
687         return 0;
688 }
689
690 void TimeBar::stop_playback()
691 {
692 }
693
694 int TimeBar::button_press_event()
695 {
696         int result = 0;
697         if( is_event_win() && cursor_above() ) {
698                 if( has_preview() && get_buttonpress() == 3 ) {
699                         result = test_preview(1);
700                 }
701 // Change time format
702                 else if( ctrl_down() ) {
703                         if( get_buttonpress() == 1 )
704                                 mwindow->next_time_format();
705                         else
706                         if( get_buttonpress() == 2 )
707                                 mwindow->prev_time_format();
708                         result = 1;
709                 }
710                 else if( get_buttonpress() == 1 ) {
711                         stop_playback();
712
713 // Select region between two labels
714                         if( get_double_click() ) {
715                                 int x = get_relative_cursor_x();
716                                 double position = pixel_to_position(x);
717 // Test labels
718                                 select_region(position);
719                         }
720                         else {
721
722 // Reposition highlight cursor
723                                 update_cursor();
724                                 current_operation = TIMEBAR_DRAG;
725                                 activate_timeline();
726                         }
727                         result = 1;
728                 }
729         }
730         return result;
731 }
732
733 void TimeBar::activate_timeline()
734 {
735         mwindow->gui->activate_timeline();
736 }
737
738 int TimeBar::cursor_motion_event()
739 {
740         int result = 0;
741         int redraw = 0;
742
743 //printf("TimeBar::cursor_motion_event %d %p %d\n", __LINE__, this, current_operation);
744         switch( current_operation )
745         {
746                 case TIMEBAR_DRAG:
747                 {
748                         update_cursor();
749                         handle_mwindow_drag();
750                         result = 1;
751 //printf("TimeBar::cursor_motion_event %d %d\n", __LINE__, current_operation);
752                         break;
753                 }
754
755
756                 case TIMEBAR_DRAG_LEFT:
757                 case TIMEBAR_DRAG_RIGHT:
758                 case TIMEBAR_DRAG_CENTER:
759                         if( has_preview() )
760                                 result = move_preview(redraw);
761                         break;
762
763                 default:
764                         if( cursor_above() ) {
765                                 highlighted = 1;
766                                 redraw = 1;
767                         }
768
769 //printf("TimeBar::cursor_motion_event 20\n");
770                         if( has_preview() )
771                                 result = test_preview(0);
772 //printf("TimeBar::cursor_motion_event 30\n");
773                         break;
774         }
775
776
777 //printf("TimeBar::cursor_motion_event %d %d\n", __LINE__, current_operation);
778         if( redraw ) {
779                 update(1);
780         }
781 //printf("TimeBar::cursor_motion_event %d %p %d\n", __LINE__, this, current_operation);
782
783         return result;
784 }
785
786 int TimeBar::cursor_leave_event()
787 {
788         if( highlighted ) {
789                 highlighted = 0;
790                 update(1);
791         }
792         return 0;
793 }
794
795 int TimeBar::button_release_event()
796 {
797 //printf("TimeBar::button_release_event %d %d\n", __LINE__, current_operation);
798         int result = 0;
799         int need_redraw = 0;
800         switch( current_operation )
801         {
802                 case TIMEBAR_DRAG:
803                         mwindow->gui->get_focused_pane()->canvas->stop_dragscroll();
804                         current_operation = TIMEBAR_NONE;
805                         need_redraw = 1;
806                         result = 1;
807                         break;
808
809                 default:
810                         if( current_operation != TIMEBAR_NONE ) {
811                                 current_operation = TIMEBAR_NONE;
812                                 result = 1;
813                         }
814                         break;
815         }
816
817         if( (!cursor_above() && highlighted) || need_redraw ) {
818                 highlighted = 0;
819                 update(1);
820         }
821
822         return result;
823 }
824
825 // Update the selection cursor during a dragging operation
826 void TimeBar::update_cursor()
827 {
828 }
829
830 void TimeBar::handle_mwindow_drag()
831 {
832 }
833
834 int TimeBar::select_region(double position)
835 {
836         Label *start = 0, *end = 0, *current;
837         for( current = mwindow->edl->labels->first; current; current = NEXT ) {
838                 if( current->position > position ) {
839                         end = current;
840                         break;
841                 }
842         }
843
844         for( current = mwindow->edl->labels->last ; current; current = PREVIOUS ) {
845                 if( current->position <= position ) {
846                         start = current;
847                         break;
848                 }
849         }
850
851 // Select region
852         if( end != start ) {
853                 if( !start )
854                         mwindow->edl->local_session->set_selectionstart(0);
855                 else
856                         mwindow->edl->local_session->set_selectionstart(start->position);
857
858                 if( !end )
859                         mwindow->edl->local_session->set_selectionend(mwindow->edl->tracks->total_length());
860                 else
861                         mwindow->edl->local_session->set_selectionend(end->position);
862         }
863         else
864         if( end || start ) {
865                 mwindow->edl->local_session->set_selectionstart(start->position);
866                 mwindow->edl->local_session->set_selectionend(start->position);
867         }
868
869 // Que the CWindow
870         mwindow->cwindow->update(1, 0, 0);
871         mwindow->gui->hide_cursor(0);
872         mwindow->gui->draw_cursor(1);
873         mwindow->gui->flash_canvas(0);
874         mwindow->gui->activate_timeline();
875         mwindow->gui->zoombar->update();
876         update_highlights();
877         return 0;
878 }
879
880
881
882
883 int TimeBar::delete_arrows()
884 {
885         return 0;
886 }
887
888 double TimeBar::test_highlight()
889 {
890         return -1;
891 }
892
893