Credit Andrew - improve in-tree documentation
[goodguy/cinelerra.git] / cinelerra / canvas.h
1
2 /*
3  * CINELERRA
4  * Copyright (C) 2008 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 CANVAS_H
23 #define CANVAS_H
24
25 #include "edl.inc"
26 #include "guicast.h"
27 #include "mwindow.inc"
28 #include "videodevice.inc"
29
30 // Output for all X11 video
31
32 class CanvasOutput;
33 class CanvasFullScreen;
34 class CanvasXScroll;
35 class CanvasYScroll;
36 class CanvasPopup;
37 class CanvasFullScreenPopup;
38 class CanvasToggleControls;
39
40 // The EDL arguments can be set to 0 if the canvas_w and canvas_h are used
41 class Canvas
42 {
43 public:
44         Canvas(MWindow *mwindow,
45                 BC_WindowBase *subwindow,
46                 int x,
47                 int y,
48                 int w,
49                 int h,
50                 int output_w,
51                 int output_h,
52                 int use_scrollbars);
53         virtual ~Canvas();
54
55         void reset();
56 // Get dimensions given a zoom
57         void calculate_sizes(float aspect_ratio,
58                 int output_w,
59                 int output_h,
60                 float zoom,
61                 int &w,
62                 int &h);
63 // Lock access to the canvas pointer.
64 // Must be called before get_canvas or locking the canvas.
65         void lock_canvas(const char *location);
66         void unlock_canvas();
67         int is_locked();
68
69         void create_objects(EDL *edl);
70         void set_cursor(int cursor);
71 // Start video playback
72         void start_video();
73         void stop_video();
74
75 // Start single frame processing.  Causes the status indicator to update
76         void start_single();
77         void stop_single();
78
79         void start_fullscreen();
80         void stop_fullscreen();
81
82 // Don't call from inside the canvas
83         void create_canvas();
84
85
86
87 // Processing or video playback changed.
88         virtual void status_event() {};
89
90
91         virtual void reset_camera() {};
92         virtual void reset_projector() {};
93         virtual void zoom_resize_window(float percentage) {};
94         virtual void zoom_auto() {};
95         virtual int cursor_leave_event() { return 0; };
96         virtual int cursor_enter_event() { return 0; };
97         virtual int button_release_event() { return 0; };
98         virtual int button_press_event();
99         virtual int cursor_motion_event() { return 0; };
100         virtual int need_overlays() { return 1; }
101         virtual void draw_overlays() { };
102         virtual void toggle_controls() { } ;
103         virtual int get_cwindow_controls() { return 0; };
104         virtual int get_fullscreen() { return 0; }
105         virtual void set_fullscreen(int value) { };
106
107         int cursor_leave_event_base(BC_WindowBase *caller);
108         int cursor_enter_event_base(BC_WindowBase *caller);
109         int button_press_event_base(BC_WindowBase *caller);
110         int keypress_event(BC_WindowBase *caller);
111 // Use menu different options for different windows
112         void use_cwindow();
113         void use_rwindow();
114         void use_vwindow();
115         void use_auxwindow(BC_WindowBase *aux);
116
117 // Provide canvas dimensions since a BC_Bitmap containing obsolete dimensions
118 // is often the output being transferred to.
119 // This gets the input coordinates on the device output_frame
120 // and the corresponding output coordinates on the canvas.
121 // Must be floating point to support OpenGL.
122         void get_transfers(EDL *edl,
123                 float &output_x1,
124                 float &output_y1,
125                 float &output_x2,
126                 float &output_y2,
127                 float &canvas_x1,
128                 float &canvas_y1,
129                 float &canvas_x2,
130                 float &canvas_y2,
131 // passing -1 causes automatic size detection
132                 int canvas_w = -1,
133                 int canvas_h = -1);
134         void reposition_window(EDL *edl, int x, int y, int w, int h);
135         virtual void reset_translation() {};
136         virtual void close_source() {};
137 // Updates the stores
138         virtual void update_zoom(int x, int y, float zoom) {};
139         void check_boundaries(EDL *edl, int &x, int &y, float &zoom);
140         void update_scrollbars(int flush);
141 // Get scrollbar positions relative to output.
142 // No correction is done if output is smaller than canvas
143         virtual int get_xscroll() { return 0; };
144         virtual int get_yscroll() { return 0; };
145         virtual float get_zoom() { return 0; };
146 // Updates the refresh_frame
147         void update_refresh(VideoDevice *device, VFrame *output_frame);
148 // Redraws the refresh_frame
149         virtual void draw_refresh(int flush = 1) {};
150         virtual void clear(int flush=1);
151
152 // Get top left offset of canvas relative to output.
153 // Normally negative.  Can be positive if output is smaller than canvas.
154         float get_x_offset(EDL *edl,
155                 int single_channel,
156                 float zoom_x,
157                 float conformed_w,
158                 float conformed_h);
159         float get_y_offset(EDL *edl,
160                 int single_channel,
161                 float zoom_y,
162                 float conformed_w,
163                 float conformed_h);
164         void get_zooms(EDL *edl,
165                 int single_channel,
166                 float &zoom_x,
167                 float &zoom_y,
168                 float &conformed_w,
169                 float &conformed_h);
170
171
172 // Convert coord from output to canvas position, including
173 // x and y scroll offsets
174         void output_to_canvas(EDL *edl, int single_channel, float &x, float &y);
175 // Convert coord from canvas to output position
176         void canvas_to_output(EDL *edl, int single_channel, float &x, float &y);
177
178 // Get dimensions of frame being sent to canvas
179         virtual int get_output_w(EDL *edl);
180         virtual int get_output_h(EDL *edl);
181 // Get if scrollbars exist
182         int scrollbars_exist();
183 // Get cursor locations relative to canvas and not offset by scrollbars
184         int get_cursor_x();
185         int get_cursor_y();
186         int get_buttonpress();
187 // Gets whatever video surface is enabled
188         BC_WindowBase* get_canvas();
189
190 // The owner of the canvas
191         BC_WindowBase *subwindow;
192 // Video surface if a subwindow
193         CanvasOutput *canvas_subwindow;
194 // Video surface if fullscreen
195         CanvasFullScreen *canvas_fullscreen;
196         CanvasXScroll *xscroll;
197         CanvasYScroll *yscroll;
198         CanvasPopup *canvas_menu;
199         CanvasFullScreenPopup *fullscreen_menu;
200         int x, y, w, h;
201         int use_scrollbars;
202         BC_WindowBase *canvas_auxwindow;
203 // Used in record monitor
204         int output_w, output_h;
205 // Last frame played is stored here in driver format for
206 // refreshes.
207         VFrame *refresh_frame;
208 // Results from last get_scrollbars
209         int w_needed;
210         int h_needed;
211         int w_visible;
212         int h_visible;
213 // For cases where video is not enabled on the canvas but processing is
214 // occurring for a single frame, this causes the status to update.
215         int is_processing;
216 // Cursor is inside video surface
217         int cursor_inside;
218         int view_x;
219         int view_y;
220         int view_w;
221         int view_h;
222         int scr_w0;
223         int root_w, root_h;
224
225         MWindow *mwindow;
226
227 private:
228         void get_scrollbars(EDL *edl,
229                 int &canvas_x, int &canvas_y, int &canvas_w, int &canvas_h);
230         Mutex *canvas_lock;
231 };
232
233
234 class CanvasOutput : public BC_SubWindow
235 {
236 public:
237         CanvasOutput(Canvas *canvas,
238                 int x, int y, int w, int h);
239         ~CanvasOutput();
240
241         int cursor_leave_event();
242         int cursor_enter_event();
243         int button_press_event();
244         int button_release_event();
245         int cursor_motion_event();
246         int keypress_event();
247
248         Canvas *canvas;
249 };
250
251
252
253
254 class CanvasFullScreen : public BC_FullScreen
255 {
256 public:
257         CanvasFullScreen(Canvas *canvas, int w, int h);
258         ~CanvasFullScreen();
259
260         Canvas *canvas;
261 };
262
263
264
265
266 class CanvasXScroll : public BC_ScrollBar
267 {
268 public:
269         CanvasXScroll(EDL *edl,
270                 Canvas *canvas,
271                 int x,
272                 int y,
273                 int length,
274                 int position,
275                 int handle_length,
276                 int pixels);
277         ~CanvasXScroll();
278
279         int handle_event();
280         Canvas *canvas;
281         EDL *edl;
282 };
283
284 class CanvasYScroll : public BC_ScrollBar
285 {
286 public:
287         CanvasYScroll(EDL *edl,
288                 Canvas *canvas,
289                 int x,
290                 int y,
291                 int length,
292                 int position,
293                 int handle_length,
294                 int pixels);
295         ~CanvasYScroll();
296
297         int handle_event();
298
299         Canvas *canvas;
300         EDL *edl;
301 };
302
303 class CanvasFullScreenPopup : public BC_PopupMenu
304 {
305 public:
306         CanvasFullScreenPopup(Canvas *canvas);
307
308         void create_objects();
309         void use_cwindow();
310
311         Canvas *canvas;
312 };
313
314 class CanvasSubWindowItem : public BC_MenuItem
315 {
316 public:
317         CanvasSubWindowItem(Canvas *canvas);
318         int handle_event();
319         Canvas *canvas;
320 };
321
322 class CanvasPopup : public BC_PopupMenu
323 {
324 public:
325         CanvasPopup(Canvas *canvas);
326         ~CanvasPopup();
327
328         void create_objects();
329         void use_cwindow();
330         void use_rwindow();
331         void use_vwindow();
332
333         Canvas *canvas;
334         CanvasToggleControls *toggle_controls;
335 };
336
337 class CanvasPopupSize : public BC_MenuItem
338 {
339 public:
340         CanvasPopupSize(Canvas *canvas, char *text, float percentage);
341         ~CanvasPopupSize();
342         int handle_event();
343         Canvas *canvas;
344         float percentage;
345 };
346
347 class CanvasPopupAuto : public BC_MenuItem
348 {
349 public:
350         CanvasPopupAuto(Canvas *canvas);
351         int handle_event();
352         Canvas *canvas;
353 };
354
355 class CanvasPopupResetCamera : public BC_MenuItem
356 {
357 public:
358         CanvasPopupResetCamera(Canvas *canvas);
359         int handle_event();
360         Canvas *canvas;
361 };
362
363 class CanvasPopupResetProjector : public BC_MenuItem
364 {
365 public:
366         CanvasPopupResetProjector(Canvas *canvas);
367         int handle_event();
368         Canvas *canvas;
369 };
370
371 class CanvasToggleControls : public BC_MenuItem
372 {
373 public:
374         CanvasToggleControls(Canvas *canvas);
375         int handle_event();
376         static char* calculate_text(int cwindow_controls);
377         Canvas *canvas;
378 };
379
380 class CanvasFullScreenItem : public BC_MenuItem
381 {
382 public:
383         CanvasFullScreenItem(Canvas *canvas);
384         int handle_event();
385         Canvas *canvas;
386 };
387
388 class CanvasPopupResetTranslation : public BC_MenuItem
389 {
390 public:
391         CanvasPopupResetTranslation(Canvas *canvas);
392         int handle_event();
393         Canvas *canvas;
394 };
395
396
397 class CanvasPopupRemoveSource : public BC_MenuItem
398 {
399 public:
400         CanvasPopupRemoveSource(Canvas *canvas);
401         int handle_event();
402         Canvas *canvas;
403 };
404
405
406
407
408
409 #endif