1 #include "lqt_private.h"
2 #include "lqt_gtk.h"
3 #include <stdlib.h>
4 #include <string.h>
5
6 #include <libintl.h>
7 #define _(str) dgettext(PACKAGE, str)
8 #define TR_DOM(str) dgettext(gettext_domain, str)
9
10 #define GTK_OPTION_MENU(x) x
11
12 enum
13 {
14 LQGTK_LIST_CODEC_NAME_COLUMN_ID = 0,
15 LQGTK_LIST_CODEC_INDEX_COLUMN_ID,
16 LQGTK_LIST_CODEC_NUM_COLS
17 };
18
lqtgtk_widget_set_can_default(GtkWidget * w,gboolean can_default)19 void lqtgtk_widget_set_can_default(GtkWidget * w, gboolean can_default)
20 {
21 #if GTK_CHECK_VERSION(2,18,0)
22 gtk_widget_set_can_default(w, can_default);
23 #else
24 if(can_default)
25 GTK_WIDGET_SET_FLAGS(w, GTK_CAN_DEFAULT);
26 else
27 GTK_WIDGET_UNSET_FLAGS(w, GTK_CAN_DEFAULT);
28 #endif
29 }
30
parameter_combobox_callback(GtkWidget * w,gpointer data)31 static void parameter_combobox_callback(GtkWidget * w, gpointer data)
32 {
33 LqtGtkParameterWidget * p = (LqtGtkParameterWidget*)data;
34 p->selected = gtk_combo_box_get_active(GTK_COMBO_BOX(w));
35 }
36
37 /*
38 * Transfer parameters from the widgets to the default
39 * values in the parameter info.
40 */
41
parameter_set_string(lqt_parameter_info_t * info,const char * str)42 static void parameter_set_string(lqt_parameter_info_t * info,
43 const char * str)
44 {
45 if(info->val_default.val_string)
46 free(info->val_default.val_string);
47 info->val_default.val_string = malloc(strlen(str)+1);
48 strcpy(info->val_default.val_string, str);
49 }
50
parameter_widget_apply(LqtGtkParameterWidget * w)51 static void parameter_widget_apply(LqtGtkParameterWidget * w)
52 {
53 const char * ptr;
54 switch(w->parameter_info->type)
55 {
56 case LQT_PARAMETER_STRINGLIST:
57 ptr = w->parameter_info->stringlist_options[w->selected];
58 parameter_set_string(w->parameter_info, ptr);
59 break;
60 case LQT_PARAMETER_STRING:
61 ptr = gtk_entry_get_text(GTK_ENTRY(w->widget));
62 parameter_set_string(w->parameter_info, ptr);
63 break;
64 case LQT_PARAMETER_INT:
65 if((w->parameter_info->val_min.val_int == 0) &&
66 (w->parameter_info->val_max.val_int == 1))
67 {
68 w->parameter_info->val_default.val_int =
69 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w->widget));
70 }
71 else if((w->parameter_info->val_min.val_int <
72 w->parameter_info->val_max.val_int))
73 {
74 w->parameter_info->val_default.val_int =
75 (int)(GTK_ADJUSTMENT(w->adjustment)->value);
76 }
77 else
78 {
79 w->parameter_info->val_default.val_int =
80 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(w->widget));
81 }
82 break;
83 case LQT_PARAMETER_FLOAT:
84 if((w->parameter_info->val_min.val_float <
85 w->parameter_info->val_max.val_float))
86 {
87 w->parameter_info->val_default.val_float =
88 GTK_ADJUSTMENT(w->adjustment)->value;
89 }
90 else
91 {
92 w->parameter_info->val_default.val_float =
93 gtk_spin_button_get_value(GTK_SPIN_BUTTON(w->widget));
94 }
95 case LQT_PARAMETER_SECTION:
96 break;
97 }
98
99 }
100
101
parameter_widget_update(LqtGtkParameterWidget * pw)102 static void parameter_widget_update(LqtGtkParameterWidget * pw)
103 {
104 int i;
105 switch(pw->parameter_info->type)
106 {
107 case LQT_PARAMETER_INT:
108 #ifndef NDEBUG
109 fprintf(stderr, "Parameter: %s: %d\n", pw->parameter_info->name,
110 pw->parameter_info->val_default.val_int);
111 #endif
112 /* Boolean */
113 if((pw->parameter_info->val_min.val_int == 0) && (pw->parameter_info->val_max.val_int == 1))
114 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pw->widget),
115 pw->parameter_info->val_default.val_int);
116 /* Integer with limits -> slider */
117 else if(pw->parameter_info->val_min.val_int < pw->parameter_info->val_max.val_int)
118 gtk_adjustment_set_value(GTK_ADJUSTMENT(pw->adjustment),
119 pw->parameter_info->val_default.val_int);
120 /* Spinbutton */
121 else
122 gtk_spin_button_set_value(GTK_SPIN_BUTTON(pw->widget),
123 pw->parameter_info->val_default.val_int);
124 break;
125 case LQT_PARAMETER_FLOAT:
126 #ifndef NDEBUG
127 fprintf(stderr, "Parameter: %s: %f\n", pw->parameter_info->name,
128 pw->parameter_info->val_default.val_float);
129 #endif
130 /* Float with limits -> slider */
131 if(pw->parameter_info->val_min.val_float < pw->parameter_info->val_max.val_float)
132 gtk_adjustment_set_value(GTK_ADJUSTMENT(pw->adjustment),
133 pw->parameter_info->val_default.val_float);
134 /* Spinbutton */
135 else
136 gtk_spin_button_set_value(GTK_SPIN_BUTTON(pw->widget),
137 pw->parameter_info->val_default.val_float);
138 break;
139 case LQT_PARAMETER_STRING:
140 #ifndef NDEBUG
141 fprintf(stderr, "Parameter: %s: %s\n", pw->parameter_info->name,
142 pw->parameter_info->val_default.val_string);
143 #endif
144 gtk_entry_set_text(GTK_ENTRY(pw->widget),
145 pw->parameter_info->val_default.val_string);
146 break;
147 case LQT_PARAMETER_STRINGLIST: /* String with options */
148 #ifndef NDEBUG
149 fprintf(stderr, "Parameter: %s: %s\n", pw->parameter_info->name,
150 pw->parameter_info->val_default.val_string);
151 #endif
152 for(i = 0; i < pw->parameter_info->num_stringlist_options; i++)
153 {
154 if(!strcmp(pw->parameter_info->stringlist_options[i],
155 pw->parameter_info->val_default.val_string))
156 {
157 gtk_combo_box_set_active(GTK_COMBO_BOX(pw->widget), i);
158 break;
159 }
160 }
161 case LQT_PARAMETER_SECTION:
162 break;
163 }
164 }
165
166 /*
167 * Really dirty trick to get tooltips for a GtkComboBox working:
168 * loop through all container children and set the tooltip for
169 * the child, which is a button
170 */
171
172 static void
set_combo_tooltip(GtkWidget * widget,gpointer data)173 set_combo_tooltip(GtkWidget *widget, gpointer data)
174 {
175 LqtGtkParameterWidget * w = (LqtGtkParameterWidget *)data;
176 // GtkTooltips *tooltips = (GtkTooltips *)data;
177
178 if(GTK_IS_BUTTON (widget))
179 #if GTK_MINOR_VERSION < 12
180 gtk_tooltips_set_tip(w->tooltips, widget,
181 w->parameter_info->help_string,
182 NULL);
183 #else
184 gtk_widget_set_tooltip_text(widget, w->parameter_info->help_string);
185 #endif
186 }
187
188 static void
realize_combo(GtkWidget * combo,gpointer data)189 realize_combo(GtkWidget *combo, gpointer data)
190 {
191 LqtGtkParameterWidget * w = (LqtGtkParameterWidget *)data;
192
193 gtk_container_forall (GTK_CONTAINER (combo),
194 set_combo_tooltip,
195 w);
196 }
197
set_tooltip(LqtGtkParameterWidget * widget,GtkWidget * w)198 static void set_tooltip(LqtGtkParameterWidget * widget,
199 GtkWidget * w)
200 {
201 #if GTK_MINOR_VERSION < 12
202 gtk_tooltips_set_tip(widget->tooltips, w,
203 widget->parameter_info->help_string,
204 widget->parameter_info->help_string);
205 #else
206 gtk_widget_set_tooltip_text(w, widget->parameter_info->help_string);
207 #endif
208 }
209
210 #if GTK_MINOR_VERSION < 12
211 LqtGtkParameterWidget *
lqtgtk_create_parameter_widget(lqt_parameter_info_t * info,GtkTooltips * tooltips,const char * gettext_domain)212 lqtgtk_create_parameter_widget(lqt_parameter_info_t * info, GtkTooltips * tooltips, const char * gettext_domain)
213 #else
214 LqtGtkParameterWidget *
215 lqtgtk_create_parameter_widget(lqt_parameter_info_t * info,
216 const char * gettext_domain)
217 #endif
218 {
219 int i;
220 LqtGtkParameterWidget * ret = calloc(1, sizeof(LqtGtkParameterWidget));
221 #if GTK_MINOR_VERSION < 12
222 ret->tooltips = tooltips;
223 #endif
224 ret->parameter_info = info;
225
226 switch(info->type)
227 {
228 case LQT_PARAMETER_INT:
229
230 /* Boolean */
231 if((info->val_min.val_int == 0) && (info->val_max.val_int == 1))
232 {
233 ret->widget =
234 gtk_check_button_new_with_label(TR_DOM(info->real_name));
235 if(info->help_string)
236 set_tooltip(ret, ret->widget);
237 }
238 /* Integer with limits -> slider */
239 else if(info->val_min.val_int < info->val_max.val_int)
240 {
241 ret->label = gtk_label_new(TR_DOM(info->real_name));
242 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
243 ret->adjustment = gtk_adjustment_new((gfloat) info->val_min.val_int,
244 (gfloat) info->val_min.val_int,
245 (gfloat) info->val_max.val_int,
246 0.0,
247 0.0,
248 0.0);
249 ret->widget = gtk_hscale_new(GTK_ADJUSTMENT(ret->adjustment));
250 gtk_scale_set_value_pos(GTK_SCALE(ret->widget),
251 GTK_POS_LEFT);
252
253 gtk_scale_set_digits(GTK_SCALE(ret->widget), 0);
254 if(info->help_string)
255 set_tooltip(ret, ret->widget);
256 }
257 /* Spinbutton */
258 else
259 {
260 ret->label = gtk_label_new(TR_DOM(info->real_name));
261 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
262 ret->adjustment = gtk_adjustment_new(0.0,
263 -1.0e8,
264 1.0e8,
265 1.0,
266 1.0,
267 0.0);
268 ret->widget = gtk_spin_button_new(GTK_ADJUSTMENT(ret->adjustment),
269 0.0,
270 0);
271 if(info->help_string)
272 set_tooltip(ret, ret->widget);
273 }
274 break;
275 case LQT_PARAMETER_FLOAT:
276
277 /* Float with limits -> slider */
278 if(info->val_min.val_float < info->val_max.val_float)
279 {
280 ret->label = gtk_label_new(TR_DOM(info->real_name));
281 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
282 ret->adjustment = gtk_adjustment_new(info->val_min.val_float,
283 info->val_min.val_float,
284 info->val_max.val_float,
285 0.0,
286 0.0,
287 0.0);
288
289 ret->widget = gtk_hscale_new(GTK_ADJUSTMENT(ret->adjustment));
290
291 gtk_scale_set_digits(GTK_SCALE(ret->widget),
292 info->num_digits);
293 // fprintf(stderr, "** NUM DIGITS: %d\n", info->num_digits);
294
295 gtk_scale_set_value_pos(GTK_SCALE(ret->widget),
296 GTK_POS_LEFT);
297
298 if(info->help_string)
299 set_tooltip(ret, ret->widget);
300 }
301 /* Spinbutton */
302 else
303 {
304 ret->label = gtk_label_new(TR_DOM(info->real_name));
305 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
306 ret->adjustment = gtk_adjustment_new(0.0,
307 -1.0e8,
308 1.0e8,
309 1.0,
310 1.0,
311 1.0);
312 ret->widget = gtk_spin_button_new(GTK_ADJUSTMENT(ret->adjustment),
313 0.0,
314 0);
315
316 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(ret->widget),
317 info->num_digits);
318
319 if(info->help_string)
320 set_tooltip(ret, ret->widget);
321 }
322 break;
323 case LQT_PARAMETER_STRING:
324 ret->label = gtk_label_new(TR_DOM(info->real_name));
325 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
326 ret->widget = gtk_entry_new();
327 if(info->help_string)
328 set_tooltip(ret, ret->widget);
329 break;
330 case LQT_PARAMETER_STRINGLIST: /* String with options */
331 ret->selected = 0;
332 ret->label = gtk_label_new(TR_DOM(info->real_name));
333 gtk_misc_set_alignment(GTK_MISC(ret->label), 0.0, 0.5);
334
335 #if ((GTK_MAJOR_VERSION == 2) && (GTK_MINOR_VERSION >= 24))
336 ret->widget = gtk_combo_box_text_new();
337 #else
338 ret->widget = gtk_combo_box_new_text();
339 #endif
340 for(i = 0; i < info->num_stringlist_options; i++)
341 {
342 #if ((GTK_MAJOR_VERSION == 2) && (GTK_MINOR_VERSION >= 24))
343 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (ret->widget),
344 info->stringlist_options[i]);
345 #else
346 gtk_combo_box_append_text (GTK_COMBO_BOX (ret->widget),
347 info->stringlist_options[i]);
348 #endif
349 }
350 g_signal_connect(GTK_COMBO_BOX (ret->widget),
351 "changed",
352 G_CALLBACK(parameter_combobox_callback),
353 ret);
354
355 if(info->help_string)
356 g_signal_connect (ret->widget, "realize",
357 G_CALLBACK (realize_combo), ret);
358
359
360 break;
361 case LQT_PARAMETER_SECTION:
362 break;
363 }
364
365 gtk_widget_set_size_request(ret->widget, 100, -1);
366
367 parameter_widget_update(ret);
368
369 gtk_widget_show(ret->widget);
370 if(ret->label)
371 gtk_widget_show(ret->label);
372 return ret;
373 }
374
375 /*
376 * Maybe empty function if we trust gtk's widget destroying mechanisms
377 */
378
379 void
lqtgtk_destroy_parameter_widget(LqtGtkParameterWidget * w)380 lqtgtk_destroy_parameter_widget(LqtGtkParameterWidget * w)
381 {
382 free(w);
383 }
384
385 /*
386 * Create Codec config widget
387 */
388
389 #if GTK_MINOR_VERSION < 12
create_table(lqt_parameter_info_t * parameter_info,LqtGtkParameterWidget ** widgets,int num_parameters,GtkTooltips * tooltips,const char * gettext_domain)390 static GtkWidget * create_table(lqt_parameter_info_t * parameter_info,
391 LqtGtkParameterWidget ** widgets,
392 int num_parameters, GtkTooltips * tooltips, const char * gettext_domain)
393 #else
394 static GtkWidget * create_table(lqt_parameter_info_t * parameter_info,
395 LqtGtkParameterWidget ** widgets,
396 int num_parameters, const char * gettext_domain)
397 #endif
398 {
399 int i;
400 GtkWidget * ret;
401 ret = gtk_table_new(num_parameters, 2, 0);
402 gtk_container_set_border_width(GTK_CONTAINER(ret),
403 10);
404 gtk_table_set_row_spacings(GTK_TABLE(ret),
405 5);
406 gtk_table_set_col_spacings(GTK_TABLE(ret),
407 5);
408
409 for(i = 0; i < num_parameters; i++)
410 {
411 #if GTK_MINOR_VERSION < 12
412 widgets[i] =
413 lqtgtk_create_parameter_widget(¶meter_info[i], tooltips, gettext_domain);
414 #else
415 widgets[i] =
416 lqtgtk_create_parameter_widget(¶meter_info[i], gettext_domain);
417 #endif
418 /* Bool parameters have no labels */
419
420 if(widgets[i]->label)
421 {
422 gtk_table_attach(GTK_TABLE(ret), widgets[i]->label,
423 0, 1, i, i+1, GTK_FILL, GTK_FILL, 0, 0);
424 gtk_table_attach(GTK_TABLE(ret), widgets[i]->widget,
425 1, 2, i, i+1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
426 }
427 else
428 {
429 gtk_table_attach(GTK_TABLE(ret), widgets[i]->widget,
430 0, 2, i, i+1, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
431 }
432 }
433 gtk_widget_show(ret);
434 return ret;
435 }
436
437 LqtGtkCodecConfigWidget *
lqtgtk_create_codec_config_widget(lqt_parameter_info_t * parameter_info,int num_parameters,const char * gettext_domain)438 lqtgtk_create_codec_config_widget(lqt_parameter_info_t * parameter_info,
439 int num_parameters, const char * gettext_domain)
440 {
441 int i, parameter_index;
442 GtkWidget * table;
443 GtkWidget * notebook;
444 GtkWidget * tab_label;
445 int num_sections = 0;
446 int parameters_in_section;
447 LqtGtkCodecConfigWidget * ret = calloc(1, sizeof(LqtGtkCodecConfigWidget));
448
449 #if GTK_MINOR_VERSION < 12
450 ret->tooltips = gtk_tooltips_new();
451 g_object_ref (G_OBJECT (ret->tooltips));
452
453 #if GTK_MINOR_VERSION < 10
454 gtk_object_sink (GTK_OBJECT (ret->tooltips));
455 #else
456 g_object_ref_sink(G_OBJECT(ret->tooltips));
457 #endif
458 #endif
459
460 if(parameter_info[0].type == LQT_PARAMETER_SECTION)
461 {
462 for(i = 0; i < num_parameters; i++)
463 {
464 if(parameter_info[i].type == LQT_PARAMETER_SECTION)
465 num_sections++;
466 }
467 }
468
469 ret->parameter_info = parameter_info;
470 ret->num_parameters = num_parameters - num_sections;
471
472 /* Create the parameter widgets */
473
474 ret->parameter_widgets = calloc(num_parameters - num_sections,
475 sizeof(LqtGtkParameterWidget *));
476
477 if(num_sections)
478 {
479 parameter_index = 1;
480 notebook = gtk_notebook_new();
481 for(i = 0; i < num_sections; i++)
482 {
483 /* Count parameters in this section */
484
485 parameters_in_section = 0;
486 while((parameters_in_section + parameter_index < num_parameters) &&
487 (parameter_info[parameters_in_section + parameter_index].type != LQT_PARAMETER_SECTION))
488 {
489 parameters_in_section++;
490 }
491
492 /* Create table */
493 #if GTK_MINOR_VERSION < 12
494 table = create_table(&(parameter_info[parameter_index]),
495 &(ret->parameter_widgets[parameter_index - i - 1]),
496 parameters_in_section, ret->tooltips, gettext_domain);
497 #else
498 table = create_table(&(parameter_info[parameter_index]),
499 &(ret->parameter_widgets[parameter_index - i - 1]),
500 parameters_in_section, gettext_domain);
501 #endif
502 /* Append table */
503
504 tab_label = gtk_label_new(TR_DOM(parameter_info[parameter_index-1].real_name));
505 gtk_widget_show(tab_label);
506 gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table, tab_label);
507
508 /* Increment */
509
510 parameter_index += parameters_in_section + 1;
511 }
512 gtk_widget_show(notebook);
513 ret->widget = notebook;
514 }
515 else
516 #if GTK_MINOR_VERSION < 12
517 ret->widget = create_table(parameter_info,
518 ret->parameter_widgets,
519 num_parameters, ret->tooltips,
520 gettext_domain);
521 #else
522 ret->widget = create_table(parameter_info,
523 ret->parameter_widgets,
524 num_parameters,
525 gettext_domain);
526 #endif
527 return ret;
528 }
529
530 /*
531 *
532 */
533 #if 0
534 static void codec_config_widget_apply(LqtGtkCodecConfigWidget * ccw)
535 {
536 int i;
537 for(i = 0; i < ccw->num_parameters; i++)
538 parameter_widget_apply(ccw->parameter_widgets[i]);
539 }
540 #endif
541
codec_config_widget_update(LqtGtkCodecConfigWidget * ccw)542 static void codec_config_widget_update(LqtGtkCodecConfigWidget * ccw)
543 {
544 int i;
545 for(i = 0; i < ccw->num_parameters; i++)
546 parameter_widget_update(ccw->parameter_widgets[i]);
547 }
548
lqtgtk_destroy_codec_config_widget(LqtGtkCodecConfigWidget * w)549 void lqtgtk_destroy_codec_config_widget(LqtGtkCodecConfigWidget * w)
550 {
551 int i;
552
553 for(i = 0; i < w->num_parameters; i++)
554 lqtgtk_destroy_parameter_widget(w->parameter_widgets[i]);
555
556 free(w->parameter_widgets);
557 free(w);
558 }
559
560
561 /*
562 * Codec Browser
563 */
564
browser_select_row_callback(GtkTreeSelection * selection,gpointer user_data)565 static void browser_select_row_callback(GtkTreeSelection *selection,
566 gpointer user_data)
567 {
568 LqtGtkCodecBrowser * cb = (LqtGtkCodecBrowser *)user_data;
569 GtkTreeModel * model;
570 GtkTreeIter iter;
571 gint row;
572
573 if (gtk_tree_selection_get_selected(selection, &model, &iter) == TRUE)
574 {
575
576 if(cb->selected == -1) /* ??? */
577 gtk_widget_set_sensitive(cb->info_button, 1);
578
579 gtk_tree_model_get(model, &iter, LQGTK_LIST_CODEC_INDEX_COLUMN_ID, &row, -1);
580 cb->selected = row;
581 cb->codec_info = cb->codecs[row];
582
583 if((cb->encode && cb->codec_info->num_encoding_parameters) ||
584 (cb->decode && cb->codec_info->num_decoding_parameters))
585 gtk_widget_set_sensitive(cb->parameters_button, 1);
586 else
587 gtk_widget_set_sensitive(cb->parameters_button, 0);
588
589 if(cb->selected == 0)
590 gtk_widget_set_sensitive(cb->up_button, 0);
591 else
592 gtk_widget_set_sensitive(cb->up_button, 1);
593
594 if(cb->selected == cb->num_codecs - 1)
595 gtk_widget_set_sensitive(cb->down_button, 0);
596 else
597 gtk_widget_set_sensitive(cb->down_button, 1);
598 }
599 }
600
601 static
lqtgtk_codec_browser_model_update(GtkTreeModel * model,int num_codecs,lqt_codec_info_t ** codecs)602 void lqtgtk_codec_browser_model_update(GtkTreeModel * model,
603 int num_codecs,
604 lqt_codec_info_t ** codecs)
605 {
606 int i;
607 const char * gettext_domain;
608 GtkListStore * store = GTK_LIST_STORE(model);
609 GtkTreeIter iter;
610
611 gtk_list_store_clear(store);
612 for(i = 0; i < num_codecs; i++)
613 {
614 gtk_list_store_append(store, &iter);
615
616 if(codecs[i]->gettext_domain && codecs[i]->gettext_directory)
617 {
618 bindtextdomain(codecs[i]->gettext_domain,
619 codecs[i]->gettext_directory);
620 gettext_domain = codecs[i]->gettext_domain;
621 }
622 else
623 {
624 lqt_translation_init();
625 gettext_domain = PACKAGE;
626 }
627
628 gtk_list_store_set(store, &iter,
629 LQGTK_LIST_CODEC_NAME_COLUMN_ID,
630 TR_DOM(codecs[i]->long_name),
631 LQGTK_LIST_CODEC_INDEX_COLUMN_ID,
632 i,
633 -1);
634 }
635
636 }
637
browser_move_codec(LqtGtkCodecBrowser * cb,int pos,int new_pos)638 static void browser_move_codec(LqtGtkCodecBrowser * cb, int pos, int new_pos)
639 {
640 lqt_codec_info_t * tmp_info;
641 GtkTreePath * path;
642 GtkTreeSelection * selection;
643
644 tmp_info = cb->codecs[pos];
645 cb->codecs[pos] = cb->codecs[new_pos];
646 cb->codecs[new_pos] = tmp_info;
647
648 /* We immediately apply this in the registry */
649
650 if(cb->type == LQT_CODEC_AUDIO)
651 lqt_reorder_audio_codecs(cb->codecs);
652 else if(cb->type == LQT_CODEC_VIDEO)
653 lqt_reorder_video_codecs(cb->codecs);
654
655 /* Enable up button */
656
657 if(!cb->selected && new_pos)
658 gtk_widget_set_sensitive(cb->up_button, 1);
659
660 /* Enable down button */
661
662 if((cb->selected == cb->num_codecs - 1) && (new_pos < cb->num_codecs - 1))
663 gtk_widget_set_sensitive(cb->down_button, 1);
664
665 /* Disable up button */
666
667 if(!new_pos)
668 gtk_widget_set_sensitive(cb->up_button, 0);
669
670 /* Disable down button */
671
672 if(new_pos == cb->num_codecs - 1)
673 gtk_widget_set_sensitive(cb->down_button, 0);
674
675 cb->selected = new_pos;
676
677 lqtgtk_codec_browser_model_update(cb->model, cb->num_codecs, cb->codecs);
678
679 /* The selected codec should still be visible */
680 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(cb->list));
681 path = gtk_tree_path_new_from_indices(cb->selected, -1);
682 gtk_tree_selection_select_path(selection, path);
683 gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(cb->list), path, NULL, FALSE, 0.0, 0.0);
684 gtk_tree_path_free(path);
685 }
686
browser_button_callback(GtkWidget * w,gpointer data)687 static void browser_button_callback(GtkWidget * w, gpointer data)
688 {
689 LqtGtkCodecBrowser * cb = (LqtGtkCodecBrowser *)data;
690
691 LqtGtkCodecConfigWindow * codec_config_window;
692 LqtGtkCodecInfoWindow * codec_info_window;
693
694 if(w == cb->up_button)
695 browser_move_codec(cb, cb->selected, cb->selected-1);
696 else if(w == cb->down_button)
697 browser_move_codec(cb, cb->selected, cb->selected+1);
698 else if(w == cb->parameters_button)
699 {
700 codec_config_window =
701 lqtgtk_create_codec_config_window(cb->codec_info,
702 cb->encode,
703 cb->decode);
704 lqtgtk_codec_config_window_run(codec_config_window);
705 lqtgtk_destroy_codec_config_window(codec_config_window);
706 }
707 else if(w == cb->info_button)
708 {
709 codec_info_window =
710 lqtgtk_create_codec_info_window(cb->codec_info);
711 lqtgtk_codec_info_window_run(codec_info_window);
712 }
713 }
714
lqtgtk_create_codec_browser(lqt_codec_type type,int encode,int decode)715 LqtGtkCodecBrowser * lqtgtk_create_codec_browser(lqt_codec_type type,
716 int encode, int decode)
717 {
718 LqtGtkCodecBrowser * ret = calloc(1, sizeof(LqtGtkCodecBrowser));
719 GtkCellRenderer * renderer;
720 GtkTreeSelection * selection;
721
722 ret->encode = encode;
723 ret->decode = decode;
724 ret->type = type;
725
726 ret->widget = gtk_table_new(4, 2, 0);
727 gtk_table_set_row_spacings(GTK_TABLE(ret->widget), 10);
728 gtk_table_set_col_spacings(GTK_TABLE(ret->widget), 10);
729 gtk_container_set_border_width(GTK_CONTAINER(ret->widget), 10);
730
731
732 ret->model = (GtkTreeModel *)gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
733 ret->list = gtk_tree_view_new_with_model(ret->model);
734 renderer = gtk_cell_renderer_text_new();
735 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(ret->list),
736 -1,
737 _("Installed codecs"),
738 renderer,
739 "text", LQGTK_LIST_CODEC_NAME_COLUMN_ID,
740 NULL);
741
742 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ret->list));
743 gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
744 g_signal_connect(G_OBJECT(selection), "changed",
745 G_CALLBACK(browser_select_row_callback),
746 (gpointer)ret);
747
748 gtk_widget_show(ret->list);
749
750 ret->scrolledwindow =
751 gtk_scrolled_window_new(NULL, NULL);
752
753 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ret->scrolledwindow),
754 GTK_POLICY_NEVER,
755 GTK_POLICY_AUTOMATIC);
756
757 gtk_container_add(GTK_CONTAINER(ret->scrolledwindow), ret->list);
758 gtk_widget_show(ret->scrolledwindow);
759
760 gtk_table_attach_defaults(GTK_TABLE(ret->widget), ret->scrolledwindow,
761 0, 1, 0, 4);
762
763 ret->up_button = gtk_button_new_with_label(_("Up"));
764 ret->down_button = gtk_button_new_with_label(_("Down"));
765
766 ret->parameters_button = gtk_button_new_with_label(_("Parameters..."));
767 ret->info_button = gtk_button_new_with_label(_("Info..."));
768
769 g_signal_connect(G_OBJECT(ret->up_button), "clicked",
770 G_CALLBACK(browser_button_callback),
771 (gpointer)ret);
772 g_signal_connect(G_OBJECT(ret->down_button), "clicked",
773 G_CALLBACK(browser_button_callback),
774 (gpointer)ret);
775 g_signal_connect(G_OBJECT(ret->parameters_button), "clicked",
776 G_CALLBACK(browser_button_callback),
777 (gpointer)ret);
778 g_signal_connect(G_OBJECT(ret->info_button), "clicked",
779 G_CALLBACK(browser_button_callback),
780 (gpointer)ret);
781
782 gtk_widget_show(ret->up_button);
783 gtk_widget_show(ret->down_button);
784 gtk_widget_show(ret->parameters_button);
785 gtk_widget_show(ret->info_button);
786
787 gtk_table_attach(GTK_TABLE(ret->widget),
788 ret->up_button, 1, 2, 0, 1,
789 GTK_FILL, GTK_FILL, 0, 0);
790 gtk_table_attach(GTK_TABLE(ret->widget),
791 ret->down_button, 1, 2, 1, 2,
792 GTK_FILL, GTK_FILL, 0, 0);
793 gtk_table_attach(GTK_TABLE(ret->widget),
794 ret->parameters_button, 1, 2, 2, 3,
795 GTK_FILL, GTK_FILL, 0, 0);
796 gtk_table_attach(GTK_TABLE(ret->widget),
797 ret->info_button, 1, 2, 3, 4,
798 GTK_FILL, GTK_FILL, 0, 0);
799
800 gtk_widget_show(ret->widget);
801 return ret;
802 }
803
lqtgtk_codec_browser_update(LqtGtkCodecBrowser * b)804 void lqtgtk_codec_browser_update(LqtGtkCodecBrowser * b)
805 {
806 b->num_codecs = 0;
807
808 if(b->codecs)
809 lqt_destroy_codec_info(b->codecs);
810
811 if(b->type == LQT_CODEC_AUDIO)
812 b->codecs = lqt_query_registry(1, 0, b->encode, b->decode);
813 else
814 b->codecs = lqt_query_registry(0, 1, b->encode, b->decode);
815
816 while(1)
817 {
818 if(b->codecs[b->num_codecs])
819 b->num_codecs++;
820 else
821 break;
822 }
823
824 lqtgtk_codec_browser_model_update(b->model,
825 b->num_codecs,
826 b->codecs);
827
828 b->selected = -1;
829 b->codec_info = b->codecs[0];
830
831 gtk_widget_set_sensitive(b->info_button, 0);
832 gtk_widget_set_sensitive(b->up_button, 0);
833 gtk_widget_set_sensitive(b->down_button, 0);
834 gtk_widget_set_sensitive(b->parameters_button, 0);
835 }
836
lqtgtk_destroy_codec_browser(LqtGtkCodecBrowser * b)837 void lqtgtk_destroy_codec_browser(LqtGtkCodecBrowser * b)
838 {
839 if(b->codecs)
840 lqt_destroy_codec_info(b->codecs);
841
842 free(b);
843 }
844
codec_config_window_button_callback(GtkWidget * w,gpointer data)845 static void codec_config_window_button_callback(GtkWidget * w, gpointer data)
846 {
847 int encode, decode;
848
849 LqtGtkCodecConfigWindow * ccw = (LqtGtkCodecConfigWindow *)data;
850 if(w == ccw->apply_button)
851 {
852 lqtgtk_codec_config_window_apply(ccw);
853 }
854 else if(w == ccw->close_button)
855 {
856 gtk_widget_hide(ccw->window);
857 gtk_main_quit();
858 }
859 else if(w == ccw->restore_button)
860 {
861 encode = (ccw->encode_widget) ? 1 : 0;
862 decode = (ccw->decode_widget) ? 1 : 0;
863
864 /* fprintf(stderr, "Restoring parameters %d %d\n", encode, decode); */
865
866 lqt_restore_default_parameters(ccw->codec_info, encode, decode);
867
868 if(encode)
869 {
870 /* fprintf(stderr, "Updating encoding parameters\n"); */
871 codec_config_widget_update(ccw->encode_widget);
872 }
873 if(decode)
874 {
875 /* fprintf(stderr, "Updating decoding parameters\n"); */
876 codec_config_widget_update(ccw->decode_widget);
877 }
878
879
880 }
881 }
882
883 LqtGtkCodecConfigWindow *
lqtgtk_create_codec_config_window(lqt_codec_info_t * codec_info,int encode,int decode)884 lqtgtk_create_codec_config_window(lqt_codec_info_t * codec_info,
885 int encode,
886 int decode)
887 {
888 const char * gettext_domain;
889
890 LqtGtkCodecConfigWindow * ret =
891 calloc(1, sizeof(LqtGtkCodecConfigWindow));
892
893 ret->codec_info = codec_info;
894
895 if(codec_info->gettext_domain && codec_info->gettext_directory)
896 {
897 bindtextdomain(codec_info->gettext_domain,
898 codec_info->gettext_directory);
899 gettext_domain = codec_info->gettext_domain;
900 }
901 else
902 {
903 lqt_translation_init();
904 gettext_domain = PACKAGE;
905 }
906
907
908 if(encode && codec_info->num_encoding_parameters)
909 ret->encode_widget =
910 lqtgtk_create_codec_config_widget(codec_info->encoding_parameters,
911 codec_info->num_encoding_parameters, gettext_domain);
912
913 if(decode && codec_info->num_decoding_parameters)
914 ret->decode_widget =
915 lqtgtk_create_codec_config_widget(codec_info->decoding_parameters,
916 codec_info->num_decoding_parameters, gettext_domain);
917
918 if(encode && decode)
919 {
920 ret->hbox = gtk_hbox_new(0, 5);
921 if(codec_info->num_encoding_parameters)
922 {
923 ret->encoding_frame = gtk_frame_new(_("Encoding Options"));
924
925 gtk_container_add(GTK_CONTAINER(ret->encoding_frame),
926 ret->encode_widget->widget);
927 gtk_widget_show(ret->encoding_frame);
928 gtk_box_pack_start(GTK_BOX(ret->hbox), ret->encoding_frame, TRUE, TRUE, 0);
929 }
930 if(codec_info->num_decoding_parameters)
931 {
932 ret->decoding_frame = gtk_frame_new(_("Decoding Options"));
933 gtk_container_add(GTK_CONTAINER(ret->decoding_frame),
934 ret->decode_widget->widget);
935 gtk_widget_show(ret->decoding_frame);
936 gtk_box_pack_start(GTK_BOX(ret->hbox), ret->decoding_frame, TRUE, TRUE, 0);
937 }
938 gtk_widget_show(ret->hbox);
939 }
940
941 ret->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
942
943 gtk_window_set_title(GTK_WINDOW(ret->window), codec_info->long_name);
944 gtk_window_set_modal(GTK_WINDOW(ret->window), TRUE);
945
946 ret->apply_button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
947 ret->close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
948 ret->restore_button = gtk_button_new_with_label(_("Restore defaults"));
949
950 g_signal_connect(G_OBJECT(ret->apply_button),
951 "clicked",
952 G_CALLBACK(codec_config_window_button_callback),
953 (gpointer)ret);
954
955 g_signal_connect(G_OBJECT(ret->close_button),
956 "clicked",
957 G_CALLBACK(codec_config_window_button_callback),
958 (gpointer)ret);
959
960 g_signal_connect(G_OBJECT(ret->restore_button),
961 "clicked",
962 G_CALLBACK(codec_config_window_button_callback),
963 (gpointer)ret);
964
965 lqtgtk_widget_set_can_default(ret->apply_button, TRUE);
966 lqtgtk_widget_set_can_default(ret->close_button, TRUE);
967 lqtgtk_widget_set_can_default(ret->restore_button, TRUE);
968
969 gtk_widget_show(ret->apply_button);
970 gtk_widget_show(ret->close_button);
971 gtk_widget_show(ret->restore_button);
972
973 ret->buttonbox = gtk_hbutton_box_new();
974 gtk_box_set_spacing(GTK_BOX(ret->buttonbox), 5);
975
976 ret->mainbox = gtk_vbox_new(0, 5);
977 gtk_container_set_border_width(GTK_CONTAINER(ret->mainbox), 10);
978
979 if(encode && decode)
980 gtk_box_pack_start(GTK_BOX(ret->mainbox), ret->hbox, TRUE, TRUE, 0);
981 else if(encode)
982 gtk_box_pack_start(GTK_BOX(ret->mainbox),
983 ret->encode_widget->widget, TRUE, TRUE, 0);
984 else if(decode)
985 gtk_box_pack_start(GTK_BOX(ret->mainbox),
986 ret->decode_widget->widget, TRUE, TRUE, 0);
987
988 gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->apply_button);
989 gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->close_button);
990 gtk_container_add(GTK_CONTAINER(ret->buttonbox), ret->restore_button);
991
992 gtk_widget_show(ret->buttonbox);
993 gtk_box_pack_start(GTK_BOX(ret->mainbox), ret->buttonbox, TRUE, TRUE, 0);
994 gtk_widget_show(ret->mainbox);
995
996 gtk_container_add(GTK_CONTAINER(ret->window), ret->mainbox);
997 return ret;
998 }
999
lqtgtk_codec_config_window_run(LqtGtkCodecConfigWindow * w)1000 void lqtgtk_codec_config_window_run(LqtGtkCodecConfigWindow *w)
1001 {
1002 gtk_widget_show(w->window);
1003 gtk_main();
1004 }
1005
1006 /* Apply all values into the libquicktime codec registry */
1007
lqtgtk_codec_config_window_apply(LqtGtkCodecConfigWindow * w)1008 void lqtgtk_codec_config_window_apply(LqtGtkCodecConfigWindow *w)
1009 {
1010 int i, index;
1011
1012 /*
1013 * First, all parameter widgets transfer their values to the
1014 * lqt_parameter_t structures
1015 */
1016
1017 if(w->encode_widget)
1018 {
1019 index = 0;
1020 for(i = 0; i < w->codec_info->num_encoding_parameters; i++)
1021 {
1022 if(w->codec_info->encoding_parameters[i].type == LQT_PARAMETER_SECTION)
1023 continue;
1024 parameter_widget_apply(w->encode_widget->parameter_widgets[index]);
1025 lqt_set_default_parameter(w->codec_info->type,
1026 1, w->codec_info->name,
1027 w->codec_info->encoding_parameters[i].name,
1028 &(w->encode_widget->parameter_info[i].val_default));
1029 index++;
1030 }
1031 }
1032 if(w->decode_widget)
1033 {
1034 index = 0;
1035 for(i = 0; i < w->codec_info->num_decoding_parameters; i++)
1036 {
1037 if(w->codec_info->decoding_parameters[i].type == LQT_PARAMETER_SECTION)
1038 continue;
1039 parameter_widget_apply(w->decode_widget->parameter_widgets[index]);
1040 lqt_set_default_parameter(w->codec_info->type,
1041 0, w->codec_info->name,
1042 w->codec_info->decoding_parameters[i].name,
1043 &(w->decode_widget->parameter_info[i].val_default));
1044 index++;
1045 }
1046 }
1047 }
1048
lqtgtk_destroy_codec_config_window(LqtGtkCodecConfigWindow * w)1049 void lqtgtk_destroy_codec_config_window(LqtGtkCodecConfigWindow *w)
1050 {
1051 gtk_widget_destroy(w->window);
1052 free(w);
1053 }
1054
1055 #define STRING_TO_FOURCC( str ) \
1056 ( ( (uint32_t)(unsigned char)(str[0]) << 24 ) | \
1057 ( (uint32_t)(unsigned char)(str[1]) << 16 ) | \
1058 ( (uint32_t)(unsigned char)(str[2]) << 8 ) | \
1059 ( (uint32_t)(unsigned char)(str[3]) ) )
1060
1061 LqtGtkCodecInfoWidget *
lqtgtk_create_codec_info_widget(const lqt_codec_info_t * info)1062 lqtgtk_create_codec_info_widget(const lqt_codec_info_t * info)
1063 {
1064 int i;
1065 char * tmp1;
1066 char * tmp2;
1067
1068 const char * gettext_domain;
1069 LqtGtkCodecInfoWidget * ret;
1070
1071 if(info->gettext_domain && info->gettext_directory)
1072 {
1073 bindtextdomain(info->gettext_domain,
1074 info->gettext_directory);
1075 gettext_domain = info->gettext_domain;
1076 }
1077 else
1078 {
1079 lqt_translation_init();
1080 gettext_domain = PACKAGE;
1081 }
1082 ret = calloc(1, sizeof(LqtGtkCodecInfoWidget));
1083
1084 ret->real_name = gtk_label_new(TR_DOM(info->long_name));
1085 gtk_misc_set_alignment(GTK_MISC(ret->real_name), 0.0, 0.5);
1086 ret->short_name_label = gtk_label_new(_("Internal name: "));
1087 gtk_misc_set_alignment(GTK_MISC(ret->short_name_label), 0.0, 0.5);
1088 ret->short_name = gtk_label_new(TR_DOM(info->name));
1089 gtk_misc_set_alignment(GTK_MISC(ret->short_name), 0.0, 0.5);
1090 ret->description = gtk_label_new(TR_DOM(info->description));
1091 gtk_misc_set_alignment(GTK_MISC(ret->description), 0.0, 0.5);
1092
1093 ret->module_filename = gtk_label_new(info->module_filename);
1094 gtk_misc_set_alignment(GTK_MISC(ret->module_filename), 0.0, 0.5);
1095 ret->module_filename_label = gtk_label_new(_("Module: "));
1096 gtk_misc_set_alignment(GTK_MISC(ret->module_filename_label), 0.0, 0.5);
1097
1098 gtk_widget_show(ret->real_name);
1099 gtk_widget_show(ret->short_name);
1100 gtk_widget_show(ret->short_name_label);
1101 gtk_widget_show(ret->description);
1102
1103 gtk_widget_show(ret->module_filename);
1104 gtk_widget_show(ret->module_filename_label);
1105
1106 /* Create the fourccs label */
1107
1108 if(info->num_fourccs)
1109 {
1110 tmp1 = malloc(info->num_fourccs * 30);
1111 tmp2 = malloc(30);
1112
1113 *tmp1 = '\0';
1114
1115 for(i = 0; i < info->num_fourccs - 1; i++)
1116 {
1117 sprintf(tmp2, "0x%08X (%s)\n", STRING_TO_FOURCC(info->fourccs[i]),
1118 info->fourccs[i]);
1119 strcat(tmp1, tmp2);
1120 }
1121
1122 /* Last one without newline */
1123
1124 sprintf(tmp2, "0x%08X (%s)", STRING_TO_FOURCC(info->fourccs[i]),
1125 info->fourccs[i]);
1126 strcat(tmp1, tmp2);
1127
1128 ret->fourccs_label = gtk_label_new(tmp1);
1129 gtk_widget_show(ret->fourccs_label);
1130
1131 free(tmp1);
1132 free(tmp2);
1133 }
1134
1135 /* Create wav_ids label */
1136
1137 if(info->num_wav_ids)
1138 {
1139 tmp1 = malloc(info->num_wav_ids * 30);
1140 tmp2 = malloc(30);
1141
1142 *tmp1 = '\0';
1143
1144 for(i = 0; i < info->num_wav_ids - 1; i++)
1145 {
1146 sprintf(tmp2, "0x%02x,", info->wav_ids[i]);
1147 strcat(tmp1, tmp2);
1148 }
1149
1150 /* Last one without comma */
1151
1152 sprintf(tmp2, "0x%02x", info->wav_ids[i]);
1153 strcat(tmp1, tmp2);
1154
1155 ret->wav_ids_label = gtk_label_new(tmp1);
1156 gtk_widget_show(ret->wav_ids_label);
1157
1158 free(tmp1);
1159 free(tmp2);
1160 }
1161
1162 /* Create encoding colormodels label */
1163
1164
1165 /* Pack all widgets onto their containers */
1166
1167 if(ret->fourccs_label)
1168 {
1169 ret->fourccs_frame = gtk_frame_new(_("Fourccs"));
1170
1171 gtk_container_add(GTK_CONTAINER(ret->fourccs_frame), ret->fourccs_label);
1172 gtk_widget_show(ret->fourccs_frame);
1173 }
1174
1175 if(ret->wav_ids_label)
1176 {
1177 ret->wav_ids_frame = gtk_frame_new(_("WAV Id(s)"));
1178
1179 gtk_container_add(GTK_CONTAINER(ret->wav_ids_frame), ret->wav_ids_label);
1180 gtk_widget_show(ret->wav_ids_frame);
1181 }
1182
1183 ret->label_table = gtk_table_new(6, 2, 0);
1184
1185 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1186 ret->real_name, 0, 2, 0, 1);
1187
1188 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1189 ret->short_name_label, 0, 1, 1, 2);
1190
1191 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1192 ret->short_name, 1, 2, 1, 2);
1193
1194 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1195 ret->module_filename_label, 0, 1, 2, 3);
1196
1197 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1198 ret->module_filename, 1, 2, 2, 3);
1199
1200 gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
1201 ret->description, 0, 2, 3, 4);
1202
1203 gtk_widget_show(ret->label_table);
1204
1205 ret->table = gtk_table_new(3, 2, 0);
1206
1207 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->label_table,
1208 0, 2, 0, 1);
1209
1210 if(info->type == LQT_CODEC_VIDEO)
1211 {
1212 if(ret->fourccs_frame)
1213 {
1214 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
1215 0, 2, 1, 2);
1216 }
1217 }
1218 else if(ret->wav_ids_frame)
1219 {
1220 if(ret->fourccs_frame)
1221 {
1222 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
1223 0, 1, 1, 2);
1224 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->wav_ids_frame,
1225 1, 2, 1, 2);
1226 }
1227 else
1228 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->wav_ids_frame,
1229 0, 2, 1, 2);
1230 }
1231
1232 else if(ret->fourccs_frame)
1233 gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
1234 0, 2, 1, 2);
1235 gtk_widget_show(ret->table);
1236 ret->widget = ret->table;
1237 return ret;
1238 }
1239
lqtgtk_destroy_codec_info_widget(LqtGtkCodecInfoWidget * w)1240 void lqtgtk_destroy_codec_info_widget(LqtGtkCodecInfoWidget * w)
1241 {
1242 free(w);
1243 }
1244
codec_info_window_button_callback(GtkWidget * w,gpointer data)1245 static void codec_info_window_button_callback(GtkWidget * w, gpointer data)
1246 {
1247 LqtGtkCodecInfoWindow * ciw = (LqtGtkCodecInfoWindow *)data;
1248 gtk_widget_hide(ciw->window);
1249 lqtgtk_destroy_codec_info_window(ciw);
1250 }
1251
1252 LqtGtkCodecInfoWindow *
lqtgtk_create_codec_info_window(const lqt_codec_info_t * info)1253 lqtgtk_create_codec_info_window(const lqt_codec_info_t *info)
1254 {
1255 LqtGtkCodecInfoWindow * ret = calloc(1, sizeof(LqtGtkCodecInfoWindow));
1256 ret->info_widget = lqtgtk_create_codec_info_widget(info);
1257 ret->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1258 gtk_window_set_title(GTK_WINDOW(ret->window), info->long_name);
1259 gtk_window_set_modal(GTK_WINDOW(ret->window), TRUE);
1260
1261 ret->mainbox = gtk_vbox_new(0, 10);
1262
1263 ret->close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
1264 lqtgtk_widget_set_can_default(ret->close_button, TRUE);
1265
1266 g_signal_connect(G_OBJECT(ret->close_button), "clicked",
1267 G_CALLBACK(codec_info_window_button_callback),
1268 (gpointer)ret);
1269
1270 gtk_widget_show(ret->close_button);
1271
1272 gtk_box_pack_start(GTK_BOX(ret->mainbox), ret->info_widget->widget, TRUE, TRUE, 0);
1273 gtk_box_pack_start(GTK_BOX(ret->mainbox), ret->close_button, TRUE, TRUE, 0);
1274
1275 gtk_widget_show(ret->mainbox);
1276
1277 gtk_container_add(GTK_CONTAINER(ret->window), ret->mainbox);
1278
1279 return ret;
1280 }
1281
1282 void
lqtgtk_destroy_codec_info_window(LqtGtkCodecInfoWindow * w)1283 lqtgtk_destroy_codec_info_window(LqtGtkCodecInfoWindow * w)
1284 {
1285 lqtgtk_destroy_codec_info_widget(w->info_widget);
1286 gtk_widget_destroy(w->window);
1287 free(w);
1288 }
1289
1290 void
lqtgtk_codec_info_window_run(LqtGtkCodecInfoWindow * w)1291 lqtgtk_codec_info_window_run(LqtGtkCodecInfoWindow * w)
1292 {
1293 gtk_widget_show(w->window);
1294 }
1295
1296 #if 0
1297
1298
1299 /*
1300 * LqtGtkEncoderWidget
1301 */
1302
1303 static void
1304 encoder_widget_button_callback(GtkWidget * w, gpointer data)
1305 {
1306 LqtGtkEncoderWidget * ew = (LqtGtkEncoderWidget*)data;
1307 LqtGtkCodecInfoWindow * iw;
1308 LqtGtkCodecConfigWindow * cw;
1309 if(w == ew->info_button)
1310 {
1311 iw = lqtgtk_create_codec_info_window(ew->encoders[ew->selected]);
1312 lqtgtk_codec_info_window_run(iw);
1313 }
1314 else if(w == ew->parameters_button)
1315 {
1316 cw = lqtgtk_create_codec_config_window(ew->encoders[ew->selected], 1, 0);
1317 lqtgtk_codec_config_window_run(cw);
1318 }
1319 }
1320
1321 LqtGtkEncoderWidget *
1322 lqtgtk_create_encoder_widget(lqt_codec_type type)
1323 {
1324 LqtGtkEncoderWidget * ret = calloc(1, sizeof(LqtGtkEncoderWidget));
1325 ret->type = type;
1326 ret->info_button = gtk_button_new_with_label(_("Info..."));
1327 ret->parameters_button = gtk_button_new_with_label(_("Parameters..."));
1328
1329 g_signal_connect(G_OBJECT(ret->info_button), "clicked",
1330 G_CALLBACK(encoder_widget_button_callback),
1331 (gpointer)ret);
1332 g_signal_connect(G_OBJECT(ret->parameters_button), "clicked",
1333 G_CALLBACK(encoder_widget_button_callback),
1334 (gpointer)ret);
1335
1336 gtk_widget_show(ret->info_button);
1337 gtk_widget_show(ret->parameters_button);
1338
1339 ret->optionmenu = gtk_option_menu_new();
1340
1341 ret->menu = gtk_menu_new();
1342 gtk_widget_show(ret->menu);
1343
1344 gtk_option_menu_set_menu(GTK_OPTION_MENU(ret->optionmenu), ret->menu);
1345 gtk_widget_show(ret->optionmenu);
1346
1347 /* NEED CHECK AGAIN */
1348 /* gtk_widget_set_usize(ret->optionmenu, 200, ret->optionmenu->requisition.height); */
1349 gtk_widget_set_size_request(ret->optionmenu, 200, -1);
1350
1351 return ret;
1352 }
1353
1354 void lqtgtk_destroy_encoder_widget(LqtGtkEncoderWidget * ew)
1355 {
1356 if(ew->encoders)
1357 lqt_destroy_codec_info(ew->encoders);
1358 }
1359
1360 static void encoder_widget_update_selected(LqtGtkEncoderWidget * ew)
1361 {
1362 gtk_option_menu_set_history(GTK_OPTION_MENU(ew->optionmenu), ew->selected);
1363 ew->current_encoder = ew->encoders[ew->selected];
1364 if(ew->current_encoder->num_encoding_parameters)
1365 gtk_widget_set_sensitive(ew->parameters_button, 1);
1366 else
1367 gtk_widget_set_sensitive(ew->parameters_button, 0);
1368 }
1369
1370 static void encoder_widget_menu_callback(GtkWidget * w, gpointer data)
1371 {
1372 int i;
1373
1374 LqtGtkEncoderWidget * ew = (LqtGtkEncoderWidget*)data;
1375
1376 for(i = 0; i < ew->num_encoders; i++)
1377 {
1378 if(w == ew->menu_items[i])
1379 {
1380 ew->selected = i;
1381 encoder_widget_update_selected(ew);
1382 }
1383 }
1384
1385 }
1386
1387 void lqtgtk_encoder_widget_update(LqtGtkEncoderWidget * ew)
1388 {
1389 GtkWidget ** new_items;
1390 int i;
1391 char * label_text;
1392
1393 if(ew->encoders)
1394 lqt_destroy_codec_info(ew->encoders);
1395
1396 if(ew->type == LQT_CODEC_AUDIO)
1397 ew->encoders = lqt_query_registry(1, 0, 1, 0);
1398 else
1399 ew->encoders = lqt_query_registry(0, 1, 1, 0);
1400
1401 /* Count the codecs */
1402 ew->num_encoders = 0;
1403
1404 while(1)
1405 {
1406 if(!(ew->encoders[ew->num_encoders]))
1407 break;
1408 else
1409 ew->num_encoders++;
1410 }
1411
1412 /* Create new menu items */
1413
1414 if(ew->num_menu_items < ew->num_encoders)
1415 {
1416 new_items = calloc(1, ew->num_encoders * sizeof(GtkWidget*));
1417
1418 /* Copy old items */
1419
1420 if(ew->menu_items)
1421 {
1422 for(i = 0; i < ew->num_menu_items; i++)
1423 new_items[i] = ew->menu_items[i];
1424 free(ew->menu_items);
1425 }
1426 ew->menu_items = new_items;
1427
1428 /* Create new items */
1429
1430 for(i = ew->num_menu_items; i < ew->num_encoders; i++)
1431 {
1432 ew->menu_items[i] = gtk_menu_item_new_with_label(" ");
1433 g_signal_connect(G_OBJECT(ew->menu_items[i]),
1434 "activate",
1435 G_CALLBACK(encoder_widget_menu_callback),
1436 (gpointer)ew);
1437 gtk_menu_shell_append(GTK_MENU_SHELL(ew->menu), ew->menu_items[i]);
1438 }
1439
1440 ew->num_menu_items = ew->num_encoders;
1441 }
1442
1443 /* Update menu labels and show all active items */
1444
1445 for(i = 0; i < ew->num_encoders; i++)
1446 {
1447 label_text = g_strdup_printf("%s (%s)",
1448 ew->encoders[i]->long_name,
1449 ew->encoders[i]->name);
1450 if(GTK_BIN(ew->menu_items[i])->child)
1451 {
1452 gtk_label_set_text(GTK_LABEL(GTK_BIN(ew->menu_items[i])->child),
1453 label_text);
1454 }
1455 else
1456 {
1457 gtk_button_set_label(GTK_BUTTON(ew->optionmenu), label_text);
1458 }
1459 g_free(label_text);
1460 gtk_widget_show(ew->menu_items[i]);
1461 }
1462
1463 /* Hide other items */
1464
1465 for(i = ew->num_encoders; i < ew->num_menu_items; i++)
1466 gtk_widget_hide(ew->menu_items[i]);
1467
1468 if(ew->selected >= ew->num_encoders)
1469 ew->selected = 0;
1470 encoder_widget_update_selected(ew);
1471 }
1472
1473 const char * lqtgtk_encoder_widget_get_encoder(LqtGtkEncoderWidget * ew)
1474 {
1475 return ew->current_encoder->name;
1476 }
1477
1478 void lqtgtk_encoder_widget_set_encoder(LqtGtkEncoderWidget * ew,
1479 const char * name)
1480 {
1481 int i;
1482 ew->selected = 0;
1483
1484 for(i = 0; i < ew->num_encoders; i++)
1485 {
1486 if(!strcmp(ew->encoders[i]->name, name))
1487 {
1488 ew->selected = i;
1489 break;
1490 }
1491 }
1492 encoder_widget_update_selected(ew);
1493 }
1494
1495 #endif
1496