rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[goodguy/history.git] / cinelerra-5.1 / cinelerra / trackcanvas.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008-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 #ifndef TRACKCANVAS_H
23 #define TRACKCANVAS_H
24
25 #include "asset.inc"
26 #include "auto.inc"
27 #include "autos.inc"
28 #include "bctimer.inc"
29 #include "edit.inc"
30 #include "edithandles.inc"
31 #include "edl.inc"
32 #include "floatauto.inc"
33 #include "floatautos.inc"
34 #include "intauto.inc"
35 #include "guicast.h"
36 #include "indexable.h"
37 #include "keyframe.inc"
38 #include "mwindow.inc"
39 #include "mwindowgui.inc"
40 #include "plugin.inc"
41 #include "pluginset.inc"
42 #include "plugintoggles.inc"
43 #include "resourcepixmap.inc"
44 #include "timelinepane.inc"
45 #include "track.inc"
46 #include "tracks.inc"
47 #include "transitionhandles.inc"
48 #include "keyframe.inc"
49
50 #include <stdarg.h>
51
52 // draw mode:
53 // NORMAL_DRAW causes incremental drawing of pixmaps.  Used for navigation and index refresh.
54 // FORCE_REDRAW causes all resource pixmaps to be redrawn from scratch.  Used by editing.
55 // IGNORE_THREAD causes resource pixmaps to ignore picon thread.  Used by Piconthread.
56 #define NORMAL_DRAW 1
57 #define FORCE_REDRAW 2
58 #define IGNORE_THREAD 3
59
60 class TrackCanvas : public BC_SubWindow
61 {
62 public:
63         TrackCanvas(MWindow *mwindow, MWindowGUI *gui);
64         TrackCanvas(MWindow *mwindow, TimelinePane *pane, int x, int y, int w, int h);
65         ~TrackCanvas();
66
67         void create_objects();
68         void resize_event();
69         int drag_start_event();
70         int cursor_leave_event();
71         int keypress_event();
72         void draw_resources(int mode = 0,
73                 int indexes_only = 0,     // Redraw only certain audio resources with indexes
74                 Indexable *indexable = 0);
75         void draw_highlight_rectangle(int x, int y, int w, int h);
76         void draw_highlight_insertion(int x, int y, int w, int h);
77         void draw_playback_cursor();
78         void draw_highlighting();
79         void draw_keyframe_reticle();
80         int draw_hairline(Auto *auto_keyframe, int color);
81
82 // User can either call draw or draw_overlays to copy a fresh
83 // canvas and just draw the overlays over it
84         void draw_overlays();
85         void update_handles();
86 // Convert edit coords to transition coords
87         void get_transition_coords(int64_t &x, int64_t &y, int64_t &w, int64_t &h);
88         void get_handle_coords(Edit *edit,
89                 int64_t &x,
90                 int64_t &y,
91                 int64_t &w,
92                 int64_t &h,
93                 int side);
94         int get_drag_values(float *percentage,
95                 int64_t *position,
96                 int do_clamp,
97                 int cursor_x,
98                 int cursor_y,
99                 Auto *current);
100         void draw_title(Edit *edit,
101                 int64_t edit_x,
102                 int64_t edit_y,
103                 int64_t edit_w,
104                 int64_t edit_h);
105         void draw_automation();
106         void draw_hard_edges();
107         void draw_inout_points();
108         void draw_auto(Auto *current,
109                 int x,
110                 int y,
111                 int center_pixel,
112                 int zoom_track);
113         void draw_floatauto(FloatAuto *current,
114                 int x,
115                 int y,
116                 int in_x,
117                 int in_y,
118                 int out_x,
119                 int out_y,
120                 int center_pixel,
121                 int zoom_track,
122                 int color);
123         int test_auto(Auto *current,
124                 int x,
125                 int y,
126                 int center_pixel,
127                 int zoom_track,
128                 int cursor_x,
129                 int cursor_y,
130                 int buttonpress);
131         int test_floatauto(FloatAuto *current,
132                 int x,
133                 int y,
134                 int in_x,
135                 int in_y,
136                 int out_x,
137                 int out_y,
138                 int center_pixel,
139                 int zoom_track,
140                 int cursor_x,
141                 int cursor_y,
142                 int buttonpress,
143                 int autogrouptype);
144         void draw_floatline(int center_pixel,
145                 FloatAuto *previous,
146                 FloatAuto *current,
147                 FloatAutos *autos,
148                 double unit_start,
149                 double zoom_units,
150                 double yscale,
151                 int ax,
152                 int ay,
153                 int ax2,
154                 int ay2,
155                 int color,
156                 int autogrouptype);
157         int test_floatline(int center_pixel,
158                 FloatAutos *autos,
159                 double unit_start,
160                 double zoom_units,
161                 double yscale,
162                 int x1,
163                 int x2,
164                 int cursor_x,
165                 int cursor_y,
166                 int buttonpress,
167                 int autogrouptype);
168         void draw_toggleline(int center_pixel,
169                 int ax,
170                 int ay,
171                 int ax2,
172                 int ay2);
173         int test_toggleline(Autos *autos,
174                 int center_pixel,
175                 int x1,
176                 int y1,
177                 int x2,
178                 int y2,
179                 int cursor_x,
180                 int cursor_y,
181                 int buttonpress);
182         int do_keyframes(int cursor_x,
183                 int cursor_y,
184                 int draw,
185                 int buttonpress,
186                 int &new_cursor,
187                 int &update_cursor,
188                 int &rerender);
189
190         int do_float_autos(Track *track,
191                 Autos *autos,
192                 int cursor_x,
193                 int cursor_y,
194                 int draw,
195                 int buttonpress,
196                 int x_offset,
197                 int y_offset,
198                 int color,
199                 Auto* &auto_instance,
200                 int autogrouptype);
201         int do_int_autos(Track *track,
202                 Autos *autos,
203                 int cursor_x,
204                 int cursor_y,
205                 int draw,
206                 int buttonpress,
207                 int x_offset,
208                 int y_offset,
209                 int color,
210                 Auto * &auto_instance);
211         int do_autos(Track *track,
212                 Autos *autos,
213                 int cursor_x,
214                 int cursor_y,
215                 int draw,
216                 int buttonpress,
217                 BC_Pixmap *pixmap,
218                 Auto* &auto_instance,
219                 int &rerender);
220         int do_plugin_autos(Track *track,
221                 int cursor_x,
222                 int cursor_y,
223                 int draw,
224                 int buttonpress,
225                 Plugin* &keyframe_plugin,
226                 KeyFrame* &keyframe_instance);
227
228
229         void calculate_viewport(Track *track,
230                 double &view_start,
231                 double &unit_start,
232                 double &view_end,
233                 double &unit_end,
234                 double &yscale,
235                 int &center_pixel,
236                 double &zoom_sample,
237                 double &zoom_units);
238
239 // Convert percentage position inside track to value.
240 // if is_toggle is 1, the result is either 0 or 1.
241 // if reference is nonzero and a FloatAuto,
242 //     the result is made relative to the value in reference.
243         float percentage_to_value(float percentage,
244                 int is_toggle,
245                 Auto *reference,
246                 int autogrouptype);
247
248 // Get x and y of a FloatAuto relative to center_pixel
249         void calculate_auto_position(double *x,
250                 double *y,
251                 double *in_x,
252                 double *in_y,
253                 double *out_x,
254                 double *out_y,
255                 Auto *current,
256                 double unit_start,
257                 double zoom_units,
258                 double yscale,
259                 int autogrouptype);
260         void synchronize_autos(float change, Track *skip, FloatAuto *fauto, int fill_gangs);
261
262
263         void draw_brender_range();
264         void draw_loop_points();
265         void draw_transitions();
266         void draw_drag_handle();
267         void draw_plugins();
268         void refresh_plugintoggles();
269         void update_edit_handles(Edit *edit, int64_t edit_x, int64_t edit_y, int64_t edit_w, int64_t edit_h);
270         void update_transitions();
271         void update_keyframe_handles(Track *track);
272 // Draw everything to synchronize with the view.
273         void draw(int mode = 0, int hide_cursor = 1);
274 // Draw resources during index building
275         void draw_indexes(Indexable *indexable);
276 // Get location of edit on screen without boundary checking
277         void edit_dimensions(Edit *edit, int64_t &x, int64_t &y, int64_t &w, int64_t &h);
278         void track_dimensions(Track *track, int64_t &x, int64_t &y, int64_t &w, int64_t &h);
279         void plugin_dimensions(Plugin *plugin, int64_t &x, int64_t &y, int64_t &w, int64_t &h);
280         void get_pixmap_size(Edit *edit, int64_t edit_x, int64_t edit_w, int64_t &pixmap_x, int64_t &pixmap_w, int64_t &pixmap_h);
281         ResourcePixmap* create_pixmap(Edit *edit, int64_t edit_x, int64_t pixmap_x, int64_t pixmap_w, int64_t pixmap_h);
282         void update_cursor(int flush);
283 // Get edit and handle the cursor is over
284         int do_edit_handles(int cursor_x,
285                 int cursor_y,
286                 int button_press,
287                 int &rerender,
288                 int &update_overlay,
289                 int &new_cursor,
290                 int &update_cursor);
291 // Get plugin and handle the cursor if over
292         int do_plugin_handles(int cursor_x,
293                 int cursor_y,
294                 int button_press,
295                 int &rerender,
296                 int &update_overlay,
297                 int &new_cursor,
298                 int &update_cursor);
299 // Get edit the cursor is over
300         int do_edits(int cursor_x,
301                 int cursor_y,
302                 int button_press,
303                 int drag_start,
304                 int &redraw,
305                 int &rerender,
306                 int &new_cursor,
307                 int &update_cursor);
308         int do_tracks(int cursor_x,
309                 int cursor_y,
310                 int button_press);
311         int test_resources(int cursor_x, int cursor_y);
312         int do_plugins(int cursor_x,
313                 int cursor_y,
314                 int drag_start,
315                 int button_press,
316                 int &redraw,
317                 int &rerender);
318         int do_transitions(int cursor_x,
319                 int cursor_y,
320                 int button_press,
321                 int &new_cursor,
322                 int &update_cursor);
323         void draw_cropped_line(int x1,
324                 int y1,
325                 int x2,
326                 int y2,
327                 int min_y,
328                 int max_y);
329         int button_press_event();
330         int button_release_event();
331         int cursor_update(int in_motion);
332         int cursor_motion_event();
333         int activate();
334         int deactivate();
335         int repeat_event(int64_t duration);
336         void start_dragscroll();
337         void stop_dragscroll();
338         int start_selection(double position);
339         int drag_motion_event();
340         int drag_stop_event();
341         int drag_motion(Track **over_track,
342                 Edit **over_edit,
343                 PluginSet **over_pluginset,
344                 Plugin **over_plugin);
345         int drag_stop(int *redraw);
346         int64_t drop_edit_position (int *is_insertion, Edit *moved_edit, int64_t moved_edit_length);
347         int64_t drop_plugin_position(PluginSet *plugin_set, Plugin *moved_plugin);
348         void end_edithandle_selection();
349         void end_pluginhandle_selection();
350 // Number of seconds spanned by the trackcanvas
351         double time_visible();
352         void update_drag_handle();
353         int update_drag_edit();
354         int update_drag_floatauto(int cursor_x, int cursor_y);
355         int update_drag_toggleauto(int cursor_x, int cursor_y);
356         int update_drag_auto(int cursor_x, int cursor_y);
357         int update_drag_pluginauto(int cursor_x, int cursor_y);
358         void show_message(Auto *current, int show_curve_type, const char *fmt, ...);
359
360 // Update status bar to reflect drag operation
361         void update_drag_caption();
362
363         int get_title_h();
364         int resource_h();
365
366 // Display hourglass if timer expired
367         void test_timer();
368 // get the relevant patchbay by traversing the panes
369 //      Patchbay* get_patchbay();
370
371         MWindow *mwindow;
372         MWindowGUI *gui;
373         TimelinePane *pane;
374 // Allows overlays to get redrawn without redrawing the resources
375         BC_Pixmap *background_pixmap;
376         BC_Pixmap *transition_pixmap;
377         EditHandles *edit_handles;
378 //      TransitionHandles *transition_handles;
379         BC_Pixmap *keyframe_pixmap;
380         BC_Pixmap *camerakeyframe_pixmap;
381         BC_Pixmap *modekeyframe_pixmap;
382         BC_Pixmap *pankeyframe_pixmap;
383         BC_Pixmap *projectorkeyframe_pixmap;
384         BC_Pixmap *maskkeyframe_pixmap;
385
386         int active;
387 // Currently in a drag scroll operation
388         int drag_scroll;
389 // Don't stop hourglass if it was never started before the operation.
390         int hourglass_enabled;
391 // position used by timebar, when the timebar needs to draw a highlight
392         double timebar_position;
393
394 // Temporary for picon drawing
395         VFrame *temp_picon;
396 // Timer for hourglass
397         Timer *resource_timer;
398         Timer *render_timer;
399
400 // Plugin toggle interfaces
401         ArrayList<PluginOn*> plugin_on_toggles;
402         ArrayList<PluginShow*> plugin_show_toggles;
403         ArrayList<PluginPresetEdit*> preset_edit_buttons;
404
405         static int auto_operations[];
406 // event handlers
407         void draw_paste_destination();
408
409         void draw_floatauto_ctrlpoint(int x, int y, int cp_x, int cp_y,
410                 int center_pixel, int zoom_track, int color);
411
412         float value_to_percentage(float auto_value, int autogrouptype);
413         // transforms automation value into current display coords
414         // dependant on current automation display range for given kind of automation
415
416 // ====================================== cursor selection type
417
418         double selection_midpoint;        // division between current ends
419         int snapped;                    // drag handle snapping
420         EDL *speed_edl;                 // drag speed handle start edl
421 };
422
423 #endif