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