1 /*
2 * Copyright (c) 2010-2011, Texas Instruments Incorporated
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * * Neither the name of Texas Instruments Incorporated nor the names of
16 * its contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
29 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 *
31 * Contact information for paper mail:
32 * Texas Instruments
33 * Post Office Box 655303
34 * Dallas, Texas 75265
35 * Contact information:
36 * http://www-k.ext.ti.com/sc/technical-support/product-information-centers.htm
37 * ?DCMP=TIHomeTracking&HQS=Other+OT+home_d_contact
38 * ============================================================================
39 *
40 */
42 /**
43 * @file gui.c
44 *
45 * @brief Defines the functions exported by the GUI.
46 * Also, defines the static functions and the callback funtions
47 */
49 #include <gtk/gtk.h>
50 #include <gst/gst.h>
52 #include <gui.h>
53 #include <common.h>
54 #include <gst-controller.h>
56 static GUIWindow *window[] = {NULL, NULL};
57 static Pipeline *pipes[] = {NULL, NULL};
58 static GtkWidget *helpWindow = NULL;
59 static GtkWidget *logWindow[] = {NULL, NULL};
62 static void setControlActive(GUIWindow *window, gboolean activeFlag)
63 {
64 gtk_widget_set_sensitive(window->playButton,activeFlag);
65 gtk_widget_set_sensitive(window->pauseButton,activeFlag);
66 gtk_widget_set_sensitive(window->stopButton,activeFlag);
67 gtk_widget_set_sensitive(window->rewindButton,activeFlag);
68 gtk_widget_set_sensitive(window->forwardButton,activeFlag);
69 gtk_widget_set_sensitive(window->openButton,activeFlag);
70 gtk_widget_set_sensitive(window->seekScale,activeFlag);
71 }
73 static void setControlMode(GUIWindow *thisWindow,
74 gint modeFlag,
75 gint activeFlag)
76 {
77 setControlActive(thisWindow, activeFlag);
78 if(activeFlag){
79 switch(modeFlag){
80 case CONTROL_MODE_NO_FILE:
81 gtk_widget_set_sensitive(thisWindow->playButton,FALSE);
82 gtk_widget_set_sensitive(thisWindow->pauseButton,FALSE);
84 gtk_widget_set_sensitive(thisWindow->stopButton,FALSE);
85 gtk_widget_set_sensitive(thisWindow->rewindButton,FALSE);
86 gtk_widget_set_sensitive(thisWindow->forwardButton,FALSE);
87 gtk_widget_set_sensitive(thisWindow->seekScale,FALSE);
89 break;
90 case CONTROL_MODE_PLAYING:
91 gtk_widget_set_sensitive(thisWindow->playButton,TRUE);
92 gtk_widget_set_sensitive(thisWindow->pauseButton,TRUE);
94 gtk_widget_set_sensitive(thisWindow->stopButton,TRUE);
95 gtk_widget_set_sensitive(thisWindow->rewindButton,TRUE);
96 gtk_widget_set_sensitive(thisWindow->forwardButton,TRUE);
97 gtk_widget_set_sensitive(thisWindow->seekScale,TRUE);
99 break;
100 case CONTROL_MODE_STOPPED:
101 gtk_widget_set_sensitive(thisWindow->playButton,TRUE);
102 gtk_widget_set_sensitive(thisWindow->pauseButton,TRUE);
104 gtk_widget_set_sensitive(thisWindow->stopButton,TRUE);
105 gtk_widget_set_sensitive(thisWindow->rewindButton,TRUE);
106 gtk_widget_set_sensitive(thisWindow->forwardButton,TRUE);
107 gtk_widget_set_sensitive(thisWindow->seekScale,FALSE);
109 break;
110 case CONTROL_MODE_PAUSED:
111 gtk_widget_set_sensitive(thisWindow->playButton,TRUE);
112 gtk_widget_set_sensitive(thisWindow->pauseButton,TRUE);
114 gtk_widget_set_sensitive(thisWindow->stopButton,TRUE);
115 gtk_widget_set_sensitive(thisWindow->rewindButton,TRUE);
116 gtk_widget_set_sensitive(thisWindow->forwardButton,TRUE);
117 gtk_widget_set_sensitive(thisWindow->seekScale,TRUE);
119 break;
120 }
121 }
122 switch(modeFlag){
123 case CONTROL_MODE_NO_FILE:
124 gtk_widget_show(thisWindow->playButton);
125 gtk_widget_hide(thisWindow->pauseButton);
127 gtk_label_set_text(GTK_LABEL(thisWindow->statusLabel),
128 LABEL_TEXT_NO_FILE);
129 gtk_label_set_text(GTK_LABEL(thisWindow->timeLabel),
130 TIME_LABEL_ORIGIN);
131 break;
132 case CONTROL_MODE_PLAYING:
133 gtk_widget_show(thisWindow->pauseButton);
134 gtk_widget_hide(thisWindow->playButton);
136 gtk_label_set_text(GTK_LABEL(thisWindow->statusLabel),
137 LABEL_TEXT_PLAYING);
138 gtk_label_set_text(GTK_LABEL(thisWindow->timeLabel),
139 TIME_LABEL_ORIGIN);
140 break;
141 case CONTROL_MODE_STOPPED:
142 gtk_widget_show(thisWindow->playButton);
143 gtk_widget_hide(thisWindow->pauseButton);
145 gtk_label_set_text(GTK_LABEL(thisWindow->statusLabel),
146 LABEL_TEXT_STOPPED);
147 gtk_label_set_text(GTK_LABEL(thisWindow->timeLabel),
148 TIME_LABEL_ORIGIN);
149 break;
150 case CONTROL_MODE_PAUSED:
151 gtk_widget_show(thisWindow->playButton);
152 gtk_widget_hide(thisWindow->pauseButton);
154 gtk_label_set_text(GTK_LABEL(thisWindow->statusLabel),
155 LABEL_TEXT_PAUSED);
156 break;
158 }
159 }
161 static void setDecodeSwitch(gint decodeSwitch)
162 {
163 switch(decodeSwitch){
164 case DECODE_MODE_SINGLE:
165 gtk_button_set_label(
166 GTK_BUTTON(window[DECODER_INDEX_SINGLE]->switchButton),
167 SWITCH_TEXT_SINGLE);
168 gtk_button_set_label(
169 GTK_BUTTON(window[DECODER_INDEX_DOUBLE]->switchButton),
170 SWITCH_TEXT_SINGLE);
171 break;
172 case DECODE_MODE_DUAL:
173 gtk_button_set_label(
174 GTK_BUTTON(window[DECODER_INDEX_SINGLE]->switchButton),
175 SWITCH_TEXT_DUAL);
176 gtk_button_set_label(
177 GTK_BUTTON(window[DECODER_INDEX_DOUBLE]->switchButton),
178 SWITCH_TEXT_DUAL);
179 }
180 }
182 static void setup()
183 {
184 gtk_widget_show_all(window[DECODER_INDEX_SINGLE]->window);
185 gtk_widget_show_all(window[DECODER_INDEX_DOUBLE]->window);
187 switch(decodeMode){
188 case DECODE_MODE_NONE:
189 setControlMode(window[DECODER_INDEX_SINGLE],
190 CONTROL_MODE_NO_FILE,
191 CONTROL_MODE_ACTIVE);
192 setControlMode(window[DECODER_INDEX_DOUBLE],
193 CONTROL_MODE_NO_FILE,
194 CONTROL_MODE_ACTIVE);
195 decodeMode = DECODE_MODE_DUAL;
196 setDecodeSwitch(DECODE_MODE_SINGLE);
197 break;
198 case DECODE_MODE_SINGLE:
199 setControlMode(window[DECODER_INDEX_SINGLE],
200 CONTROL_MODE_PLAYING,
201 CONTROL_MODE_ACTIVE);
202 setControlMode(window[DECODER_INDEX_DOUBLE],
203 CONTROL_MODE_PLAYING,
204 CONTROL_MODE_INACTIVE);
205 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
206 filename[DECODER_INDEX_SINGLE],
207 SEEK_START,
208 window[DECODER_INDEX_SINGLE]->drawArea,
209 window[DECODER_INDEX_DOUBLE]->drawArea);
210 setDecodeSwitch(DECODE_MODE_DUAL);
211 break;
212 case DECODE_MODE_DUAL:
213 setControlMode(window[DECODER_INDEX_SINGLE],
214 CONTROL_MODE_PLAYING,
215 CONTROL_MODE_ACTIVE);
216 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
217 filename[DECODER_INDEX_SINGLE],
218 SEEK_START,
219 window[DECODER_INDEX_SINGLE]->drawArea,
220 NULL);
221 setControlMode(window[DECODER_INDEX_DOUBLE],
222 CONTROL_MODE_PLAYING,
223 CONTROL_MODE_ACTIVE);
224 DualDecode_playMedia (pipes[DECODER_INDEX_DOUBLE],
225 filename[DECODER_INDEX_DOUBLE],
226 SEEK_START,
227 window[DECODER_INDEX_DOUBLE]->drawArea,
228 NULL);
229 setDecodeSwitch(DECODE_MODE_SINGLE);
230 break;
231 }
232 }
234 static gboolean cbOpenClicked(GtkWidget *widget, gpointer data)
235 {
236 GUIWindow *thisWindow = (GUIWindow *)data;
238 GtkWidget *fileChooser = gtk_file_chooser_dialog_new(
239 "Open",
240 GTK_WINDOW(thisWindow->window),
241 GTK_FILE_CHOOSER_ACTION_OPEN,
242 GTK_STOCK_OPEN,
243 GTK_RESPONSE_OK,
244 GTK_STOCK_CANCEL,
245 GTK_RESPONSE_CANCEL,
246 NULL);
247 gtk_window_set_modal(fileChooser,FALSE);
248 if(GTK_RESPONSE_OK == gtk_dialog_run(GTK_DIALOG(fileChooser))){
249 g_printerr("%s\n",
250 gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fileChooser)));
251 /*TODO : set global filename here*/
253 if(DECODE_MODE_SINGLE == decodeMode){
254 setControlMode(window[DECODER_INDEX_SINGLE],
255 CONTROL_MODE_PLAYING,
256 CONTROL_MODE_ACTIVE);
257 setControlMode(window[DECODER_INDEX_DOUBLE],
258 CONTROL_MODE_PLAYING,
259 CONTROL_MODE_INACTIVE);
260 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
261 filename[DECODER_INDEX_SINGLE],
262 SEEK_START,
263 window[DECODER_INDEX_SINGLE]->drawArea,
264 window[DECODER_INDEX_DOUBLE]->drawArea);
265 }else{
266 if(window[DECODER_INDEX_SINGLE] == thisWindow){
267 setControlMode(window[DECODER_INDEX_SINGLE],
268 CONTROL_MODE_PLAYING,
269 CONTROL_MODE_ACTIVE);
270 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
271 filename[DECODER_INDEX_SINGLE],
272 SEEK_START,
273 window[DECODER_INDEX_SINGLE]->drawArea,
274 NULL);
275 }else{
276 setControlMode(window[DECODER_INDEX_DOUBLE],
277 CONTROL_MODE_PLAYING,
278 CONTROL_MODE_ACTIVE);
279 DualDecode_playMedia(pipes[DECODER_INDEX_DOUBLE],
280 filename[DECODER_INDEX_DOUBLE],
281 SEEK_START,
282 window[DECODER_INDEX_DOUBLE]->drawArea,
283 NULL);
284 }
285 }
286 }
287 gtk_widget_destroy(fileChooser);
288 }
290 static gboolean cbPlayClicked(GtkWidget *widget, gpointer data)
291 {
292 GUIWindow *thisWindow = (GUIWindow *)data;
294 if(DECODE_MODE_SINGLE == decodeMode){
295 setControlMode(window[DECODER_INDEX_SINGLE],
296 CONTROL_MODE_PLAYING,
297 CONTROL_MODE_ACTIVE);
298 setControlMode(window[DECODER_INDEX_DOUBLE],
299 CONTROL_MODE_PLAYING,
300 CONTROL_MODE_INACTIVE);
301 if(GST_STATE_PAUSED ==
302 DualDecode_getMediaState(pipes[DECODER_INDEX_SINGLE])){
303 DualDecode_resumeMedia(pipes[DECODER_INDEX_SINGLE]);
304 }else{
305 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
306 filename[DECODER_INDEX_SINGLE],
307 SEEK_START,
308 window[DECODER_INDEX_SINGLE]->drawArea,
309 window[DECODER_INDEX_DOUBLE]->drawArea);
310 }
311 }else{
312 if(window[DECODER_INDEX_SINGLE] == thisWindow){
313 setControlMode(window[DECODER_INDEX_SINGLE],
314 CONTROL_MODE_PLAYING,
315 CONTROL_MODE_ACTIVE);
316 if(GST_STATE_PAUSED ==
317 DualDecode_getMediaState(pipes[DECODER_INDEX_SINGLE])){
318 DualDecode_resumeMedia(pipes[DECODER_INDEX_SINGLE]);
319 }else{
320 DualDecode_playMedia(pipes[DECODER_INDEX_SINGLE],
321 filename[DECODER_INDEX_SINGLE],
322 SEEK_START,
323 window[DECODER_INDEX_SINGLE]->drawArea,
324 NULL);
325 }
326 }else{
327 setControlMode(window[DECODER_INDEX_DOUBLE],
328 CONTROL_MODE_PLAYING,
329 CONTROL_MODE_ACTIVE);
330 if(GST_STATE_PAUSED ==
331 DualDecode_getMediaState(pipes[DECODER_INDEX_DOUBLE])){
332 DualDecode_resumeMedia(pipes[DECODER_INDEX_DOUBLE]);
333 }else{
334 DualDecode_playMedia(pipes[DECODER_INDEX_DOUBLE],
335 filename[DECODER_INDEX_DOUBLE],
336 SEEK_START,
337 window[DECODER_INDEX_DOUBLE]->drawArea,
338 NULL);
339 }
340 }
341 }
342 }
344 static gboolean cbPauseClicked(GtkWidget *widget, gpointer data)
345 {
346 GUIWindow *thisWindow = (GUIWindow *)data;
348 if(DECODE_MODE_SINGLE == decodeMode){
349 setControlMode(window[DECODER_INDEX_SINGLE],
350 CONTROL_MODE_PAUSED,
351 CONTROL_MODE_ACTIVE);
352 setControlMode(window[DECODER_INDEX_DOUBLE],
353 CONTROL_MODE_PAUSED,
354 CONTROL_MODE_INACTIVE);
355 DualDecode_pauseMedia(pipes[DECODER_INDEX_SINGLE]);
356 }else{
357 if(window[DECODER_INDEX_SINGLE] == thisWindow){
358 setControlMode(window[DECODER_INDEX_SINGLE],
359 CONTROL_MODE_PAUSED,
360 CONTROL_MODE_ACTIVE);
361 DualDecode_pauseMedia(pipes[DECODER_INDEX_SINGLE]);
362 }else{
363 setControlMode(window[DECODER_INDEX_DOUBLE],
364 CONTROL_MODE_PAUSED,
365 CONTROL_MODE_ACTIVE);
366 DualDecode_pauseMedia(pipes[DECODER_INDEX_DOUBLE]);
367 }
368 }
369 }
371 static gboolean cbStopClicked(GtkWidget *widget, gpointer data)
372 {
373 GUIWindow *thisWindow = (GUIWindow *)data;
375 if(DECODE_MODE_SINGLE == decodeMode){
376 setControlMode(window[DECODER_INDEX_SINGLE],
377 CONTROL_MODE_STOPPED,
378 CONTROL_MODE_ACTIVE);
379 setControlMode(window[DECODER_INDEX_DOUBLE],
380 CONTROL_MODE_STOPPED,
381 CONTROL_MODE_INACTIVE);
382 DualDecode_stopMedia(pipes[DECODER_INDEX_SINGLE]);
383 }else{
384 if(window[DECODER_INDEX_SINGLE] == thisWindow){
385 setControlMode(window[DECODER_INDEX_SINGLE],
386 CONTROL_MODE_STOPPED,
387 CONTROL_MODE_ACTIVE);
388 DualDecode_stopMedia(pipes[DECODER_INDEX_SINGLE]);
389 }else{
390 setControlMode(window[DECODER_INDEX_DOUBLE],
391 CONTROL_MODE_STOPPED,
392 CONTROL_MODE_ACTIVE);
393 DualDecode_stopMedia(pipes[DECODER_INDEX_DOUBLE]);
394 }
395 }
396 }
398 static gboolean cbWindowClosed(GtkWidget *widget, gpointer data){
399 DualDecode_exitApplication();
400 }
402 static GUIWindow *createWindow()
403 {
404 GUIWindow *ret = NULL;
405 ret = g_malloc0(sizeof(GUIWindow));
406 if(NULL == ret){
407 return ret;
408 }
409 DualDecode_builderCreate();
411 ret->window = DualDecode_getWidget("decodeWindowSingle");
412 if(NULL == ret->window){
413 goto memCleanup;
414 }
415 ret->windowCloseSignal = g_signal_connect(G_OBJECT(ret->window),
416 "delete-event",
417 G_CALLBACK(cbWindowClosed),
418 NULL);
420 GtkWidget *toolbar = DualDecode_getWidget("toolbarSingle");
421 if(NULL == toolbar){
422 goto memCleanup;
423 }
424 ret->drawArea = DualDecode_getWidget("videoViewerSingle");
425 if(NULL == ret->drawArea){
426 goto memCleanup;
427 }
429 ret->openButton = GTK_WIDGET(
430 gtk_tool_button_new_from_stock(GTK_STOCK_OPEN));
431 if(NULL == ret->openButton){
432 goto memCleanup;
433 }
434 ret->rewindButton = GTK_WIDGET(
435 gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_REWIND));
436 if(NULL == ret->rewindButton){
437 goto memCleanup;
438 }
439 ret->playButton = GTK_WIDGET(
440 gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY));
441 if(NULL == ret->playButton){
442 goto memCleanup;
443 }
444 ret->pauseButton = GTK_WIDGET(
445 gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PAUSE));
446 if(NULL == ret->pauseButton){
447 goto memCleanup;
448 }
449 ret->stopButton = GTK_WIDGET(
450 gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_STOP));
451 if(NULL == ret->stopButton){
452 goto memCleanup;
453 }
454 ret->forwardButton = GTK_WIDGET(
455 gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_FORWARD));
456 if(NULL == ret->forwardButton){
457 goto memCleanup;
458 }
459 ret->helpButton = GTK_WIDGET(
460 gtk_tool_button_new_from_stock(GTK_STOCK_HELP));
461 if(NULL == ret->helpButton){
462 goto memCleanup;
463 }
465 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
466 GTK_TOOL_ITEM(ret->openButton),
467 -1);
468 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
469 gtk_separator_tool_item_new(),
470 -1);
471 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
472 GTK_TOOL_ITEM(ret->rewindButton),
473 -1);
474 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
475 GTK_TOOL_ITEM(ret->playButton),
476 -1);
477 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
478 GTK_TOOL_ITEM(ret->pauseButton),
479 -1);
480 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
481 GTK_TOOL_ITEM(ret->stopButton),
482 -1);
483 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
484 GTK_TOOL_ITEM(ret->forwardButton),
485 -1);
486 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
487 gtk_separator_tool_item_new(),
488 -1);
489 gtk_toolbar_insert(GTK_TOOLBAR(toolbar),
490 GTK_TOOL_ITEM(ret->helpButton),
491 -1);
493 ret->openSignal = g_signal_connect(G_OBJECT(ret->openButton),
494 "clicked",
495 G_CALLBACK(cbOpenClicked),
496 ret);
497 ret->stopSignal = g_signal_connect(G_OBJECT(ret->stopButton),
498 "clicked",
499 G_CALLBACK(cbStopClicked),
500 ret);
501 ret->pauseSignal = g_signal_connect(G_OBJECT(ret->pauseButton),
502 "clicked",
503 G_CALLBACK(cbPauseClicked),
504 ret);
505 ret->playSignal = g_signal_connect(G_OBJECT(ret->playButton),
506 "clicked",
507 G_CALLBACK(cbPlayClicked),
508 ret);
510 ret->switchButton = DualDecode_getWidget("switchButtonSingle");
511 if(NULL == ret->switchButton){
512 goto memCleanup;
513 }
515 /*TODO: connect switch signal here*/
517 ret->seekScale = DualDecode_getWidget("seekScaleSingle");
518 if(NULL == ret->seekScale){
519 goto memCleanup;
520 }
522 /*TODO: connect scale signal here*/
524 ret->statusLabel = DualDecode_getWidget("statusLabelSingle");
525 if(NULL == ret->statusLabel){
526 goto memCleanup;
527 }
529 ret->timeLabel = DualDecode_getWidget("timeLabelSingle");
530 if(NULL == ret->timeLabel){
531 goto memCleanup;
532 }
534 goto last;
536 cleanup:
537 gtk_widget_destroy(ret->window);
538 memCleanup:
539 g_free(ret);
540 last:
541 DualDecode_builderClose();
542 return ret;
543 }
545 static GtkWidget *createLogWindow()
546 {
547 /*TODO: create help window*/
548 return gtk_window_new(GTK_WINDOW_TOPLEVEL);
549 }
551 static GtkWidget *createHelpWindow()
552 {
553 /*TODO: create help window*/
554 return gtk_window_new(GTK_WINDOW_TOPLEVEL);
555 }
557 G_GNUC_PRINTF(2,3) static void logGUI(GtkWidget *logWindow, gchar *format, ...)
558 {
559 /*TODO: dummy now*/
560 }
562 static void setWindowSizeLocation()
563 {
564 GdkScreen *screen = NULL;
565 gint screenWidth = -1;
566 gint screenHeight = -1;
567 gint windowWidth = -1;
568 gint windowHeight = -1;
570 screen = gdk_screen_get_default();
571 screenWidth = gdk_screen_get_width(screen);
572 screenHeight = gdk_screen_get_height(screen);
573 windowWidth = screenWidth/SCREEN_WIDTH_FACTOR;
574 windowHeight = screenHeight/SCREEN_HEIGHT_FACTOR;
576 gtk_widget_set_size_request(window[DECODER_INDEX_SINGLE]->window,
577 windowWidth,windowHeight);
578 gtk_widget_set_size_request(window[DECODER_INDEX_DOUBLE]->window,
579 windowWidth,windowHeight);
580 gtk_window_move(GTK_WINDOW(window[DECODER_INDEX_SINGLE]->window),
581 (screenWidth-2*windowWidth)/2,
582 0);
583 gtk_window_move(GTK_WINDOW(window[DECODER_INDEX_DOUBLE]->window),
584 (screenWidth-2*windowWidth)/2+windowWidth,
585 0);
586 }
588 void DualDecode_startApplication()
589 {
590 window[DECODER_INDEX_SINGLE] = createWindow();
591 g_assert(window[DECODER_INDEX_SINGLE] != NULL);
593 window[DECODER_INDEX_DOUBLE] = createWindow();
594 g_assert(window[DECODER_INDEX_DOUBLE] != NULL);
596 setWindowSizeLocation();
598 helpWindow = createHelpWindow();
599 g_assert(helpWindow != NULL);
601 logWindow[DECODER_INDEX_SINGLE] = createLogWindow();
602 g_assert(logWindow[DECODER_INDEX_SINGLE] != NULL);
604 logWindow[DECODER_INDEX_DOUBLE] = createLogWindow();
605 g_assert(logWindow[DECODER_INDEX_DOUBLE] != NULL);
607 pipes[DECODER_INDEX_SINGLE] = DualDecode_createPipeline();
608 DualDecode_setLogFunction(pipes[DECODER_INDEX_SINGLE],
609 logGUI,
610 logWindow[DECODER_INDEX_SINGLE]);
612 pipes[DECODER_INDEX_DOUBLE] = DualDecode_createPipeline();
613 DualDecode_setLogFunction(pipes[DECODER_INDEX_DOUBLE],
614 logGUI,
615 logWindow[DECODER_INDEX_DOUBLE]);
617 setup();
619 gtk_main();
620 }
622 void DualDecode_exitApplication()
623 {
624 gtk_widget_destroy(window[DECODER_INDEX_SINGLE]->window);
625 gtk_widget_destroy(window[DECODER_INDEX_DOUBLE]->window);
626 g_free(window[DECODER_INDEX_SINGLE]);
627 g_free(window[DECODER_INDEX_DOUBLE]);
628 gtk_widget_destroy(logWindow[DECODER_INDEX_SINGLE]);
629 gtk_widget_destroy(logWindow[DECODER_INDEX_DOUBLE]);
630 gtk_widget_destroy(helpWindow);
632 /*TODO: destroy pipes here*/
634 gtk_main_quit();
635 }
637 gboolean DualDecode_initGUI(gint *argc, char **argv[])
638 {
639 return gtk_init_check(argc,argv);
640 }