1 /*
2 * Copyright (C) 2004-2005 Vadim Berezniker
3 * http://www.kryptolus.com
4 *
5 * This Program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2, or (at your option)
8 * any later version.
9 *
10 * This Program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with GNU Make; see the file COPYING. If not, write to
17 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 */
21 #include "stdafx.h"
22
23 #include "common.h"
24
25 #include "sabbu.h"
26
27 #include "kryArray.h"
28 #include "kryString.h"
29 #include "krySSACommandParser.h"
30 #include "krySSACommandHighlighter.h"
31
32 #include "sound.h"
33 #include "gui_properties.h"
34 #include "gui_options.h"
35 #include "gui_workspace.h"
36 #include "gui_waveforms.h"
37 #include "gui_event_list.h"
38 #include "gui_menu.h"
39 #include "gui_main_help.h"
40 #include "gui_main_script.h"
41 #include "gui_main_video.h"
42 #include "gui_main_event.h"
43 #include "gui_main_karaoke.h"
44 #include "gui_main_navigation.h"
45 #include "gui_main_tool.h"
46 #include "gui_main_tab_video.h"
47 #include "gui_text_editor.h"
48 #include "gui_main_fontsel.h"
49 #include "gui_status_bar.h"
50 #include "gui_time_entry.h"
51 #include "spell.h"
52 #include "resource.h"
53 #include "stringutils.h"
54
55 extern struct sabbu app;
56 extern krySabbu *appObj;
57
gui_main_set_ui_mode(enum ui_mode ui_mode)58 void gui_main_set_ui_mode(enum ui_mode ui_mode)
59 {
60 if(app.ui.ui_mode == ui_mode)
61 return;
62
63
64 app.ui.ui_mode = ui_mode;
65 gui_event_list_update_visible_columns(app.ui.event_list, ui_mode);
66
67 if(app.ui.ui_mode == UI_MODE_SSA)
68 {
69
70 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_font_underline));
71 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_font_strikethrough));
72 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.frame_style_font));
73
74 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_outline));
75 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_outline));
76
77 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_tertiary));
78 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_tertiary));
79
80 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_shadow));
81 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_shadow));
82
83 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_back));
84 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_back));
85
86 kryColor *back = app.ui.style_color_table->Get(TAB_VIDEO_COLOR_BACK);
87 kryColor *outline = app.ui.style_color_table->Get(TAB_VIDEO_COLOR_OUTLINE);
88
89 back->SetColor(outline->GetRed(), outline->GetGreen(), outline->GetBlue());
90 back->SetAlpha(outline->GetAlpha());
91
92 gtk_widget_show(GTK_WIDGET(app.ui.label_style));
93 gtk_widget_show(GTK_WIDGET(app.ui.combo_style));
94
95 gtk_widget_show(GTK_WIDGET(app.ui.label_name));
96 gtk_widget_show(GTK_WIDGET(app.ui.combo_name));
97
98 gtk_widget_hide(GTK_WIDGET(app.ui.label_layer));
99 gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer));
100
101 gtk_widget_show(GTK_WIDGET(app.ui.karaoke_hbox_switch));
102 gtk_widget_show(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor));
103
104 if(gtk_notebook_get_current_page(app.ui.notebook) == NOTEBOOK_PAGE_VIDEO)
105 gtk_widget_show(GTK_WIDGET(app.ui.tab_video.vbox_notebook));
106
107 gtk_widget_show(GTK_WIDGET(app.ui.tab_video.button_hide));
108
109 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), TRUE);
110
111 //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), TRUE);
112
113 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), TRUE);
114 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), TRUE);
115
116 kry_marker_set_multiple(app.ui.marker_event_start, 10);
117 kry_marker_set_multiple(app.ui.marker_event_end, 10);
118 }
119 else if(app.ui.ui_mode == UI_MODE_ASS)
120 {
121 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_font_underline));
122 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_font_strikethrough));
123 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.frame_style_font));
124
125 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_outline));
126 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_outline));
127
128 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_tertiary));
129 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_tertiary));
130
131 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_shadow));
132 gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_shadow));
133
134 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_back));
135 gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_back));
136
137
138 gtk_widget_show(GTK_WIDGET(app.ui.label_style));
139 gtk_widget_show(GTK_WIDGET(app.ui.combo_style));
140
141 gtk_widget_show(GTK_WIDGET(app.ui.label_name));
142 gtk_widget_show(GTK_WIDGET(app.ui.combo_name));
143
144 gtk_widget_show(GTK_WIDGET(app.ui.label_layer));
145 gtk_widget_show(GTK_WIDGET(app.ui.spin_layer));
146
147 gtk_widget_show(GTK_WIDGET(app.ui.karaoke_hbox_switch));
148 gtk_widget_show(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor));
149
150 if(gtk_notebook_get_current_page(app.ui.notebook) == NOTEBOOK_PAGE_VIDEO)
151 gtk_widget_show(GTK_WIDGET(app.ui.tab_video.vbox_notebook));
152
153 gtk_widget_show(GTK_WIDGET(app.ui.tab_video.button_hide));
154
155 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), TRUE);
156
157 //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), TRUE);
158
159 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), TRUE);
160 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), TRUE);
161
162 kry_marker_set_multiple(app.ui.marker_event_start, 10);
163 kry_marker_set_multiple(app.ui.marker_event_end, 10);
164 }
165 else if(ui_mode == UI_MODE_SRT)
166 {
167 gtk_widget_hide(GTK_WIDGET(app.ui.label_style));
168 gtk_widget_hide(GTK_WIDGET(app.ui.combo_style));
169
170 gtk_widget_hide(GTK_WIDGET(app.ui.label_name));
171 gtk_widget_hide(GTK_WIDGET(app.ui.combo_name));
172
173 gtk_widget_hide(GTK_WIDGET(app.ui.label_layer));
174 gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer));
175
176 gui_text_editor_set_syntax_highlight_mode(app.ui.text_editor, SYNTAX_HIGHLIGHT_NONE);
177 gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_hbox_switch));
178 gtk_widget_hide(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor));
179
180 //gtk_widget_hide(GTK_WIDGET(app.ui.vbox_sw
181
182 gtk_widget_hide(GTK_WIDGET(app.ui.tab_video.vbox_notebook));
183
184 gtk_widget_hide(GTK_WIDGET(app.ui.tab_video.button_hide));
185
186 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), FALSE);
187
188 //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), FALSE);
189
190 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), FALSE);
191 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), FALSE);
192
193 kry_marker_set_multiple(app.ui.marker_event_start, 1);
194 kry_marker_set_multiple(app.ui.marker_event_end, 1);
195 }
196 else if(ui_mode == UI_MODE_KARAOKE)
197 {
198 gtk_widget_hide(GTK_WIDGET(app.ui.label_style));
199 gtk_widget_hide(GTK_WIDGET(app.ui.combo_style));
200
201 gtk_widget_hide(GTK_WIDGET(app.ui.label_name));
202 gtk_widget_hide(GTK_WIDGET(app.ui.combo_name));
203
204 gtk_widget_hide(GTK_WIDGET(app.ui.label_layer));
205 gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer));
206
207 gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_hbox_switch));
208 gtk_widget_hide(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor));
209
210 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), FALSE);
211 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), FALSE);
212 }
213
214
215 gui_main_notebook_page_changed(app.ui.notebook, NULL, (notebook_page) gtk_notebook_get_current_page(app.ui.notebook), NULL);
216 }
217
gui_spin_button_get_value(GtkSpinButton * button)218 double gui_spin_button_get_value(GtkSpinButton *button)
219 {
220 double val = gtk_spin_button_get_value(button);
221
222 if(val > -0.0000001 && val < 0.0000001)
223 return 0;
224
225 return (val + (val > 0 ? 0.0000001 : -0.0000001));
226 }
227
gui_main_sync_point_set(GtkWidget * widget,int action,gpointer data)228 void gui_main_sync_point_set(GtkWidget *widget, int action, gpointer data)
229 {
230 KryMarker *marker = app.ui.marker_event_start;
231 if(kry_marker_get_value(marker) == -1)
232 {
233 gui_warning(_("Please set the start time before trying to place a sync point"));
234 return;
235 }
236
237 char *time = time_mili_to_string(kry_marker_get_value(marker));
238 app.script->SetProperty("Sync Point Time", time);
239 app.script->SetModifiedFlag(TRUE);
240 }
241
gui_main_sync_event_to_wave(GtkWidget * widget,int action,gpointer data)242 void gui_main_sync_event_to_wave(GtkWidget *widget, int action, gpointer data)
243 {
244 KryMarker *marker = app.ui.marker_event_start;
245 if(kry_marker_get_value(marker) == -1)
246 {
247 gui_warning(_("Please select the time to which the selected event will be synced to"));
248 return;
249 }
250
251 GtkTreeModel *model;
252 GtkTreeSelection *selection = gui_event_list_get_selection(app.ui.event_list);
253 GList *children = gtk_tree_selection_get_selected_rows(selection, &model);
254 if(!children)
255 {
256 gui_warning(_("Please select the event you wish to sync"));
257 return;
258 }
259
260 kryEvent *event;
261 GtkTreeIter iter;
262 GtkTreePath *path = (GtkTreePath *) children->data;
263 gtk_tree_model_get_iter(model, &iter, path);
264 gtk_tree_model_get(model, &iter,
265 PTR_COLUMN, &event, -1);
266
267 g_list_foreach(children, (GFunc) gtk_tree_path_free, NULL);
268 g_list_free(children);
269
270 if(event->GetType() != kryEvent::EVENT_DIALOG)
271 {
272 gui_warning(_("The event being synced must be a Dialog line"));
273 return;
274 }
275
276 long time_wave = kry_marker_get_value(marker);
277 long time_event = event->GetStart();
278 long time_diff;
279 gboolean backward;
280
281 if(time_wave > time_event)
282 {
283 time_diff = time_wave - time_event;
284 backward = FALSE;
285 }
286 else
287 {
288 time_diff = time_event - time_wave;
289 backward = TRUE;
290 }
291
292 gui_shift_times_show_custom(time_diff, backward ? SHIFT_BACKWARD : SHIFT_FORWARD, SHIFT_ALL);
293 }
294
gui_main_sync_point_sync(GtkWidget * widget,int action,gpointer data)295 void gui_main_sync_point_sync(GtkWidget *widget, int action, gpointer data)
296 {
297 gboolean backward = FALSE;
298 KryMarker *marker = app.ui.marker_event_start;
299 long time_cur = kry_marker_get_value(marker);
300 if(kry_marker_get_value(marker) == -1)
301 {
302 gui_warning(_("Please set the start time where the two scripts will be synchronized"));
303 return;
304 }
305
306 kryScript *script = gui_main_script_open();
307 if(!script)
308 return;
309
310 char *val = script->GetProperty("Sync Point Time");
311 if(!val)
312 {
313 gui_warning(_("The specified script does not contain a sync point"));
314 delete script;
315 return;
316 }
317
318 long time_file = time_string_to_mili(val, -1);
319 if(time_file == -1)
320 {
321 gui_warning(_("The specified script contains an invalid sync point"));
322 delete script;
323 return;
324 }
325
326 delete script;
327
328 long time_diff;
329 if(time_file > time_cur)
330 {
331 time_diff = time_file - time_cur;
332 backward = FALSE;
333 }
334 else
335 {
336 time_diff = time_cur - time_file;
337 backward = TRUE;
338 }
339
340 gui_shift_times_show_custom(time_diff, backward ? SHIFT_BACKWARD : SHIFT_FORWARD, SHIFT_ALL);
341 }
342
gui_main_focus_on_wave()343 void gui_main_focus_on_wave()
344 {
345 GList *list = kry_waveform_group_waveform_get_list(app.ui.waveform_group);
346 if(!list)
347 return;
348
349 KryWaveformGroupItem *item = KRY_WAVEFORM_GROUP_ITEM(list->data);
350
351 gtk_widget_grab_focus(GTK_WIDGET(kry_waveform_group_item_get_waveform(item)));
352 }
353
gui_main_set_time_modified(gboolean val)354 void gui_main_set_time_modified(gboolean val)
355 {
356 app.ui.time_modified = val;
357
358 if(val)
359 {
360 GdkColor red;
361 red.red = 257*255;
362 red.green = 257*64;
363 red.blue = 257*64;
364 red.pixel = 0;
365 gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, &red);
366 gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_end), GTK_STATE_NORMAL, &red);
367 }
368 else
369 {
370 gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, NULL);
371 gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_end), GTK_STATE_NORMAL, NULL);
372 }
373 }
374
gui_main_play_button_map(GtkWidget * widget,GtkWidget * target)375 void gui_main_play_button_map(GtkWidget *widget, GtkWidget *target)
376 {
377 if(app.ui.color_bg.red || app.ui.color_bg.green || app.ui.color_bg.blue || app.ui.color_bg.pixel)
378 return;
379
380 GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable(NULL, target->window, NULL, 0, 0, 0, 0, 5, 5);
381 if(!pixbuf)
382 return;
383
384 guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
385
386 guchar red = pixels[0];
387 guchar green = pixels[1];
388 guchar blue = pixels[2];
389
390 app.ui.color_bg.red = red * 257;
391 app.ui.color_bg.green = green * 257;
392 app.ui.color_bg.blue = blue * 257;
393 app.ui.color_bg.pixel = 0;
394 g_object_unref(pixbuf);
395 }
396
397
gui_main_select_font(struct fontsel_info * fontsel_info)398 int gui_main_select_font(struct fontsel_info * fontsel_info)
399 {
400 int rv;
401 gui_main_disable();
402
403 KryFontSelectionDialog *dialog = KRY_FONT_SELECTION_DIALOG(kry_font_selection_dialog_new(__("FontSelectionDialogTitle|Style Font"), fontsel_info));
404
405 gtk_window_set_transient_for(GTK_WINDOW(dialog), app.ui.window);
406 gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
407
408 rv = gtk_dialog_run(GTK_DIALOG(dialog));
409 gtk_widget_destroy(GTK_WIDGET(dialog));
410
411 gui_main_enable();
412
413 if(rv == GTK_RESPONSE_OK)
414 return TRUE;
415 else
416 return FALSE;
417 }
418
gui_main_check_theme()419 void gui_main_check_theme()
420 {
421 #ifdef _WINDOWS
422 int show_first_time_warning = app.prefs->GetInt("ShowFirstRunWarning", 1);
423 app.prefs->SetInt("ShowFirstRunWarning", 0);
424
425 if(show_first_time_warning)
426 {
427 while(gtk_events_pending())
428 gtk_main_iteration();
429
430 HWND wnd = HWND(GDK_WINDOW_HWND(GTK_WIDGET(app.ui.window)->window));
431
432 gunichar2 *msg = g_utf8_to_utf16(_("Thank you for using Sabbu. \n\nIf you experience any problems, especially font related, then please see the README.English.txt file in the sabbu directory.\n\nThis message will only be displayed once."), -1, NULL, NULL, NULL);
433 gunichar2 *title = g_utf8_to_utf16(_("First Run Notice"), -1, NULL, NULL, NULL);
434 MessageBoxW(wnd, msg, title, MB_OK | MB_ICONWARNING);
435 g_free(msg);
436 g_free(title);
437 }
438
439 if(gtk_major_version <= 2 && gtk_minor_version <= 6 && gtk_micro_version < 8)
440 {
441 while(gtk_events_pending())
442 gtk_main_iteration();
443
444 app.prefs->SetInt("GTKCheckPre2.6.8", 0);
445
446 HWND wnd = HWND(GDK_WINDOW_HWND(GTK_WIDGET(app.ui.window)->window));
447
448 gunichar2 *msg = g_utf8_to_utf16(_("The version of GTK you have installed is outdated and is known to contain certain bugs that affect sabbu.\n\nPlease go to http://www.sabbu.com and download and install the latest version of GTK.\n\nSabbu won't run until at least version 2.6.8 of GTK is installed."), -1, NULL, NULL, NULL);
449 gunichar2 *title = g_utf8_to_utf16(_("GTK Version Notice"), -1, NULL, NULL, NULL);
450 MessageBoxW(wnd, msg, title, MB_OK | MB_ICONWARNING);
451 g_free(msg);
452 g_free(title);
453 exit(0);
454 }
455 #endif
456 }
457
gui_main_save_window_state()458 void gui_main_save_window_state()
459 {
460 if(gdk_window_get_state(GTK_WIDGET(app.ui.window)->window) & GDK_WINDOW_STATE_MAXIMIZED)
461 {
462 app.prefs->SetInt("StartMaximized", 1);
463 return;
464 }
465
466 app.prefs->SetInt("StartMaximized", 0);
467
468 int width, height;
469 gdk_drawable_get_size(GDK_DRAWABLE(GTK_WIDGET(app.ui.window)->window), &width, &height);
470 app.prefs->SetInt("WindowMainWidth", width);
471 app.prefs->SetInt("WindowMainHeight", height);
472
473 int x, y;
474 gtk_window_get_position(app.ui.window, &x, &y);
475 app.prefs->SetInt("WindowMainX", x);
476 app.prefs->SetInt("WindowMainY", y);
477 }
478
479
gui_main_cb_configure(GtkWidget * widget,GdkEventConfigure * event,gpointer data)480 gboolean gui_main_cb_configure(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
481 {
482 gui_main_save_window_state();
483 return FALSE;
484 }
485
gui_main_error_sound()486 void gui_main_error_sound()
487 {
488 #ifdef _WINDOWS
489 MessageBeep(MB_ICONASTERISK);
490 #endif
491 }
492
gui_main_marker_changed_cb(KryMarker * marker,long old_position)493 void gui_main_marker_changed_cb(KryMarker *marker, long old_position)
494 {
495 long miliseconds;
496 long start, end;
497 char *str;
498
499 long mili_val = kry_marker_get_value(marker);
500 if(mili_val < 0)
501 mili_val = 0;
502
503 str = time_mili_to_string(mili_val, app.ui.ui_mode == UI_MODE_SRT);
504 if(marker == app.ui.marker_active_start)
505 gui_time_entry_set_text(app.ui.time_start, str);
506 else if(marker == app.ui.marker_active_end)
507 gui_time_entry_set_text(app.ui.time_end, str);
508 kry_free(str);
509
510
511 start = kry_marker_get_value(app.ui.marker_active_start);
512 end = kry_marker_get_value(app.ui.marker_active_end);
513
514 if(start != -1 && end != -1 && start <= end)
515 miliseconds = end - start;
516 else
517 miliseconds = 0;
518
519 str = time_mili_to_string(miliseconds, app.ui.ui_mode == UI_MODE_SRT);
520 gui_time_entry_set_text(app.ui.time_dur, str);
521 kry_free(str);
522
523
524 if((marker == app.ui.marker_active_start || marker == app.ui.marker_active_end) && kry_marker_get_value(marker) != old_position)
525 gui_main_set_time_modified(TRUE);
526 }
527
528
gui_main_marker_start_move(GdkEventButton * event,int amount)529 void gui_main_marker_start_move(GdkEventButton *event, int amount)
530 {
531 long newVal;
532
533 if(app.ui.video_drawing)
534 return;
535
536 if(event->state & GDK_CONTROL_MASK && (amount == 100 || amount == -100))
537 amount /= 10;
538
539 newVal = kry_marker_get_value(app.ui.marker_active_start) + amount;
540 if(newVal < 0)
541 newVal = 0;
542
543 kry_marker_set_value(app.ui.marker_active_start, newVal);
544
545 gui_main_focus_on_wave();
546 }
547
gui_main_marker_end_move(GdkEventButton * event,int amount)548 void gui_main_marker_end_move(GdkEventButton *event, int amount)
549 {
550 long newVal;
551 if(app.ui.video_drawing)
552 return;
553
554 if(event->state & GDK_CONTROL_MASK && (amount == 100 || amount == -100))
555 amount /= 10;
556
557 newVal = kry_marker_get_value(app.ui.marker_active_end) + amount;
558 if(newVal < 0)
559 newVal = 0;
560
561 kry_marker_set_value(app.ui.marker_active_end, newVal);
562
563 gui_main_focus_on_wave();
564 }
565
566 /*
567 * Updates widget sensitivity states based on the state of the application.
568 */
gui_main_update_sensitivity()569 void gui_main_update_sensitivity()
570 {
571 if(app.ui.sound_info == NULL)
572 {
573 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.close), FALSE);
574 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.save_selection_as_wav), FALSE);
575 }
576 else
577 {
578 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.close), TRUE);
579 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.save_selection_as_wav), TRUE);
580 }
581
582 if(app.ui.tab_video.video == NULL)
583 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.video.close), FALSE);
584 else
585 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.video.close), TRUE);
586 }
587
588
gui_warning_internal(GtkWindow * parent,char * format,va_list list,GtkMessageType type,int buttons)589 int gui_warning_internal(GtkWindow *parent, char *format, va_list list, GtkMessageType type, int buttons)
590 {
591 int rv;
592 GtkDialog *dialog;
593 char *str;
594 gboolean disabled = !gui_main_is_enabled();
595
596 if(app.ui.window)
597 gui_main_disable();
598
599 if(parent && parent != app.ui.window)
600 gtk_widget_set_sensitive(GTK_WIDGET(parent), FALSE);
601
602 str = kry_strdup_vprintf(format, list);
603
604 dialog = GTK_DIALOG(gtk_message_dialog_new(parent,
605 GTK_DIALOG_DESTROY_WITH_PARENT,
606 type,
607 (GtkButtonsType) buttons,
608 str));
609 rv = gtk_dialog_run(dialog);
610 gtk_widget_destroy(GTK_WIDGET(dialog));
611
612 kry_free(str);
613
614 if(parent)
615 {
616 gtk_window_present(parent);
617 if(parent == app.ui.window)
618 gui_main_focus_on_wave();
619 }
620
621 if(app.ui.window && !disabled)
622 gui_main_enable();
623
624 if(parent && parent != app.ui.window)
625 gtk_widget_set_sensitive(GTK_WIDGET(parent), TRUE);
626
627 return rv;
628 }
629
gui_warning_yes_no(char * format,...)630 gboolean gui_warning_yes_no(char *format, ...)
631 {
632 gboolean rv;
633 va_list list;
634
635 va_start(list, format);
636 if(gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES)
637 rv = TRUE;
638 else
639 rv = FALSE;
640 va_end(list);
641
642 return rv;
643 }
644
gui_question_yes_no(GtkWindow * parent,char * format,...)645 gboolean gui_question_yes_no(GtkWindow *parent, char *format, ...)
646 {
647 gboolean rv;
648 va_list list;
649
650 va_start(list, format);
651 if(gui_warning_internal(parent, format, list, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES)
652 rv = TRUE;
653 else
654 rv = FALSE;
655 va_end(list);
656
657 return rv;
658 }
659
gui_question_yes_no(char * format,...)660 gboolean gui_question_yes_no(char *format, ...)
661 {
662 gboolean rv;
663 va_list list;
664
665 va_start(list, format);
666 if(gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES)
667 rv = TRUE;
668 else
669 rv = FALSE;
670 va_end(list);
671
672 return rv;
673 }
674
gui_warning(char * format,...)675 void gui_warning(char *format, ...)
676 {
677 va_list list;
678
679 va_start(list, format);
680 gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK);
681 va_end(list);
682 }
683
gui_error(char * format,...)684 void gui_error(char *format, ...)
685 {
686 va_list list;
687
688 va_start(list, format);
689 gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);
690 va_end(list);
691 }
692
gui_error(GtkWindow * parent,char * format,...)693 void gui_error(GtkWindow *parent, char *format, ...)
694 {
695 va_list list;
696
697 va_start(list, format);
698 gui_warning_internal(parent, format, list, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK);
699 va_end(list);
700 }
701
gui_main_cb_delete(GtkWidget * widget,GdkEvent * event,gpointer data)702 gboolean gui_main_cb_delete(GtkWidget *widget, GdkEvent *event, gpointer data)
703 {
704 gui_main_save_window_state();
705
706 kry_recent_list_save(app.ui.list_recent_scripts, "Recent File");
707 kry_recent_list_save(app.ui.list_recent_workspaces, "Recent Workspace");
708 kry_recent_list_save(app.ui.list_recent_audio, "Recent Audio");
709 kry_recent_list_save(app.ui.list_recent_videos, "Recent Video");
710
711 if(app.ui.pane_video_pos)
712 app.prefs->SetInt("PanePositionVideoB", app.ui.pane_video_pos);
713
714 app.prefs->SetInt("SearchMatchCase", app.gui_find_replace_options.match_case);
715 app.prefs->SetInt("SearchMatchWholeWord", app.gui_find_replace_options.match_wholeword);
716 app.prefs->SetInt("SearchMatchSearchUp", app.gui_find_replace_options.search_up);
717 app.prefs->SetInt("SearchMatchSearchText", app.gui_find_replace_options.search_text);
718 app.prefs->SetInt("SearchMatchSearchStyle", app.gui_find_replace_options.search_style);
719 app.prefs->SetInt("SearchMatchSearchName", app.gui_find_replace_options.search_name);
720 kry_recent_list_save(app.gui_find_replace_options.target_history, "SearchHistory");
721
722 if(!app.prefs->Save())
723 {
724 if(!gui_warning_yes_no(_("Error saving preferences.\n\nWould you like to quit anyway?")))
725 return TRUE;
726 }
727
728
729 if(app.script && app.script->GetModifiedFlag())
730 if(!gui_main_script_save(FALSE, TRUE, FALSE))
731 return TRUE;
732
733 if(app.workspace && !gui_workspace_save(app.workspace))
734 if(!gui_warning_yes_no(_("Error saving current workspace.\n\nWould you like to quit anyway?")))
735 return TRUE;
736
737
738 if(app.script)
739 {
740 app.script->SetModifiedFlag(FALSE);
741 if(!appObj->ScriptClose())
742 return TRUE;
743 }
744
745 gui_status_bar_text_only_mode(app.ui.status_bar);
746 gui_waveforms_destroy();
747
748 if(app.workspace)
749 kry_free(app.workspace);
750
751 #ifdef HAVE_ASPELL
752 if(app.ui.speller)
753 spell_destroy(app.ui.speller);
754 #endif
755
756 gtk_main_quit();
757
758 // yeah.. save again...
759 app.prefs->Save();
760
761 sabbu_exit();
762
763 return FALSE;
764 }
765
gui_main_title_update()766 void gui_main_title_update()
767 {
768 char *title;
769 char *filename;
770 char *workspace;
771 char *flags;
772 char *encoding = "";
773 char *format = "";
774
775 if(app.script->GetFilename() == NULL)
776 filename = kry_strdup(_("Untitled"));
777 else
778 filename = KRY_TS(g_path_get_basename(app.script->GetFilename()));
779
780 if(!app.workspace)
781 {
782 workspace = kry_strdup("");
783 }
784 else
785 {
786 char *base = KRY_TS(g_path_get_basename(app.workspace));
787 workspace = kry_strdup_printf(KRY_LOC " (%s)", base);
788 kry_free(base);
789 }
790
791 if(app.script->GetEncoding() == ENCODING_UTF8)
792 encoding = " UTF8";
793 else if(app.script->GetEncoding() == ENCODING_UTF16)
794 encoding = " UTF16";
795
796 if(app.script->GetType() == KRY_FORMAT_SSA)
797 format = "SSA";
798 else if(app.script->GetType() == KRY_FORMAT_ASS)
799 format = "ASS";
800 else if(app.script->GetType() == KRY_FORMAT_SRT)
801 format = "SRT";
802
803 flags = kry_strdup_printf(KRY_LOC "%s%s", format, encoding);
804 title = kry_strdup_printf(KRY_LOC "Sabbu (%s) - %s (%s)%s", app.version, filename, flags, workspace);
805
806 gtk_window_set_title(GTK_WINDOW(app.ui.window), title);
807
808 #ifdef _WINDOWS
809 gunichar2 *title_utf16 = g_utf8_to_utf16(title, -1, NULL, NULL, NULL);
810 HWND wnd = (HWND) GDK_WINDOW_HWND (GTK_WIDGET(app.ui.window)->window);
811 SetWindowTextW(wnd, title_utf16);
812 g_free(title_utf16);
813 #endif
814
815 kry_free(flags);
816 kry_free(title);
817 kry_free(filename);
818 kry_free(workspace);
819 }
820
gui_main_waveform_toolbar_advanced(struct waveform_info * info)821 void gui_main_waveform_toolbar_advanced(struct waveform_info *info)
822 {
823 gtk_widget_show(GTK_WIDGET(info->button_mute));
824 gtk_widget_show(GTK_WIDGET(info->frame_name));
825 gtk_widget_show(GTK_WIDGET(info->button_hide));
826 gtk_widget_show(GTK_WIDGET(info->button_set_name));
827 gtk_widget_show(GTK_WIDGET(info->button_clone));
828 gtk_widget_show(GTK_WIDGET(info->sep1));
829 //gtk_widget_show(GTK_WIDGET(info->sep2));
830 gtk_widget_show(GTK_WIDGET(info->sep3));
831 }
832
gui_main_create_control_toolbar(control_widget_type type)833 GtkWidget *gui_main_create_control_toolbar(control_widget_type type)
834 {
835 GtkButton *button_play_start = GTK_BUTTON(gtk_button_new());
836 if(type == CONTROLS_VBOX || type == CONTROLS_TABLE)
837 gtk_container_add(GTK_CONTAINER(button_play_start), gtk_image_new_from_pixbuf(app.ui.pixbufs.play));
838 else
839 gtk_container_add(GTK_CONTAINER(button_play_start), gtk_label_new(_("Play")));
840 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_start), _("Play"), NULL);
841 g_signal_connect(G_OBJECT(button_play_start), "clicked", G_CALLBACK(gui_main_menu_audio_play_start), NULL);
842
843 GtkButton *button_play_stop = GTK_BUTTON(gtk_button_new());
844 if(type == CONTROLS_VBOX || type == CONTROLS_TABLE)
845 gtk_container_add(GTK_CONTAINER(button_play_stop), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_stop));
846 else
847 gtk_container_add(GTK_CONTAINER(button_play_stop), gtk_label_new(_("Stop")));
848 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_stop), _("Stop"), NULL);
849 g_signal_connect(G_OBJECT(button_play_stop), "clicked", G_CALLBACK(gui_main_menu_audio_stop), NULL);
850
851 GtkButton *button_play_selection = GTK_BUTTON(gtk_button_new());
852 if(type == CONTROLS_VBOX || type == CONTROLS_TABLE)
853 gtk_container_add(GTK_CONTAINER(button_play_selection), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_selection));
854 else
855 gtk_container_add(GTK_CONTAINER(button_play_selection), gtk_label_new(_("Play Selection")));
856 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_selection), _("Play Selection"), NULL);
857 g_signal_connect(G_OBJECT(button_play_selection), "clicked", G_CALLBACK(gui_main_play_selected), NULL);
858
859 GtkButton *button_play_last = GTK_BUTTON(gtk_button_new());
860 if(type == CONTROLS_VBOX || type == CONTROLS_TABLE)
861 gtk_container_add(GTK_CONTAINER(button_play_last), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_last));
862 else
863 gtk_container_add(GTK_CONTAINER(button_play_last), gtk_label_new(_("Play Last 0.5 seconds")));
864 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_last), _("Play Last 0.5 seconds"), NULL);
865 g_signal_connect(G_OBJECT(button_play_last), "clicked", G_CALLBACK(gui_main_menu_audio_play_last), NULL);
866
867 GtkButton *button_grab_times = GTK_BUTTON(gtk_button_new());
868 if(type == CONTROLS_VBOX || type == CONTROLS_TABLE)
869 gtk_container_add(GTK_CONTAINER(button_grab_times), gtk_image_new_from_pixbuf(app.ui.pixbufs.grab_times));
870 else
871 gtk_container_add(GTK_CONTAINER(button_grab_times), gtk_label_new(_("Grab Times")));
872 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_grab_times), _("Grab Times"), NULL);
873 g_signal_connect(G_OBJECT(button_grab_times), "clicked", G_CALLBACK(gui_main_grab_times_cb), (gpointer) TRUE);
874
875 gtk_button_set_relief(button_play_start, GTK_RELIEF_NONE);
876 gtk_button_set_relief(button_play_stop, GTK_RELIEF_NONE);
877 gtk_button_set_relief(button_play_selection, GTK_RELIEF_NONE);
878 gtk_button_set_relief(button_play_last, GTK_RELIEF_NONE);
879 gtk_button_set_relief(button_grab_times, GTK_RELIEF_NONE);
880
881 if(type == CONTROLS_TABLE)
882 {
883 GtkTable *table = GTK_TABLE(gtk_table_new(4, 2, FALSE));
884 gtk_table_attach(table, GTK_WIDGET(button_play_start), 0, 1, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
885 gtk_table_attach(table, GTK_WIDGET(button_play_selection), 1, 2, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
886 gtk_table_attach(table, GTK_WIDGET(button_play_last), 2, 3, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
887 gtk_table_attach(table, GTK_WIDGET(button_play_stop), 3, 4, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0);
888
889 gtk_table_attach(table, GTK_WIDGET(button_grab_times), 0, 1, 1, 2, GTK_FILL, GTK_EXPAND, 0, 0);
890 return GTK_WIDGET(table);
891 }
892 else
893 {
894 GtkBox *box;
895 if(type == CONTROLS_VBOX)
896 box = GTK_BOX(gtk_vbox_new(FALSE, 0));
897 else
898 box = GTK_BOX(gtk_hbox_new(FALSE, 0));
899
900 gtk_box_pack_start(box, GTK_WIDGET(button_play_start), FALSE, TRUE, 0);
901 gtk_box_pack_start(box, GTK_WIDGET(button_play_selection), FALSE, TRUE, 0);
902 gtk_box_pack_start(box, GTK_WIDGET(button_play_last), FALSE, TRUE, 0);
903 gtk_box_pack_start(box, GTK_WIDGET(button_play_stop), FALSE, TRUE, 0);
904 gtk_box_pack_start(box, GTK_WIDGET(button_grab_times), FALSE, TRUE, 0);
905
906 return GTK_WIDGET(box);
907 }
908
909 }
910
gui_main_advanced_waveform_ui_switch(gboolean val)911 void gui_main_advanced_waveform_ui_switch(gboolean val)
912 {
913 if(val)
914 {
915 app.opts.advanced_waveform_ui = TRUE;
916 kry_waveform_group_disable_simple_interface(app.ui.waveform_group);
917 }
918 else
919 {
920 app.opts.advanced_waveform_ui = FALSE;
921 if(app.ui.sound_info)
922 kry_waveform_group_enable_simple_interface(app.ui.waveform_group);
923 }
924 }
925
gui_main_create_wave_toolbar(gboolean horizontal)926 GtkToolbar *gui_main_create_wave_toolbar(gboolean horizontal)
927 {
928 GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new());
929
930 if(horizontal)
931 {
932 gtk_toolbar_set_orientation(toolbar, GTK_ORIENTATION_HORIZONTAL);
933 gtk_toolbar_set_style(toolbar, GTK_TOOLBAR_TEXT);
934 }
935 else
936 {
937 gtk_toolbar_set_orientation(toolbar, GTK_ORIENTATION_VERTICAL);
938 gtk_toolbar_set_style(toolbar, GTK_TOOLBAR_ICONS);
939 }
940
941 app.ui.tool_play_start = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play"), __("WaveToolbarTooltip|Play"), NULL,
942 gtk_image_new_from_stock("sabbu-play", GTK_ICON_SIZE_SMALL_TOOLBAR),
943 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_start), NULL));
944 app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.tool_play_start);
945
946 g_signal_connect(app.ui.tool_play_start, "key-press-event", G_CALLBACK(gui_main_key_press), NULL);
947
948 app.ui.tool_play_stop = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Stop"), __("WaveToolbarTooltip|Stop"), NULL,
949 gtk_image_new_from_stock("sabbu-stop", GTK_ICON_SIZE_SMALL_TOOLBAR),
950 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_start), NULL));
951 app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.tool_play_stop);
952
953 gtk_widget_hide(GTK_WIDGET(app.ui.tool_play_stop));
954
955 app.ui.wave_play_selected =
956 GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play Selection"), __("WaveToolbarTooltip|Play Selection"), NULL,
957 gtk_image_new_from_stock("sabbu-play-selected", GTK_ICON_SIZE_SMALL_TOOLBAR),
958 GTK_SIGNAL_FUNC(gui_main_play_selected), NULL));
959 app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.wave_play_selected);
960
961 GtkWidget *widget = gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play Last 0.5s"), __("WaveToolbarTooltip|Play Last 0.5 seconds"), NULL,
962 gtk_image_new_from_stock("sabbu-play-last", GTK_ICON_SIZE_SMALL_TOOLBAR),
963 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_last), NULL);
964 app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, widget);
965
966 app.ui.wave_grab_times =
967 GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Grab Times"), __("WaveToolbarTooltip|Grab Times"), NULL,
968 gtk_image_new_from_stock("sabbu-check-mark", GTK_ICON_SIZE_SMALL_TOOLBAR),
969 GTK_SIGNAL_FUNC(gui_main_grab_times_cb), (gpointer) TRUE));
970 app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.wave_grab_times);
971
972 gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);
973
974 app.ui.play_toolbar = toolbar;
975
976 return toolbar;
977 }
978
gui_main_auto_time_select_cb(GtkToggleButton * button,gpointer data)979 void gui_main_auto_time_select_cb(GtkToggleButton *button, gpointer data)
980 {
981 app.opts.disable_automatic_wave_jump = gtk_toggle_button_get_active(button);
982
983 app.prefs->SetInt("DisableAutomaticWaveJump", app.opts.disable_automatic_wave_jump);
984
985 gui_main_focus_on_wave();
986 }
987
gui_main_create_list_toolbar(gboolean horizontal)988 GtkToolbar *gui_main_create_list_toolbar(gboolean horizontal)
989 {
990 GtkToolbar *list_toolbar = GTK_TOOLBAR(gtk_toolbar_new());
991
992 if(horizontal)
993 {
994 gtk_toolbar_set_orientation(list_toolbar, GTK_ORIENTATION_HORIZONTAL);
995 gtk_toolbar_set_style(list_toolbar, GTK_TOOLBAR_TEXT);
996 }
997 else
998 {
999 gtk_toolbar_set_orientation(list_toolbar, GTK_ORIENTATION_VERTICAL);
1000 gtk_toolbar_set_style(list_toolbar, GTK_TOOLBAR_ICONS);
1001 }
1002
1003 gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Previous Row"), __("EventListToolbarTooltip|Play Previous Row"), NULL,
1004 gtk_image_new_from_stock("sabbu-play-previous", GTK_ICON_SIZE_SMALL_TOOLBAR),
1005 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_previous_row), NULL);
1006
1007 gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Current Row"), __("EventListToolbarTooltip|Play Current Row"), NULL,
1008 gtk_image_new_from_stock("sabbu-play-current", GTK_ICON_SIZE_SMALL_TOOLBAR),
1009 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_current_row), NULL);
1010
1011 gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Next Row"), __("EventListToolbarTooltip|Play Next Row"), NULL,
1012 gtk_image_new_from_stock("sabbu-play-next", GTK_ICON_SIZE_SMALL_TOOLBAR),
1013 GTK_SIGNAL_FUNC(gui_main_menu_audio_play_next_row), NULL);
1014
1015 gtk_toolbar_append_space(list_toolbar);
1016
1017 GtkButton *button_auto_select = GTK_BUTTON(gtk_toggle_button_new_with_label(__("EventListToolbar|DS")));
1018 gtk_button_set_relief(button_auto_select, GTK_RELIEF_NONE);
1019 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_auto_select), FALSE);
1020 g_signal_connect(button_auto_select, "toggled", G_CALLBACK(gui_main_auto_time_select_cb), NULL);
1021 gtk_toolbar_append_widget(list_toolbar, GTK_WIDGET(button_auto_select), __("EventListToolbarTooltip|Disables Automatic Selection of Time / Automatic Wave Focus when a different event is selected"), NULL);
1022
1023 gtk_toolbar_set_icon_size(list_toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);
1024
1025 return list_toolbar;
1026 }
1027
gui_main_update_pane_position(int page)1028 void gui_main_update_pane_position(int page)
1029 {
1030 if(page != NOTEBOOK_PAGE_VIDEO && app.ui.pane_other_pos)
1031 {
1032 gtk_paned_set_position(app.ui.wave_pane, app.ui.pane_other_pos);
1033 }
1034 else
1035 {
1036 if(app.ui.pane_video_pos)
1037 gtk_paned_set_position(app.ui.wave_pane, app.ui.pane_video_pos);
1038 }
1039 }
1040
gui_main_notebook_button_press_cb(GtkNotebook * notebook,GdkEventButton * button,gpointer data)1041 gboolean gui_main_notebook_button_press_cb(GtkNotebook *notebook, GdkEventButton *button, gpointer data)
1042 {
1043 if(!GTK_WIDGET_SENSITIVE(app.ui.menu.me))
1044 return TRUE;
1045
1046 return FALSE;
1047 }
1048
1049
gui_main_notebook_page_changed(GtkNotebook * notebook,GtkNotebookPage * page_unused,enum notebook_page page,gpointer data_unused)1050 void gui_main_notebook_page_changed(GtkNotebook *notebook, GtkNotebookPage *page_unused,
1051 enum notebook_page page, gpointer data_unused)
1052 {
1053 GtkWidget *child1 = gtk_paned_get_child1(app.ui.wave_pane);
1054 GtkWidget *child2 = gtk_paned_get_child2(app.ui.wave_pane);
1055
1056 g_object_set_data(G_OBJECT(app.ui.wave_pane), "sabbu-signal-ignore", (gpointer) TRUE);
1057
1058 if(app.ui.ui_mode == UI_MODE_SSA || app.ui.ui_mode == UI_MODE_ASS)
1059 {
1060 if(page != NOTEBOOK_PAGE_VIDEO)
1061 {
1062 GtkWidget *temp = child1;
1063 child1 = child2;
1064 child2 = temp;
1065
1066 gtk_toggle_button_set_active(app.ui.tab_video.button_hide, FALSE);
1067 }
1068 else
1069 {
1070 gtk_toggle_button_set_active(app.ui.tab_video.button_hide, TRUE);
1071 }
1072 }
1073
1074 gui_main_update_pane_position(page);
1075 g_object_set_data(G_OBJECT(app.ui.wave_pane), "sabbu-signal-ignore", FALSE);
1076
1077 g_object_set(G_OBJECT(app.ui.wave_pane), "position-set", TRUE, NULL);
1078
1079 gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child1), "resize", TRUE, NULL);
1080 gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child1), "shrink", FALSE, NULL);
1081
1082 gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child2), "resize", FALSE, NULL);
1083 gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child2), "shrink", FALSE, NULL);
1084
1085 gui_main_focus_on_wave();
1086 }
1087
gui_main_entry_style_changed_cb(GtkWidget * widget,gpointer data)1088 void gui_main_entry_style_changed_cb(GtkWidget *widget, gpointer data)
1089 {
1090 if(app.ui.video_area)
1091 gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
1092
1093 char *text = KRY_TS(gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget)));
1094 if(strcmp(text, ""))
1095 gui_main_layer_style_changed_cb(widget, data);
1096 kry_free(text);
1097
1098 gui_main_focus_on_wave();
1099 }
1100
gui_main_entry_name_press_cb(GtkWidget * widget,GdkEventKey * event,GtkWidget * combo)1101 gboolean gui_main_entry_name_press_cb(GtkWidget *widget, GdkEventKey *event, GtkWidget *combo)
1102 {
1103 if(event->keyval != GDK_Return)
1104 g_object_set_data(G_OBJECT(combo), "user-key-press", (gpointer) 1);
1105
1106 return FALSE;
1107 }
1108
gui_main_entry_name_release_cb(GtkWidget * widget,GdkEventKey * event,GtkWidget * combo)1109 gboolean gui_main_entry_name_release_cb(GtkWidget *widget, GdkEventKey *event, GtkWidget *combo)
1110 {
1111 g_object_set_data(G_OBJECT(combo), "user-key-press", (gpointer) 0);
1112 return FALSE;
1113 }
1114
gui_main_entry_name_changed_cb(GtkWidget * widget,GtkComboBox * combo)1115 void gui_main_entry_name_changed_cb(GtkWidget *widget, GtkComboBox *combo)
1116 {
1117 if((long) g_object_get_data(G_OBJECT(widget), "user-key-press") == 1)
1118 return;
1119
1120 if(app.ui.video_area)
1121 gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
1122
1123 const char *text = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo))));
1124 if(text)
1125 gui_main_layer_style_changed_cb(widget, NULL);
1126
1127 gui_main_focus_on_wave();
1128 }
1129
1130
1131
gui_main_entry_style_button_release_cb(GtkPaned * paned,GParamSpec * spec,GtkNotebook * notebook)1132 gboolean gui_main_entry_style_button_release_cb(GtkPaned *paned, GParamSpec *spec, GtkNotebook *notebook)
1133 {
1134 g_warning("test");
1135 gui_main_focus_on_wave();
1136 return FALSE;
1137 }
1138
gui_main_scroll_press(GtkWidget * widget,GdkEvent * event,gpointer button)1139 gboolean gui_main_scroll_press(GtkWidget *widget, GdkEvent *event, gpointer button)
1140 {
1141 if(event->scroll.direction == 0 || event->scroll.direction == 1)
1142 {
1143 long val = 0;
1144 GtkAdjustment *adj = kry_waveform_get_adjustment(KRY_WAVEFORM(widget));
1145
1146 if(event->scroll.direction == 0)
1147 val = (int) (gtk_adjustment_get_value(adj) - adj->step_increment);
1148 else if(event->scroll.direction == 1)
1149 val = (int) (gtk_adjustment_get_value(adj) + adj->step_increment);
1150
1151 if(val > adj->upper - adj->page_size)
1152 val = (long) (adj->upper - adj->page_size);
1153
1154 gtk_adjustment_set_value(adj, val);
1155
1156 return TRUE;
1157 }
1158
1159 return FALSE;
1160 }
1161
gui_main_key_press(GtkWidget * widget,GdkEventKey * event,gpointer button)1162 gboolean gui_main_key_press(GtkWidget *widget, GdkEventKey *event, gpointer button)
1163 {
1164 if(!app.ui.sound_info)
1165 return FALSE;
1166
1167 if(event->keyval == GDK_g || event->keyval == GDK_G || event->keyval == GDK_KP_Add)
1168 {
1169 if(app.ui.karaoke_mode != KARAOKE_MODE_OFF)
1170 {
1171 gui_karaoke_grab_times_cb(NULL, NULL);
1172 }
1173 else
1174 {
1175 gui_main_grab_times(GRAB_ADVANCE);
1176 }
1177 return TRUE;
1178 }
1179 else if(event->keyval == GDK_s || event->keyval == GDK_S || event->keyval == GDK_Clear)
1180 {
1181 gui_main_play_selected(NULL, NULL);
1182 return TRUE;
1183 }
1184 else if(event->keyval == GDK_d || event->keyval == GDK_D || event->keyval == GDK_Up)
1185 {
1186 if(event->state & GDK_CONTROL_MASK)
1187 gui_main_menu_audio_play_next(NULL, 0, NULL);
1188 else
1189 gui_main_menu_audio_play_last(NULL, 0, NULL);
1190 return TRUE;
1191 }
1192 else if(event->keyval == GDK_w || event->keyval == GDK_W)
1193 {
1194 gui_main_menu_audio_play_start(NULL, 0, NULL);
1195 }
1196 else if(event->keyval == GDK_e || event->keyval == GDK_E)
1197 {
1198 gui_main_advance_markers();
1199 }
1200 else if(event->keyval == GDK_q || event->keyval == GDK_Q)
1201 {
1202 gui_main_menu_audio_stop();
1203 }
1204 else if(event->keyval == GDK_KP_Multiply)
1205 {
1206 gui_main_menu_audio_play_previous(NULL, 0, NULL);
1207 return TRUE;
1208 }
1209 else if(event->keyval == GDK_KP_Divide)
1210 {
1211 kry_waveform_group_focus_selected(app.ui.waveform_group);
1212 return TRUE;
1213 }
1214 else if(event->keyval == GDK_a || event->keyval == GDK_A
1215 || event->keyval == GDK_f || event->keyval == GDK_F
1216 || event->keyval == GDK_Page_Down || event->keyval == GDK_End)
1217 {
1218 GtkAdjustment *adj = NULL;
1219 int val;
1220 if(KRY_IS_WAVEFORM(widget))
1221 adj = kry_waveform_get_adjustment(KRY_WAVEFORM(widget));
1222 else
1223 adj = kry_waveform_group_get_adjustment(app.ui.waveform_group);
1224
1225 if(event->keyval == GDK_f || event->keyval == GDK_F || event->keyval == GDK_Page_Down)
1226 val = (int) (gtk_adjustment_get_value(adj) + adj->step_increment);
1227 else
1228 val = (int) (gtk_adjustment_get_value(adj) - adj->step_increment);
1229
1230 if(val > adj->upper - adj->page_size)
1231 val = (long) (adj->upper - adj->page_size);
1232
1233 gtk_adjustment_set_value(adj, val);
1234
1235 return TRUE;
1236 }
1237 else if(event->keyval == GDK_Left || event->keyval == GDK_Home || event->keyval == GDK_Right || event->keyval == GDK_Page_Up)
1238 {
1239 KryMarker *marker = NULL;
1240 long mili;
1241 int offset;
1242
1243 if(event->keyval == GDK_Left || event->keyval == GDK_Right)
1244 marker = app.ui.marker_active_start;
1245 else
1246 marker = app.ui.marker_active_end;
1247
1248 if(!marker)
1249 return FALSE;
1250
1251 if(event->state & GDK_CONTROL_MASK)
1252 offset = 100;
1253 else
1254 offset = 10;
1255
1256 mili = kry_marker_get_value(marker);
1257 if(mili == -1)
1258 mili = 0;
1259
1260 if(event->keyval == GDK_Left || event->keyval == GDK_Home)
1261 mili -= offset;
1262 else if(event->keyval == GDK_Right || event->keyval == GDK_Page_Up)
1263 mili += offset;
1264
1265 if(mili < 0)
1266 mili = 0;
1267
1268 kry_marker_set_value(marker, mili);
1269
1270 return TRUE;
1271 }
1272
1273 return FALSE;
1274 }
1275
1276
1277 int uniq_button_counter = 0;
1278
gui_main_button_press_timer(struct hold_button_callback_info * info)1279 gboolean gui_main_button_press_timer(struct hold_button_callback_info *info)
1280 {
1281 if(info->released)
1282 {
1283 info->running--;
1284 return FALSE;
1285 }
1286
1287 if(info->running > 1)
1288 {
1289 info->running--;
1290 return FALSE;
1291
1292 }
1293
1294
1295 if(GTK_WIDGET_IS_SENSITIVE(info->widget))
1296 info->func(&info->event, info->data);
1297 return TRUE;
1298 }
1299
1300
gui_main_hold_button_press(GtkWidget * widget,GdkEventButton * event,struct hold_button_callback_info * info)1301 gboolean gui_main_hold_button_press(GtkWidget *widget, GdkEventButton *event, struct hold_button_callback_info *info)
1302 {
1303 if(info->released == FALSE && info->running || event->button != 1)
1304 return FALSE;
1305
1306 info->func(event, info->data);
1307 info->released = FALSE;
1308 info->running++;
1309 info->widget = widget;
1310 info->event = *event;
1311 info->id = uniq_button_counter++;
1312 g_timeout_add(125, (GSourceFunc) gui_main_button_press_timer, info);
1313
1314 gui_main_focus_on_wave();
1315
1316 return FALSE;
1317 }
1318
gui_main_hold_button_release(GtkWidget * widget,struct hold_button_callback_info * info)1319 gboolean gui_main_hold_button_release(GtkWidget *widget, struct hold_button_callback_info *info)
1320 {
1321 info->released = TRUE;
1322 gui_main_focus_on_wave();
1323
1324 return FALSE;
1325 }
1326
gui_main_load_color_table(kryColorTable * table)1327 void gui_main_load_color_table(kryColorTable *table)
1328 {
1329 for(int i = 0; i < table->GetColorCount(); i++)
1330 {
1331 char *str;
1332 kryColor *color = table->Get(i);
1333 if(color->IsInitialized() && (str = app.prefs->GetString("Colors", color->GetTextID())))
1334 {
1335 int ncolor = atoi(str);
1336 color->SetColor(ncolor >> 16, (ncolor >> 8) & 0xFF, ncolor & 0xFF);
1337 }
1338 }
1339 }
1340
gui_main_layer_style_changed_cb(GtkWidget * widget,gpointer data)1341 void gui_main_layer_style_changed_cb(GtkWidget *widget, gpointer data)
1342 {
1343 if(g_object_get_data(G_OBJECT(gui_event_list_get_view(app.ui.event_list)), "layer-internal-change"))
1344 return;
1345
1346 GtkTreeModel *model;
1347 GtkTreeSelection *selection = gui_event_list_get_selection(app.ui.event_list);
1348 GList *sel_items = gtk_tree_selection_get_selected_rows(selection, &model);
1349 GtkTreeIter iter;
1350 kryEventDetailed *event;
1351
1352 for(GList *ptr = sel_items; ptr; ptr = ptr->next)
1353 {
1354 GtkTreePath *path = (GtkTreePath *) ptr->data;
1355
1356 gtk_tree_model_get_iter(model, &iter, path);
1357 gtk_tree_model_get(model, &iter,
1358 PTR_COLUMN, &event,
1359 -1);
1360
1361 if(event->GetType() != kryEvent::EVENT_BLANK && event->GetType() != kryEvent::EVENT_COMMENT_STRING && event->GetType() != kryEvent::EVENT_COMMENT_BLANK)
1362 {
1363 char *cur_style = KRY_TS(gtk_combo_box_get_active_text(app.ui.combo_style));
1364 const char *cur_name = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app.ui.combo_name))));
1365 if(event->GetLayer() != gtk_spin_button_get_value_as_int(app.ui.spin_layer) || strcmp(event->GetStyle(), cur_style) || strcmp(event->GetName(), cur_name))
1366 app.script->SetModifiedFlag(TRUE);
1367
1368 event->SetLayer(gtk_spin_button_get_value_as_int(app.ui.spin_layer));
1369 event->SetStyle(cur_style);
1370 event->SetName((char *) cur_name);
1371
1372 gui_event_list_update_line(app.ui.event_list, event, &iter);
1373
1374 gui_event_list_color_collisions(app.ui.event_list); // bad idea to call this every time
1375
1376 kry_free(cur_style);
1377 }
1378 }
1379
1380 g_list_foreach(sel_items, (GFunc) gtk_tree_path_free, NULL);
1381 g_list_free(sel_items);
1382
1383 gui_main_focus_on_wave();
1384 }
1385
gui_combo_box_set_text(GtkComboBox * combo,char * text,gboolean numeric)1386 gboolean gui_combo_box_set_text(GtkComboBox *combo, char *text, gboolean numeric)
1387 {
1388 GtkTreeIter iter;
1389 GtkTreeModel *model = gtk_combo_box_get_model(combo);
1390 char *combo_text;
1391 if(!gtk_tree_model_get_iter_first(model, &iter))
1392 {
1393 //g_warning("tried to set combo value to '%s' but failed", text);
1394 return FALSE;
1395 }
1396
1397 do
1398 {
1399 gtk_tree_model_get(model, &iter, 0, &combo_text, -1);
1400 combo_text = KRY_TS(combo_text);
1401 if(!strcmp(combo_text, text) || numeric && atof(combo_text) == atof(text))
1402 {
1403 gtk_combo_box_set_active_iter(combo, &iter);
1404 kry_free(combo_text);
1405 return TRUE;
1406 }
1407
1408 kry_free(combo_text);
1409 } while(gtk_tree_model_iter_next(model, &iter));
1410
1411 return FALSE;
1412 //g_warning("tried to set combo value to '%s' but failed", text);
1413 }
1414
gui_combo_box_add_text(GtkComboBox * combo,char * text,gboolean numeric)1415 void gui_combo_box_add_text(GtkComboBox *combo, char *text, gboolean numeric)
1416 {
1417 if(gui_combo_box_set_text(combo, text, numeric))
1418 return;
1419
1420 GtkTreeModel *model = gtk_combo_box_get_model(combo);
1421
1422 GtkTreeIter iter;
1423 gtk_list_store_append(GTK_LIST_STORE(model), &iter);
1424 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, text, -1);
1425
1426 gui_combo_box_set_text(combo, text);
1427 }
1428
gui_combo_fps_select_cb(GtkEntry * entry,GdkEventFocus * focus,GtkComboBox * combo)1429 gboolean gui_combo_fps_select_cb(GtkEntry *entry, GdkEventFocus *focus, GtkComboBox *combo)
1430 {
1431 char *text = KRY_TS(gtk_combo_box_get_active_text(combo));
1432 double val = atof(text);
1433
1434 char *new_text = kry_strdup_printf(KRY_LOC "%.12f", val);
1435
1436 int i;
1437 for(i = 0; text[i] != 0 && new_text[i] != 0 && text[i] == new_text[i]; i++);
1438
1439 if(i == 0)
1440 {
1441 gui_combo_box_add_text(combo, "0", TRUE);
1442 }
1443 else
1444 {
1445 new_text[i] = 0;
1446 gui_combo_box_add_text(combo, new_text, TRUE);
1447 }
1448
1449 kry_free(text);
1450 kry_free(new_text);
1451
1452 return FALSE;
1453 }
1454
gui_combo_box_fps_new(gboolean ntsc_pal_only)1455 GtkComboBoxEntry *gui_combo_box_fps_new(gboolean ntsc_pal_only)
1456 {
1457 GtkComboBoxEntry *combo_fps = GTK_COMBO_BOX_ENTRY(gtk_combo_box_entry_new_text());
1458
1459 if(!ntsc_pal_only)
1460 {
1461 gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "23.976");
1462 }
1463
1464 gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "25 (PAL)");
1465 gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "29.97 (NTSC)");
1466
1467 if(!ntsc_pal_only)
1468 {
1469 gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "119.880");
1470 }
1471
1472 gtk_widget_set_size_request(GTK_WIDGET(combo_fps), 120, -1);
1473
1474 GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo_fps)));
1475 gtk_entry_set_max_length(entry, 12);
1476
1477 g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(gui_combo_fps_select_cb), combo_fps);
1478 g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(gui_combo_fps_select_cb), combo_fps);
1479
1480 return combo_fps;
1481 }
1482
gui_main_script_modified(gboolean modified)1483 void gui_main_script_modified(gboolean modified)
1484 {
1485 if(modified)
1486 {
1487 gui_status_bar_set_text_with_color(app.ui.status_bar,
1488 STATUS_MODIFIED,
1489 _("There are UNSAVED Changes"), app.ui.status_bar_color_table->Get(STATUS_COLOR_UNSAVED));
1490 }
1491 else
1492 {
1493 gui_status_bar_set_text(app.ui.status_bar, STATUS_NOT_MODIFIED, _("No Changes Since Last Save"));
1494 }
1495 }
1496
gui_main_is_enabled()1497 gboolean gui_main_is_enabled()
1498 {
1499 return GTK_WIDGET_IS_SENSITIVE(app.ui.menu.me);
1500 }
1501
gui_main_disable()1502 void gui_main_disable()
1503 {
1504 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.me), FALSE);
1505 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.paned_list), FALSE);
1506
1507 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_widget), FALSE);
1508 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_widget), FALSE);
1509
1510 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_label), FALSE);
1511 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_label), FALSE);
1512
1513 if(app.gui_find_replace && app.gui_find_replace->window)
1514 gtk_widget_set_sensitive(GTK_WIDGET(app.gui_find_replace->window), FALSE);
1515 }
1516
gui_main_enable()1517 void gui_main_enable()
1518 {
1519 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.me), TRUE);
1520 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.paned_list), TRUE);
1521
1522 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_widget), TRUE);
1523 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_widget), TRUE);
1524
1525 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_label), TRUE);
1526 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_label), TRUE);
1527
1528 if(app.gui_find_replace && app.gui_find_replace->window)
1529 gtk_widget_set_sensitive(GTK_WIDGET(app.gui_find_replace->window), TRUE);
1530 }
1531
gui_main_recent_list_update(GtkMenuItem * parent,GList * list,GCallback cb)1532 void gui_main_recent_list_update(GtkMenuItem *parent, GList *list, GCallback cb)
1533 {
1534 GtkMenu *menu = GTK_MENU(gtk_menu_new());
1535
1536 while(list)
1537 {
1538 GtkMenuItem *menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label((const gchar *) list->data));
1539 g_signal_connect(menu_item, "activate", cb, list->data);
1540 gtk_menu_append(menu, GTK_WIDGET(menu_item));
1541
1542 list = list->next;
1543 }
1544
1545 gtk_menu_item_set_submenu(parent, GTK_WIDGET(menu));
1546 gtk_widget_show_all(GTK_WIDGET(menu));
1547 }
1548
gui_main_recent_list_add(GtkMenuItem * parent,GList ** list,GCallback cb,char * filename)1549 void gui_main_recent_list_add(GtkMenuItem *parent, GList **list, GCallback cb, char *filename)
1550 {
1551 kry_recent_list_add(list, filename);
1552 gui_main_recent_list_update(parent, *list, cb);
1553 }
1554
gui_main_recent_list_save(GList * list,char * key)1555 void gui_main_recent_list_save(GList *list, char *key)
1556 {
1557 app.prefs->Remove(key);
1558 while(list)
1559 {
1560 app.prefs->SetListAddString(key, (char *) list->data);
1561 list = list->next;
1562 }
1563 }
1564
gui_main_setup_stock_icons()1565 void gui_main_setup_stock_icons()
1566 {
1567 GdkPixbuf *pixbuf_scaleup = gui_main_load_image(IDR_SCALE_UP);
1568 GdkPixbuf *pixbuf_scaledown = gui_main_load_image(IDR_SCALE_DOWN);
1569 GtkIconFactory *icon_factory = gtk_icon_factory_new();
1570
1571 app.ui.pixbufs.sarrow_up_left = gui_main_load_image(IDR_SARROW_UP_LEFT);
1572 app.ui.pixbufs.sarrow_up = gui_main_load_image(IDR_SARROW_UP);
1573 app.ui.pixbufs.sarrow_up_right = gui_main_load_image(IDR_SARROW_UP_RIGHT);
1574 app.ui.pixbufs.sarrow_left = gui_main_load_image(IDR_SARROW_LEFT);
1575 app.ui.pixbufs.sarrow_center = gui_main_load_image(IDR_SARROW_CENTER);
1576 app.ui.pixbufs.sarrow_right = gui_main_load_image(IDR_SARROW_RIGHT);
1577 app.ui.pixbufs.sarrow_down_left = gui_main_load_image(IDR_SARROW_DOWN_LEFT);
1578 app.ui.pixbufs.sarrow_down = gui_main_load_image(IDR_SARROW_DOWN);
1579 app.ui.pixbufs.sarrow_down_right = gui_main_load_image(IDR_SARROW_DOWN_RIGHT);
1580
1581 GtkIconSet *icon_set;
1582 GtkIconSet *iconset_show;
1583 GtkIconSet *iconset_hide;
1584 GtkIconSet *iconset_scaleup;
1585 GtkIconSet *iconset_scaledown;
1586
1587 #define STOCK_ITEM_COUNT 37
1588 GtkStockItem items[STOCK_ITEM_COUNT] =
1589 {
1590 {"sabbu-zoom-in", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1591 {"sabbu-zoom-out", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1592 {"sabbu-play", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1593 {"sabbu-stop", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1594 {"sabbu-play-selected", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1595 {"sabbu-check-mark", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1596 {"sabbu-play-last", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1597 {"sabbu-wave-show", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1598 {"sabbu-wave-hide", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1599 {"sabbu-wave-scale-up", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1600 {"sabbu-wave-scale-down", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1601 {"sabbu-wave-name", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1602 {"sabbu-wave-clone", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1603 {"sabbu-wave-close", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1604 {"sabbu-wave-jump", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1605 {"sabbu-play-previous", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1606 {"sabbu-play-current", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1607 {"sabbu-play-next", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1608 {"sabbu-left", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1609 {"sabbu-right", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1610 {"sabbu-up", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1611 {"sabbu-down", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1612 {"sabbu-jump-start", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1613 {"sabbu-jump-end", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1614 {"sabbu-new", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1615 {"sabbu-edit", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1616 {"sabbu-delete", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1617 {"sabbu-manager", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1618 {"sabbu-plus-sign", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1619 {"sabbu-x-mark", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1620 {"sabbu-scissors", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1621 {"sabbu-star", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1622 {"sabbu-bold", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1623 {"sabbu-italic", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1624 {"sabbu-underline", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1625 {"sabbu-strikethrough", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1626 {"sabbu-lock", "", (GdkModifierType) 0, 0, "sabbu-fake"},
1627 };
1628
1629 iconset_show = gtk_icon_set_new_from_pixbuf(app.ui.pixbufs.show);
1630 iconset_hide = gtk_icon_set_new_from_pixbuf(app.ui.pixbufs.hide);
1631 iconset_scaleup= gtk_icon_set_new_from_pixbuf(pixbuf_scaleup);
1632 iconset_scaledown = gtk_icon_set_new_from_pixbuf(pixbuf_scaledown);
1633
1634 gtk_icon_factory_add(icon_factory, "sabbu-wave-show", iconset_show);
1635 gtk_icon_factory_add(icon_factory, "sabbu-wave-hide", iconset_hide);
1636 gtk_icon_factory_add(icon_factory, "sabbu-wave-scale-up", iconset_scaleup);
1637 gtk_icon_factory_add(icon_factory, "sabbu-wave-scale-down", iconset_scaledown);
1638
1639 gtk_icon_factory_add_default(icon_factory);
1640
1641 icon_set = gtk_icon_factory_lookup_default("gtk-zoom-in");
1642 gtk_icon_factory_add(icon_factory, "sabbu-zoom-in", icon_set);
1643 icon_set = gtk_icon_factory_lookup_default("gtk-zoom-out");
1644 gtk_icon_factory_add(icon_factory, "sabbu-zoom-out", icon_set);
1645 icon_set = gtk_icon_factory_lookup_default("gtk-media-play");
1646 gtk_icon_factory_add(icon_factory, "sabbu-play", icon_set);
1647 icon_set = gtk_icon_factory_lookup_default("gtk-media-stop");
1648 gtk_icon_factory_add(icon_factory, "sabbu-stop", icon_set);
1649 icon_set = gtk_icon_factory_lookup_default("gtk-goto-last");
1650 gtk_icon_factory_add(icon_factory, "sabbu-play-selected", icon_set);
1651 icon_set = gtk_icon_factory_lookup_default("gtk-jump-to");
1652 gtk_icon_factory_add(icon_factory, "sabbu-play-last", icon_set);
1653 icon_set = gtk_icon_factory_lookup_default("gtk-apply");
1654 gtk_icon_factory_add(icon_factory, "sabbu-check-mark", icon_set);
1655 icon_set = gtk_icon_factory_lookup_default("gtk-properties");
1656 gtk_icon_factory_add(icon_factory, "sabbu-wave-name", icon_set);
1657 icon_set = gtk_icon_factory_lookup_default("gtk-copy");
1658 gtk_icon_factory_add(icon_factory, "sabbu-wave-clone", icon_set);
1659 icon_set = gtk_icon_factory_lookup_default("gtk-close");
1660 gtk_icon_factory_add(icon_factory, "sabbu-wave-close", icon_set);
1661 icon_set = gtk_icon_factory_lookup_default("gtk-redo");
1662 gtk_icon_factory_add(icon_factory, "sabbu-wave-jump", icon_set);
1663 icon_set = gtk_icon_factory_lookup_default("gtk-go-up");
1664 gtk_icon_factory_add(icon_factory, "sabbu-play-previous", icon_set);
1665 icon_set = gtk_icon_factory_lookup_default("gtk-go-forward");
1666 gtk_icon_factory_add(icon_factory, "sabbu-play-current", icon_set);
1667 icon_set = gtk_icon_factory_lookup_default("gtk-go-down");
1668 gtk_icon_factory_add(icon_factory, "sabbu-play-next", icon_set);
1669 icon_set = gtk_icon_factory_lookup_default("gtk-go-back");
1670 gtk_icon_factory_add(icon_factory, "sabbu-left", icon_set);
1671 icon_set = gtk_icon_factory_lookup_default("gtk-go-forward");
1672 gtk_icon_factory_add(icon_factory, "sabbu-right", icon_set);
1673 icon_set = gtk_icon_factory_lookup_default("gtk-go-up");
1674 gtk_icon_factory_add(icon_factory, "sabbu-up", icon_set);
1675 icon_set = gtk_icon_factory_lookup_default("gtk-go-down");
1676 gtk_icon_factory_add(icon_factory, "sabbu-down", icon_set);
1677 icon_set = gtk_icon_factory_lookup_default("gtk-goto-last");
1678 gtk_icon_factory_add(icon_factory, "sabbu-jump-end", icon_set);
1679 icon_set = gtk_icon_factory_lookup_default("gtk-goto-first");
1680 gtk_icon_factory_add(icon_factory, "sabbu-jump-start", icon_set);
1681
1682 icon_set = gtk_icon_factory_lookup_default("gtk-delete");
1683 gtk_icon_factory_add(icon_factory, "sabbu-delete", icon_set);
1684
1685 icon_set = gtk_icon_factory_lookup_default("gtk-new");
1686 gtk_icon_factory_add(icon_factory, "sabbu-new", icon_set);
1687
1688 icon_set = gtk_icon_factory_lookup_default("gtk-edit");
1689 gtk_icon_factory_add(icon_factory, "sabbu-edit", icon_set);
1690
1691 icon_set = gtk_icon_factory_lookup_default("gtk-dnd-multiple");
1692 gtk_icon_factory_add(icon_factory, "sabbu-manager", icon_set);
1693
1694 icon_set = gtk_icon_factory_lookup_default("gtk-add");
1695 gtk_icon_factory_add(icon_factory, "sabbu-plus-sign", icon_set);
1696
1697 icon_set = gtk_icon_factory_lookup_default("gtk-cancel");
1698 gtk_icon_factory_add(icon_factory, "sabbu-x-mark", icon_set);
1699
1700 icon_set = gtk_icon_factory_lookup_default("gtk-cut");
1701 gtk_icon_factory_add(icon_factory, "sabbu-scissors", icon_set);
1702
1703 icon_set = gtk_icon_factory_lookup_default("gtk-about");
1704 gtk_icon_factory_add(icon_factory, "sabbu-star", icon_set);
1705
1706 icon_set = gtk_icon_factory_lookup_default("gtk-bold");
1707 gtk_icon_factory_add(icon_factory, "sabbu-bold", icon_set);
1708
1709 icon_set = gtk_icon_factory_lookup_default("gtk-italic");
1710 gtk_icon_factory_add(icon_factory, "sabbu-italic", icon_set);
1711
1712 icon_set = gtk_icon_factory_lookup_default("gtk-underline");
1713 gtk_icon_factory_add(icon_factory, "sabbu-underline", icon_set);
1714
1715 icon_set = gtk_icon_factory_lookup_default("gtk-strikethrough");
1716 gtk_icon_factory_add(icon_factory, "sabbu-strikethrough", icon_set);
1717
1718 icon_set = gtk_icon_factory_lookup_default("gtk-dialog-authentication");
1719 gtk_icon_factory_add(icon_factory, "sabbu-lock", icon_set);
1720
1721 gtk_stock_add((GtkStockItem *) &items, STOCK_ITEM_COUNT);
1722 }
1723
gui_text_editor_keypress_cb(GtkWidget * widget,GdkEventKey * event,struct KryTextEditor * editor)1724 gboolean gui_text_editor_keypress_cb(GtkWidget *widget, GdkEventKey *event, struct KryTextEditor *editor)
1725 {
1726 if(gtk_im_context_filter_keypress (GTK_TEXT_VIEW (editor->view)->im_context, event))
1727 {
1728 GTK_TEXT_VIEW (editor->view)->need_im_reset = TRUE;
1729 return TRUE;
1730 }
1731
1732 if(event->keyval == GDK_Return && event->state & GDK_SHIFT_MASK && app.ui.ui_mode == UI_MODE_SRT)
1733 return FALSE;
1734
1735 if(event->keyval == GDK_Return)
1736 {
1737 if(app.ui.karaoke_mode == KARAOKE_MODE_LINE)
1738 {
1739 char *text = gui_text_editor_get_text(editor);
1740 gui_main_karaoke_split_word(text);
1741 kry_free(text);
1742 }
1743 else
1744 {
1745 gui_main_grab_times((enum grab_flags) (GRAB_ADVANCE | GRAB_ENTERKEY));
1746 }
1747 return TRUE;
1748 }
1749
1750 return FALSE;
1751 }
1752
1753 /* Creates the "Text Editor" widget. This widget contains the actual Text Editor, plus
1754 the toggles for code highlighting and the karaoke features */
gui_main_create_text_editor()1755 GtkWidget *gui_main_create_text_editor()
1756 {
1757 GtkFrame *frame_text = GTK_FRAME(gtk_frame_new(NULL));
1758 GtkHBox *hbox_input = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1759
1760 app.ui.karaoke_container = GTK_LAYOUT(gtk_layout_new(NULL, NULL));
1761 app.ui.hbox_karaoke = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1762
1763 app.ui.text_editor = gui_text_editor_new();
1764
1765 g_signal_connect(G_OBJECT(gui_text_editor_get_view(app.ui.text_editor)),
1766 "key-press-event", G_CALLBACK(gui_text_editor_keypress_cb), app.ui.text_editor);
1767
1768 GtkVBox *vbox_karaoke_switch = GTK_VBOX(gtk_vbox_new(FALSE, 0));
1769 GtkHBox *hbox_karaoke_switch = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1770 GtkButton *button_box = GTK_BUTTON(gtk_button_new());
1771 GtkButton *button_line = GTK_BUTTON(gtk_button_new());
1772
1773 GtkImage *image_box = GTK_IMAGE(gtk_image_new_from_pixbuf(app.ui.pixbufs.karaoke_box));
1774 GtkImage *image_line = GTK_IMAGE(gtk_image_new_from_pixbuf(app.ui.pixbufs.karaoke_line));
1775
1776 gtk_container_add(GTK_CONTAINER(button_box), GTK_WIDGET(image_box));
1777 gtk_container_add(GTK_CONTAINER(button_line), GTK_WIDGET(image_line));
1778
1779 //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(button_box), FALSE, TRUE, 1);
1780 //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(button_line), FALSE, TRUE, 1);
1781 gtk_container_set_border_width(GTK_CONTAINER(hbox_karaoke_switch), 1);
1782
1783 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_box), _("Karaoke Box Mode"), NULL);
1784 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_line), _("Karaoke Line Mode"), NULL);
1785
1786 g_signal_connect(G_OBJECT(button_box), "clicked", G_CALLBACK(gui_main_karaoke_mode_on), (gpointer) 0);
1787 g_signal_connect(G_OBJECT(button_line), "clicked", G_CALLBACK(gui_main_karaoke_mode_on), (gpointer) 1);
1788
1789 gtk_box_pack_start(GTK_BOX(vbox_karaoke_switch), GTK_WIDGET(hbox_karaoke_switch), FALSE, TRUE, 1);
1790
1791 app.ui.karaoke_hbox_switch = hbox_karaoke_switch;
1792 app.ui.karaoke_vbox_switch = vbox_karaoke_switch;
1793 app.ui.karaoke_button_box = button_box;
1794 app.ui.karaoke_button_line = button_line;
1795
1796
1797 GtkVBox *vbox_toolbar = GTK_VBOX(gtk_vbox_new(FALSE, 0));
1798 GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new());
1799
1800 GtkComboBox *combo = GTK_COMBO_BOX(gtk_combo_box_new_text());
1801 gtk_combo_box_append_text(combo, "\\k");
1802 gtk_combo_box_append_text(combo, "\\K");
1803 gtk_combo_box_append_text(combo, "\\ko");
1804
1805 g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(gui_main_karaoke_type_changed_cb), NULL);
1806 g_signal_connect(G_OBJECT(combo), "key-press-event", G_CALLBACK(gui_main_key_press), NULL);
1807
1808 app.ui.karaoke_type_combo = combo;
1809
1810 gtk_toolbar_append_item(toolbar, NULL, _("Exit Karaoke Mode"), _("Exit Karaoke Mode"),
1811 gtk_image_new_from_stock("sabbu-x-mark", GTK_ICON_SIZE_SMALL_TOOLBAR),
1812 GTK_SIGNAL_FUNC(gui_main_karaoke_mode_off_cb), (gpointer)1);
1813
1814 gtk_toolbar_append_item(toolbar, NULL, _("Save Changes"), _("Save Changes"),
1815 gtk_image_new_from_stock("sabbu-check-mark", GTK_ICON_SIZE_SMALL_TOOLBAR),
1816 GTK_SIGNAL_FUNC(gui_main_karaoke_mode_off_cb), 0);
1817
1818 gtk_toolbar_append_widget(toolbar, GTK_WIDGET(combo), _("Karaoke Type"), NULL);
1819
1820 app.ui.karaoke_toolbar_split = gtk_toolbar_append_item(toolbar, NULL, _("Split Word"), _("Split Word"),
1821 gtk_image_new_from_stock("sabbu-scissors", GTK_ICON_SIZE_SMALL_TOOLBAR),
1822 GTK_SIGNAL_FUNC(gui_main_karaoke_split_word_cb), NULL);
1823
1824 /*gtk_toolbar_append_item(toolbar, NULL, _("Add Silence"), _("Add Silence"),
1825 gtk_image_new_from_stock("sabbu-plus-sign", GTK_ICON_SIZE_SMALL_TOOLBAR),
1826 GTK_SIGNAL_FUNC(gui_main_karaoke_add_silence_before_cb), NULL);*/
1827
1828 app.ui.karaoke_vbox_toolbar = vbox_toolbar;
1829
1830
1831 gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR);
1832
1833 gtk_box_pack_start(GTK_BOX(vbox_toolbar), GTK_WIDGET(toolbar), FALSE, TRUE, 0);
1834
1835 gtk_box_pack_start(GTK_BOX(app.ui.hbox_karaoke), GTK_WIDGET(app.ui.karaoke_container), TRUE, TRUE, 0);
1836
1837
1838
1839 //GtkVSeparator *karaoke_separator = GTK_VSEPARATOR(gtk_vseparator_new());
1840
1841 //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(karaoke_separator), TRUE, TRUE, 2);
1842
1843 gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(vbox_karaoke_switch), FALSE, TRUE, 1);
1844 gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(vbox_toolbar), FALSE, TRUE, 5);
1845 gtk_box_pack_start(GTK_BOX(hbox_input), gui_text_editor_get_widget(app.ui.text_editor), TRUE, TRUE, 0);
1846 gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(app.ui.hbox_karaoke), TRUE, TRUE, 0);
1847
1848
1849 gtk_container_add(GTK_CONTAINER(frame_text), GTK_WIDGET(hbox_input));
1850
1851 return GTK_WIDGET(frame_text);
1852 }
1853
gui_main_time_start_enter_cb()1854 void gui_main_time_start_enter_cb()
1855 {
1856 gui_main_grab_times(GRAB_TIME_START_ONLY);
1857 gtk_widget_grab_focus(GTK_WIDGET(gui_time_entry_get_view(app.ui.time_end)));
1858 }
1859
gui_main_time_end_enter_cb()1860 void gui_main_time_end_enter_cb()
1861 {
1862 gui_main_grab_times(GRAB_TIME_END_ONLY);
1863 gtk_widget_grab_focus(GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor)));
1864 }
1865
gui_main_time_dur_enter_cb()1866 void gui_main_time_dur_enter_cb()
1867 {
1868 gui_main_grab_times(GRAB_TIME_START_ONLY);
1869 gui_main_grab_times(GRAB_TIME_END_ONLY);
1870 gtk_widget_grab_focus(GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor)));
1871 }
1872
gui_main_time_text_field_changed_cb(char * val,KryMarker ** marker)1873 void gui_main_time_text_field_changed_cb(char *val, KryMarker **marker)
1874 {
1875 if(app.ui.ui_mode == UI_MODE_SRT)
1876 kry_marker_set_value(*marker, time_string_to_mili(val, 0, TRUE, FALSE));
1877 else
1878 kry_marker_set_value(*marker, time_string_to_mili(val, 0));
1879 }
1880
gui_main_time_dur_field_changed_cb(char * val,gpointer data)1881 void gui_main_time_dur_field_changed_cb(char *val, gpointer data)
1882 {
1883 int dur;
1884 if(app.ui.ui_mode == UI_MODE_SRT)
1885 dur = time_string_to_mili(val, 0, TRUE, FALSE);
1886 else
1887 dur = time_string_to_mili(val, 0);
1888
1889 kry_marker_set_value(app.ui.marker_active_end, kry_marker_get_value(app.ui.marker_active_start) + dur);
1890 }
1891
gui_main_time_box_key_press_cb(GtkWidget * widget,GdkEventKey * key,gpointer data)1892 gboolean gui_main_time_box_key_press_cb(GtkWidget *widget, GdkEventKey *key, gpointer data)
1893 {
1894
1895 if(key->keyval == GDK_Tab || key->keyval == GDK_ISO_Left_Tab)
1896 {
1897 GtkWidget *widgets[3] =
1898 {
1899 GTK_WIDGET(g_object_get_data(G_OBJECT(app.ui.time_start), "text_view")),
1900 GTK_WIDGET(g_object_get_data(G_OBJECT(app.ui.time_end), "text_view")),
1901 GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor))
1902 };
1903 int cur = -1;
1904 int count = sizeof(widgets) / sizeof(GtkWidget *);
1905 for(int i = 0; i < count; i++)
1906 if(widgets[i] == widget)
1907 cur = i;
1908
1909 if(cur == -1)
1910 return FALSE;
1911
1912 if(key->state & GDK_SHIFT_MASK)
1913 cur--;
1914 else
1915 cur++;
1916
1917 if(cur < 0)
1918 cur = count - 1;
1919 if(cur >= count)
1920 cur = 0;
1921
1922 gtk_widget_grab_focus(widgets[cur]);
1923 return TRUE;
1924 }
1925
1926 return FALSE;
1927 }
1928
gui_main_leadin_cb(GtkWidget * widget,gpointer data)1929 void gui_main_leadin_cb(GtkWidget *widget, gpointer data)
1930 {
1931 KryMarker *marker = app.ui.marker_active_start;
1932 int offset = app.opts.leadin;
1933 int val = kry_marker_get_value(marker) - offset;
1934 if(val < 0)
1935 val = 0;
1936
1937 kry_marker_set_value(marker, val);
1938
1939 gui_main_focus_on_wave();
1940 }
1941
gui_main_leadout_cb(GtkWidget * widget,gpointer data)1942 void gui_main_leadout_cb(GtkWidget *widget, gpointer data)
1943 {
1944 KryMarker *marker = app.ui.marker_active_end;
1945 int offset = app.opts.leadout;
1946 int val = kry_marker_get_value(marker) + offset;
1947
1948 kry_marker_set_value(marker, val);
1949
1950 gui_main_focus_on_wave();
1951 }
1952
gui_main_leadboth_cb(GtkWidget * widget,gpointer data)1953 void gui_main_leadboth_cb(GtkWidget *widget, gpointer data)
1954 {
1955 gui_main_leadin_cb(widget, data);
1956 gui_main_leadout_cb(widget, data);
1957 }
1958
gui_main_play_speed_cb(GtkComboBox * combo,gpointer data)1959 void gui_main_play_speed_cb(GtkComboBox *combo, gpointer data)
1960 {
1961 char *text = gtk_combo_box_get_active_text(combo);
1962 int speed = atoi(text);
1963 kry_free(text);
1964
1965 app.ui.play_speed = speed;
1966 }
1967
1968 /* Creates the event editor widget. (The remaining edit controls after the text editor) */
gui_main_create_event_editor()1969 GtkWidget *gui_main_create_event_editor()
1970 {
1971 GtkButton *button_leadin = GTK_BUTTON(gtk_button_new());
1972 GtkButton *button_leadout = GTK_BUTTON(gtk_button_new());
1973 GtkButton *button_leadboth = GTK_BUTTON(gtk_button_new());
1974 GtkButton *button_start_less_10 = GTK_BUTTON(gtk_button_new());
1975 GtkButton *button_start_more_10 = GTK_BUTTON(gtk_button_new());
1976 GtkButton *button_start_less_1 = GTK_BUTTON(gtk_button_new());
1977 GtkButton *button_start_more_1 = GTK_BUTTON(gtk_button_new());
1978 GtkButton *button_end_less_10 = GTK_BUTTON(gtk_button_new());;
1979 GtkButton *button_end_more_10 = GTK_BUTTON(gtk_button_new());
1980 GtkButton *button_end_less_1 = GTK_BUTTON(gtk_button_new());
1981 GtkButton *button_end_more_1 = GTK_BUTTON(gtk_button_new());
1982 GtkHBox *hbox_start_10 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1983 GtkHBox *hbox_end_10 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1984 GtkHBox *hbox_start_1 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1985 GtkHBox *hbox_end_1 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
1986 GtkLabel *label_start = GTK_LABEL(gtk_label_new(_("Start:")));
1987 GtkLabel *label_end = GTK_LABEL(gtk_label_new(_("End:")));
1988 GtkLabel *label_dur = GTK_LABEL(gtk_label_new(_("Dur:")));
1989 GtkLabel *label_style = GTK_LABEL(gtk_label_new(_("Style:")));
1990 GtkLabel *label_name = GTK_LABEL(gtk_label_new(_("Name:")));
1991 GtkLabel *label_layer = GTK_LABEL(gtk_label_new(_("Layer:")));
1992 GtkLabel *label_speed = GTK_LABEL(gtk_label_new(_("Play Speed")));
1993 GtkSpinButton *spin_layer = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 99, 1));
1994 GtkTable *table;
1995
1996 GtkComboBox *combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text());
1997 g_signal_connect(G_OBJECT(combo_box), "changed", G_CALLBACK(gui_main_play_speed_cb), NULL);
1998
1999 gtk_combo_box_append_text(combo_box, "25%");
2000 gtk_combo_box_append_text(combo_box, "50%");
2001 gtk_combo_box_append_text(combo_box, "100%");
2002 gui_combo_box_set_text(combo_box, "100%", FALSE);
2003
2004 gtk_container_add(GTK_CONTAINER(button_leadin), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadin)));
2005 gtk_container_add(GTK_CONTAINER(button_leadout), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadout)));
2006 gtk_container_add(GTK_CONTAINER(button_leadboth), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadboth)));
2007
2008 gtk_container_add(GTK_CONTAINER(button_start_less_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left2)));
2009 gtk_container_add(GTK_CONTAINER(button_end_less_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left2)));
2010
2011 gtk_container_add(GTK_CONTAINER(button_start_more_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right2)));
2012 gtk_container_add(GTK_CONTAINER(button_end_more_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right2)));
2013
2014 gtk_container_add(GTK_CONTAINER(button_start_less_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left)));
2015 gtk_container_add(GTK_CONTAINER(button_end_less_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left)));
2016
2017 gtk_container_add(GTK_CONTAINER(button_start_more_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right)));
2018 gtk_container_add(GTK_CONTAINER(button_end_more_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right)));
2019
2020
2021 g_signal_connect(spin_layer, "value-changed", G_CALLBACK(gui_main_layer_style_changed_cb), NULL);
2022
2023 app.ui.label_layer = label_layer;
2024 app.ui.spin_layer = spin_layer;
2025
2026
2027 table = GTK_TABLE(gtk_table_new(2, 10, 0));
2028
2029
2030 struct hold_button_callback_info *info_start_less1 = kry_new0(struct hold_button_callback_info);
2031 info_start_less1->func = (kryButtonCallback) gui_main_marker_start_move;
2032 info_start_less1->data = (gpointer) - 10;
2033
2034 struct hold_button_callback_info *info_start_less10 = kry_new0(struct hold_button_callback_info);
2035 info_start_less10->func = (kryButtonCallback) gui_main_marker_start_move;
2036 info_start_less10->data = (gpointer) - 100;
2037
2038 struct hold_button_callback_info *info_start_more1 = kry_new0(struct hold_button_callback_info);
2039 info_start_more1->func = (kryButtonCallback) gui_main_marker_start_move;
2040 info_start_more1->data = (gpointer) 10;
2041
2042 struct hold_button_callback_info *info_start_more10 = kry_new0(struct hold_button_callback_info);
2043 info_start_more10->func = (kryButtonCallback) gui_main_marker_start_move;
2044 info_start_more10->data = (gpointer) 100;
2045
2046 struct hold_button_callback_info *info_end_less1 = kry_new0(struct hold_button_callback_info);
2047 info_end_less1->func = (kryButtonCallback) gui_main_marker_end_move;
2048 info_end_less1->data = (gpointer) - 10;
2049
2050 struct hold_button_callback_info *info_end_less10 = kry_new0(struct hold_button_callback_info);
2051 info_end_less10->func = (kryButtonCallback) gui_main_marker_end_move;
2052 info_end_less10->data = (gpointer) - 100;
2053
2054 struct hold_button_callback_info *info_end_more1 = kry_new0(struct hold_button_callback_info);
2055 info_end_more1->func = (kryButtonCallback) gui_main_marker_end_move;
2056 info_end_more1->data = (gpointer) 10;
2057
2058 struct hold_button_callback_info *info_end_more10 = kry_new0(struct hold_button_callback_info);
2059 info_end_more10->func = (kryButtonCallback) gui_main_marker_end_move;
2060 info_end_more10->data = (gpointer) 100;
2061
2062 app.ui.button_start_less_10 = button_start_less_10;
2063 app.ui.button_start_more_10 = button_start_more_10;
2064 app.ui.button_start_less_1 = button_start_less_1;
2065 app.ui.button_start_more_1 = button_start_more_1;
2066
2067 g_signal_connect(button_leadin, "clicked", G_CALLBACK(gui_main_leadin_cb), NULL);
2068 g_signal_connect(button_leadout, "clicked", G_CALLBACK(gui_main_leadout_cb), NULL);
2069 g_signal_connect(button_leadboth, "clicked", G_CALLBACK(gui_main_leadboth_cb), NULL);
2070
2071
2072 g_signal_connect(button_start_less_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less1);
2073 g_signal_connect(button_start_less_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less10);
2074 g_signal_connect(button_start_more_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more1);
2075 g_signal_connect(button_start_more_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more10);
2076
2077 g_signal_connect(button_end_less_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_less1);
2078 g_signal_connect(button_end_less_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_less10);
2079 g_signal_connect(button_end_more_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_more1);
2080 g_signal_connect(button_end_more_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_more10);
2081
2082 g_signal_connect(button_start_less_1, "released", G_CALLBACK(gui_main_hold_button_release ), info_start_less1);
2083 g_signal_connect(button_start_less_10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_less10);
2084 g_signal_connect(button_start_more_1, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more1);
2085 g_signal_connect(button_start_more_10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more10);
2086
2087 g_signal_connect(button_end_less_1, "released", G_CALLBACK(gui_main_hold_button_release), info_end_less1);
2088 g_signal_connect(button_end_less_10, "released", G_CALLBACK(gui_main_hold_button_release), info_end_less10);
2089 g_signal_connect(button_end_more_1, "released", G_CALLBACK(gui_main_hold_button_release), info_end_more1);
2090 g_signal_connect(button_end_more_10, "released", G_CALLBACK(gui_main_hold_button_release), info_end_more10);
2091
2092 app.ui.info_start_less1 = info_start_less1;
2093 app.ui.info_start_less10 = info_start_less10;
2094 app.ui.info_start_more1 = info_start_more1;
2095 app.ui.info_start_more10 = info_start_more10;
2096
2097 app.ui.info_end_less1 = info_end_less1;
2098 app.ui.info_end_less10 = info_end_less10;
2099 app.ui.info_end_more1 = info_end_more1;
2100 app.ui.info_end_more10 = info_end_more10;
2101
2102 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadin), _("Add Lead-In"), NULL);
2103 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadout), _("Add Lead-Out"), NULL);
2104 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadboth), _("Add Lead-In & Lead-Out"), NULL);
2105
2106 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_less_1), _("Start -0.01 s"), NULL);
2107 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_less_10), _("Start -0.1 s"), NULL);
2108 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_more_1), _("Start +0.01 s"), NULL);
2109 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_more_10), _("Start +0.1 s"), NULL);
2110
2111 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_less_1), _("End -0.01 s"), NULL);
2112 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_less_10), _("End -0.1 s"), NULL);
2113 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_more_1), _("End +0.01 s"), NULL);
2114 gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_more_10), _("End +0.1 s"), NULL);
2115
2116 gtk_box_pack_start(GTK_BOX(hbox_start_10), GTK_WIDGET(button_start_less_10), FALSE, TRUE, 1);
2117 gtk_box_pack_start(GTK_BOX(hbox_start_10), GTK_WIDGET(button_start_more_10), FALSE, TRUE, 1);
2118
2119 gtk_box_pack_start(GTK_BOX(hbox_end_10), GTK_WIDGET(button_end_less_10), FALSE, TRUE, 1);
2120 gtk_box_pack_start(GTK_BOX(hbox_end_10), GTK_WIDGET(button_end_more_10), FALSE, TRUE, 1);
2121
2122 app.ui.hbox_start_1 = hbox_start_1;
2123 gtk_box_pack_start(GTK_BOX(hbox_start_1), GTK_WIDGET(button_start_less_1), FALSE, TRUE, 1);
2124 gtk_box_pack_start(GTK_BOX(hbox_start_1), GTK_WIDGET(button_start_more_1), FALSE, TRUE, 1);
2125
2126 app.ui.hbox_end_1 = hbox_end_1;
2127 gtk_box_pack_start(GTK_BOX(hbox_end_1), GTK_WIDGET(button_end_less_1), FALSE, TRUE, 1);
2128 gtk_box_pack_start(GTK_BOX(hbox_end_1), GTK_WIDGET(button_end_more_1), FALSE, TRUE, 1);
2129
2130
2131 GtkWidget *border_start2 = gtk_event_box_new();
2132 {
2133 GtkWidget *border_start1 = gtk_event_box_new();
2134 app.ui.time_start = gui_time_entry_new(
2135 G_CALLBACK(gui_main_time_text_field_changed_cb),
2136 G_CALLBACK(gui_main_time_start_enter_cb),
2137 &app.ui.marker_active_start);
2138
2139 gtk_container_add(GTK_CONTAINER(border_start1), GTK_WIDGET(app.ui.time_start));
2140 gtk_container_add(GTK_CONTAINER(border_start2), GTK_WIDGET(border_start1));
2141 gtk_container_set_border_width(GTK_CONTAINER(border_start1), 2);
2142 app.ui.box_time_start = GTK_WIDGET(border_start2);
2143 }
2144
2145 /*GdkColor red;
2146 red.red = 257*255;
2147 red.green = 257*64;
2148 red.blue = 257*64;
2149 red.pixel = 0;
2150 gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, &red);*/
2151
2152
2153 GtkWidget *border_end2 = gtk_event_box_new();
2154 {
2155 GtkWidget *border_end1 = gtk_event_box_new();
2156 app.ui.time_end = gui_time_entry_new(
2157 G_CALLBACK(gui_main_time_text_field_changed_cb),
2158 G_CALLBACK(gui_main_time_end_enter_cb),
2159 &app.ui.marker_active_end);
2160
2161 gtk_container_add(GTK_CONTAINER(border_end1), GTK_WIDGET(app.ui.time_end));
2162 gtk_container_add(GTK_CONTAINER(border_end2), GTK_WIDGET(border_end1));
2163 gtk_container_set_border_width(GTK_CONTAINER(border_end1), 2);
2164 app.ui.box_time_end = GTK_WIDGET(border_end2);
2165 }
2166
2167
2168 GtkWidget *border_dur2 = gtk_event_box_new();
2169 {
2170 GtkWidget *border_dur1 = gtk_event_box_new();
2171 app.ui.time_dur = gui_time_entry_new(
2172 G_CALLBACK(gui_main_time_dur_field_changed_cb),
2173 G_CALLBACK(gui_main_time_dur_enter_cb),
2174 NULL);
2175
2176 gtk_container_add(GTK_CONTAINER(border_dur1), GTK_WIDGET(app.ui.time_dur));
2177 gtk_container_add(GTK_CONTAINER(border_dur2), GTK_WIDGET(border_dur1));
2178 gtk_container_set_border_width(GTK_CONTAINER(border_dur1), 2);
2179 }
2180
2181 //gtk_widget_set_sensitive(app.ui.time_dur, FALSE);
2182
2183 app.ui.label_style = label_style;
2184 app.ui.label_name = label_name;
2185
2186 app.ui.combo_style = GTK_COMBO_BOX(gtk_combo_box_entry_new_text());
2187 gtk_combo_box_set_model(app.ui.combo_style, GTK_TREE_MODEL(app.ui.style_store));
2188 gtk_editable_set_editable(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(app.ui.combo_style))), FALSE);
2189 gtk_widget_set_size_request(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(app.ui.combo_style))), 100, -1);
2190 gtk_combo_box_set_focus_on_click(app.ui.combo_style, FALSE);
2191
2192 g_signal_connect(app.ui.combo_style, "changed", G_CALLBACK(gui_main_entry_style_changed_cb), NULL);
2193 g_signal_connect(app.ui.combo_style, "key-press-event", G_CALLBACK(gui_main_key_press), NULL);
2194
2195 app.ui.name_store = gtk_list_store_new(1, G_TYPE_STRING);
2196 app.ui.name_store_sorted = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(app.ui.name_store));
2197
2198 app.ui.combo_name = GTK_COMBO_BOX(gtk_combo_box_entry_new_text());
2199 gtk_combo_box_set_model(app.ui.combo_name, GTK_TREE_MODEL(app.ui.name_store_sorted));
2200 //gtk_editable_set_editable(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(app.ui.combo_name))), FALSE);
2201 gtk_widget_set_size_request(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(app.ui.combo_name))), 100, -1);
2202 gtk_combo_box_set_focus_on_click(app.ui.combo_name, FALSE);
2203
2204 //g_signal_connect(G_OBJECT(app.ui.combo_name), "focus-out-event", G_CALLBACK(gui_main_entry_name_text_changed_cb), app.ui.combo_name);
2205 g_signal_connect(gtk_bin_get_child(GTK_BIN(app.ui.combo_name)), "key-press-event", G_CALLBACK(gui_main_entry_name_press_cb), app.ui.combo_name);
2206 g_signal_connect(gtk_bin_get_child(GTK_BIN(app.ui.combo_name)), "key-release-event", G_CALLBACK(gui_main_entry_name_release_cb), app.ui.combo_name);
2207 g_signal_connect(gtk_bin_get_child(GTK_BIN(app.ui.combo_name)), "activate", G_CALLBACK(gui_main_entry_name_changed_cb), app.ui.combo_name);
2208 g_signal_connect(GTK_WIDGET(app.ui.combo_name), "changed", G_CALLBACK(gui_main_entry_name_changed_cb), app.ui.combo_name);
2209
2210 gtk_misc_set_alignment(GTK_MISC(label_start), 1.0, 0.5);
2211 gtk_misc_set_alignment(GTK_MISC(label_end), 1.0, 0.5);
2212
2213 gtk_misc_set_alignment(GTK_MISC(label_style), 1.0, 0.5);
2214 gtk_misc_set_alignment(GTK_MISC(label_name), 1.0, 0.5);
2215
2216 gtk_misc_set_alignment(GTK_MISC(label_dur), 1.0, 0.5);
2217 gtk_misc_set_alignment(GTK_MISC(label_layer), 1.0, 0.5);
2218
2219 app.ui.table_event_editor = table;
2220
2221 // controls
2222 {
2223 GtkFrame *controls = GTK_FRAME(gtk_frame_new(NULL));
2224 GtkWidget *widget = gui_main_create_control_toolbar(CONTROLS_TABLE);
2225
2226 gtk_container_add(GTK_CONTAINER(controls), widget);
2227 gtk_table_attach(app.ui.table_event_editor, GTK_WIDGET(controls), 0, 4, 0, 2, GTK_FILL, GTK_FILL, 2, 0);
2228
2229 gtk_widget_show_all(GTK_WIDGET(controls));
2230 app.ui.frame_controls = controls;
2231 }
2232
2233 gtk_table_attach(table, GTK_WIDGET(button_leadin), 5, 6, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2234 gtk_table_attach(table, GTK_WIDGET(button_leadout), 5, 6, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2235 gtk_table_attach(table, GTK_WIDGET(button_leadboth), 4, 5, 0, 2, GTK_FILL, GTK_FILL, 2, 2);
2236
2237 int off = 6;
2238 gtk_table_attach(table, GTK_WIDGET(label_start), off + 0, off + 1, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2239 gtk_table_attach(table, GTK_WIDGET(hbox_start_10), off + 1, off + 2, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2240 gtk_table_attach(table, GTK_WIDGET(border_start2), off + 2, off + 3, 0, 1, GTK_FILL, GTK_FILL, 0, 2);
2241 gtk_table_attach(table, GTK_WIDGET(hbox_start_1), off + 3, off + 4, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2242
2243 gtk_table_attach(table, GTK_WIDGET(label_end), off + 0, off + 1, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2244 gtk_table_attach(table, GTK_WIDGET(hbox_end_10), off + 1, off + 2, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2245 gtk_table_attach(table, GTK_WIDGET(border_end2), off + 2, off + 3, 1, 2, GTK_FILL, GTK_FILL, 0, 2);
2246 gtk_table_attach(table, GTK_WIDGET(hbox_end_1), off + 3, off + 4, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2247
2248 gtk_table_attach(table, GTK_WIDGET(label_dur), off + 4, off + 5, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2249 gtk_table_attach(table, GTK_WIDGET(border_dur2), off + 5, off + 6, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2250
2251 gtk_table_attach(table, GTK_WIDGET(label_layer), off + 4, off + 5, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2252 gtk_table_attach(table, GTK_WIDGET(spin_layer), off + 5, off + 6, 1, 2, GTK_FILL, GTK_FILL, 3, 2);
2253
2254 gtk_table_attach(table, GTK_WIDGET(label_style), off + 6, off + 7, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2255 gtk_table_attach(table, GTK_WIDGET(app.ui.combo_style), off + 7, off + 8, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
2256
2257 gtk_table_attach(table, GTK_WIDGET(label_name), off + 6, off + 7, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2258 gtk_table_attach(table, GTK_WIDGET(app.ui.combo_name), off + 7, off + 8, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
2259
2260 GtkFrame *frame_speed = GTK_FRAME(gtk_frame_new(NULL));
2261 GtkVBox *vbox_speed = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2262 gtk_box_pack_start(GTK_BOX(vbox_speed), GTK_WIDGET(label_speed), TRUE, TRUE, 0);
2263 gtk_box_pack_start(GTK_BOX(vbox_speed), GTK_WIDGET(combo_box), TRUE, TRUE, 0);
2264 gtk_container_add(GTK_CONTAINER(frame_speed), GTK_WIDGET(vbox_speed));
2265 gtk_container_set_border_width(GTK_CONTAINER(vbox_speed), 2);
2266
2267 //gtk_table_attach(table, GTK_WIDGET(frame_speed), off + 8, off + 9, 0, 2, GTK_FILL, GTK_FILL, 2, 2);
2268
2269
2270 return GTK_WIDGET(table);
2271 }
2272
2273
gui_main_paned_move_cb(GtkPaned * paned,GParamSpec * spec,GtkNotebook * notebook)2274 void gui_main_paned_move_cb(GtkPaned *paned, GParamSpec *spec, GtkNotebook *notebook)
2275 {
2276 if(g_object_get_data(G_OBJECT(paned), "sabbu-signal-ignore"))
2277 return;
2278
2279 int page = gtk_notebook_get_current_page(notebook);
2280 int pos = gtk_paned_get_position(paned);
2281
2282 if(page == NOTEBOOK_PAGE_VIDEO)
2283 app.ui.pane_video_pos = pos;
2284 else if(page == NOTEBOOK_PAGE_AUDIO)
2285 app.ui.pane_other_pos = pos;
2286 }
2287
2288
gui_main_text_paned_move_cb(GtkPaned * paned,GParamSpec * spec,gpointer data)2289 void gui_main_text_paned_move_cb(GtkPaned *paned, GParamSpec *spec, gpointer data)
2290 {
2291 long min_height = (long) g_object_get_data(G_OBJECT(paned), "sabbu-min-size");
2292 int pos = gtk_paned_get_position(paned);
2293 if(pos < min_height)
2294 {
2295 gtk_paned_set_position(paned, min_height);
2296 return;
2297 }
2298 app.prefs->SetInt("TextEditorPanedPos", pos);
2299 }
2300
gui_main_get_menu_item(char * text,GtkItemFactory * item_factory)2301 GtkMenuItem *gui_main_get_menu_item(char *text, GtkItemFactory *item_factory)
2302 {
2303 char *text2 = string_replace(text, "_", "");
2304 char *menu_text = kry_strdup_printf(KRY_LOC "<main_menu>%s", text2);
2305 GtkMenuItem *menu = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory, menu_text));
2306 kry_free(menu_text);
2307 kry_free(text2);
2308
2309 if(!menu)
2310 g_warning("unable to lookup menu item: %s", text);
2311
2312 return menu;
2313 }
2314
gui_main_focus()2315 void gui_main_focus()
2316 {
2317 gtk_window_present(app.ui.window);
2318 gui_main_focus_on_wave();
2319 }
2320
gui_main_spellcheck_language_cb(GtkWidget * widget,char * lang)2321 void gui_main_spellcheck_language_cb(GtkWidget *widget, char *lang)
2322 {
2323 #ifdef HAVE_ASPELL
2324 if(app.ui.speller)
2325 {
2326 spell_destroy(app.ui.speller);
2327 app.ui.speller = NULL;
2328 }
2329
2330 app.ui.speller = spell_create((char *) lang);
2331 #endif
2332 }
2333
gui_main_create()2334 void gui_main_create()
2335 {
2336 GtkAccelGroup *accel_group = gtk_accel_group_new();
2337 GtkWidget *menu_widget;
2338 GtkVBox *vbox_super = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2339 GtkFrame *frame = GTK_FRAME(gtk_frame_new(NULL));
2340 GtkVBox *vbox_text = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2341 GtkHBox *hbox_table = GTK_HBOX(gtk_hbox_new(FALSE, 0));
2342 GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
2343 GtkVBox *vbox_notebook = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2344 GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new());
2345 GtkVBox *timing_box = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2346 GtkLabel *page_progress;
2347 GtkVBox *vbox_event_edit = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2348 GtkPaned *paned_notebook = GTK_PANED(gtk_vpaned_new());
2349 GtkPaned *paned_list = GTK_PANED(gtk_vpaned_new());
2350
2351 app.ui.notebook = notebook;
2352
2353 // event list colors
2354 {
2355 kryColorTable *table = new kryColorTable(LIST_COLOR_COUNT);
2356 table->Set(LIST_COLOR_COMMENT, "EventListComment", __("Color|Comment"), 0xCC, 0xCC, 0xFF);
2357 table->Set(LIST_COLOR_COLLISION, "EventListCollision", __("Color|Collision"), 0xFF, 0xBB, 0xBB);
2358 table->Set(LIST_COLOR_COLLISION_HIGHLIGHT, "EventListCollisionHighlight", __("Color|Collision Highlight"), 0xFF, 0x77, 0x77);
2359
2360 for(int i = 0; i < table->GetColorCount(); i++)
2361 {
2362 if(table->Get(i)->IsInitialized())
2363 gui_event_list_color_change_string(table->Get(i));
2364 }
2365
2366 app.ui.list_color_table = table;
2367 }
2368
2369 // status bar colors
2370 {
2371 kryColorTable *table = new kryColorTable(STATUS_COLOR_COUNT);
2372 table->Set(STATUS_COLOR_SUCCESS, "StatusSuccess", __("Color|Success"), 0, 0xFF, 0);
2373 table->Set(STATUS_COLOR_UNSAVED, "StatusUnsaved", __("Color|Unsaved Changes"), 0xFF, 0xC0, 0xC0);
2374 app.ui.status_bar_color_table = table;
2375 }
2376
2377 // syntax highlighting colors
2378 {
2379 kryColorTable *table = new kryColorTable(HIGHLIGHT_COLOR_COUNT);
2380 table->Set(HIGHLIGHT_COLOR_COMMAND1, "HighlightCommand1", __("Color|Command 1"), 0xAA, 0x22, 0x22);
2381 table->Set(HIGHLIGHT_COLOR_COMMAND2, "HighlightCommand2", __("Color|Command 2"), 0x22, 0xAA, 0x22);
2382 table->Set(HIGHLIGHT_COLOR_TEXT, "HighlightText", __("Color|Text"), 0x00, 0x00, 0xFF);
2383 table->Set(HIGHLIGHT_COLOR_ERROR, "HighlightError", __("Color|Error"), 0xFF, 0x00, 0x00);
2384
2385 app.ui.highlight_color_table = table;
2386 }
2387
2388 // setup find options
2389 {
2390 app.gui_find_replace_options.match_case = app.prefs->GetInt("SearchMatchCase", 0);
2391 app.gui_find_replace_options.match_wholeword = app.prefs->GetInt("SearchMatchWholeWord", 0);
2392 app.gui_find_replace_options.search_up = app.prefs->GetInt("SearchMatchSearchUp", 0);
2393 app.gui_find_replace_options.search_text = app.prefs->GetInt("SearchMatchSearchText", 1);
2394 app.gui_find_replace_options.search_style = app.prefs->GetInt("SearchMatchSearchStyle", 0);
2395 app.gui_find_replace_options.search_name = app.prefs->GetInt("SearchMatchSearchName", 0);
2396
2397 app.gui_find_replace_options.target_history = kry_recent_list_load("SearchHistory");
2398 }
2399
2400 // setup the markers
2401 {
2402 app.ui.marker_event_start = KRY_MARKER(kry_marker_new(MARKER_START, 10));
2403 app.ui.marker_event_end = KRY_MARKER(kry_marker_new(MARKER_END, 10));
2404 app.ui.marker_current = KRY_MARKER(kry_marker_new(MARKER_CURRENT, 1));
2405 app.ui.marker_active_start = app.ui.marker_event_start;
2406 app.ui.marker_active_end = app.ui.marker_event_end;
2407
2408 g_signal_connect(app.ui.marker_event_start, "value-changed", G_CALLBACK(gui_main_marker_changed_cb), NULL);
2409 g_signal_connect(app.ui.marker_event_end, "value-changed", G_CALLBACK(gui_main_marker_changed_cb), NULL);
2410 }
2411
2412 // initialize common stuff
2413 {
2414 app.ui.tooltips = gtk_tooltips_new();
2415 app.ui.style_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
2416 app.ui.pixbufs.show = gui_main_load_image(IDR_ARROW_DOWN);
2417 app.ui.pixbufs.hide = gui_main_load_image(IDR_ARROW_RIGHT);
2418 app.ui.pixbufs.gear = gui_main_load_image(IDR_GEAR);
2419 app.ui.pixbufs.syntax = gui_main_load_image(IDR_SYNTAX);
2420 app.ui.pixbufs.syntax_off = gui_main_load_image(IDR_SYNTAX_OFF);
2421 app.ui.pixbufs.karaoke_box = gui_main_load_image(IDR_KARAOKE_BOX);
2422 app.ui.pixbufs.karaoke_line = gui_main_load_image(IDR_KARAOKE_LINE);
2423 app.ui.pixbufs.search_indicator = gui_main_load_image(IDR_SEARCH_INDICATOR);
2424 app.ui.pixbufs.margin_left = gui_main_load_image(IDR_MARGIN_LEFT);
2425 app.ui.pixbufs.margin_right = gui_main_load_image(IDR_MARGIN_RIGHT);
2426 app.ui.pixbufs.margin_vertical = gui_main_load_image(IDR_MARGIN_VERTICAL);
2427 app.ui.pixbufs.angle = gui_main_load_image(IDR_ANGLE);
2428 app.ui.pixbufs.scalex = gui_main_load_image(IDR_SCALEX);
2429 app.ui.pixbufs.scaley = gui_main_load_image(IDR_SCALEY);
2430 app.ui.pixbufs.spacing = gui_main_load_image(IDR_SPACING);
2431
2432 app.ui.pixbufs.time_left = gui_main_load_image(IDR_TIME_LEFT);
2433 app.ui.pixbufs.time_left2 = gui_main_load_image(IDR_TIME_LEFT2);
2434 app.ui.pixbufs.time_right = gui_main_load_image(IDR_TIME_RIGHT);
2435 app.ui.pixbufs.time_right2 = gui_main_load_image(IDR_TIME_RIGHT2);
2436
2437 app.ui.pixbufs.sync_scroll = gui_main_load_image(IDR_SYNC_SCROLL);
2438 app.ui.pixbufs.sync_zoom = gui_main_load_image(IDR_SYNC_ZOOM);
2439 app.ui.pixbufs.sync_scale = gui_main_load_image(IDR_SYNC_SCALE);
2440
2441 app.ui.pixbufs.play = gui_main_load_image(IDR_PLAY);
2442 app.ui.pixbufs.play_last = gui_main_load_image(IDR_PLAY_LAST);
2443 app.ui.pixbufs.play_selection = gui_main_load_image(IDR_PLAY_SELECTION);
2444 app.ui.pixbufs.play_stop = gui_main_load_image(IDR_PLAY_STOP);
2445
2446 app.ui.pixbufs.grab_times = gui_main_load_image(IDR_GRAB_TIMES);
2447 app.ui.pixbufs.focus_selected = gui_main_load_image(IDR_FOCUS_SELECTED);
2448
2449 app.ui.pixbufs.show_time = gui_main_load_image(IDR_SHOW_TIME);
2450 app.ui.pixbufs.show_keyframes = gui_main_load_image(IDR_SHOW_KEYFRAMES);
2451
2452 app.ui.pixbufs.leadin = gui_main_load_image(IDR_LEADIN);
2453 app.ui.pixbufs.leadout = gui_main_load_image(IDR_LEADOUT);
2454 app.ui.pixbufs.leadboth = gui_main_load_image(IDR_LEADBOTH);
2455
2456 app.ui.paned_notebook = paned_notebook;
2457 app.ui.paned_list = paned_list;
2458 app.ui.vbox_event_edit = vbox_event_edit;
2459 gui_main_setup_stock_icons();
2460 }
2461
2462 // setup main window properties
2463 {
2464 app.ui.window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
2465 app.ui.window_focus = app.ui.window;
2466
2467 if(app.prefs->GetInt("StartMaximized", 0))
2468 gtk_window_maximize(app.ui.window);
2469
2470 gtk_widget_set_usize (GTK_WIDGET(app.ui.window), -1, 600);
2471 gtk_window_set_default_size(app.ui.window,
2472 app.prefs->GetInt("WindowMainWidth", -1),
2473 app.prefs->GetInt("WindowMainHeight", -1));
2474
2475 int x = app.prefs->GetInt("WindowMainX", -1);
2476 int y = app.prefs->GetInt("WindowMainY", -1);
2477
2478 if(x != -1 && y != -1)
2479 gtk_window_move(app.ui.window, x, y);
2480
2481 gtk_window_add_accel_group(app.ui.window, accel_group);
2482 g_signal_connect(app.ui.window, "delete-event", G_CALLBACK(gui_main_cb_delete), NULL);
2483 g_signal_connect(app.ui.window, "configure-event", G_CALLBACK(gui_main_cb_configure), NULL);
2484 }
2485
2486 // setup menus
2487 {
2488 menu_widget = GTK_WIDGET(gui_menu_create());
2489 app.ui.menu.me = GTK_MENU_BAR(menu_widget);
2490 gtk_box_pack_start(GTK_BOX(vbox_super), GTK_WIDGET(menu_widget), FALSE, TRUE, 0);
2491
2492
2493 gui_main_karaoke_disable_menus();
2494
2495 {
2496 GtkMenu *menu = GTK_MENU(gtk_menu_new());
2497
2498 GtkMenuItem *menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label(__("EventType|Dialog")));
2499 g_signal_connect(menu_item, "activate", G_CALLBACK(gui_main_menu_event_type), (gpointer) kryEvent::EVENT_DIALOG);
2500 gtk_menu_append(menu, GTK_WIDGET(menu_item));
2501
2502 menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label(__("EventType|Comment")));
2503 g_signal_connect(menu_item, "activate", G_CALLBACK(gui_main_menu_event_type), (gpointer) kryEvent::EVENT_COMMENT_DIALOG);
2504 gtk_menu_append(menu, GTK_WIDGET(menu_item));
2505
2506 gtk_menu_item_set_submenu(app.ui.menu.event.type, GTK_WIDGET(menu));
2507 }
2508
2509 app.ui.list_recent_scripts = kry_recent_list_load("Recent File");
2510 app.ui.list_recent_workspaces = kry_recent_list_load("Recent Workspace");
2511 app.ui.list_recent_audio = kry_recent_list_load("Recent Audio");
2512 app.ui.list_recent_videos = kry_recent_list_load("Recent Video");
2513
2514 app.ui.cb_recent_scripts = (GCallback) gui_main_menu_script_openrecent;
2515 app.ui.cb_recent_workspaces = (GCallback) gui_workspace_openrecent_cb;
2516 app.ui.cb_recent_audio = (GCallback) gui_main_menu_audio_openrecent;
2517 app.ui.cb_recent_videos = (GCallback) gui_main_menu_video_openrecent;
2518
2519 gui_main_recent_list_update(app.ui.menu.script.open_recent,
2520 app.ui.list_recent_scripts, app.ui.cb_recent_scripts);
2521
2522 gui_main_recent_list_update(app.ui.menu.script.open_recent_workspace,
2523 app.ui.list_recent_workspaces, app.ui.cb_recent_workspaces);
2524
2525 gui_main_recent_list_update(app.ui.menu.audio.open_recent,
2526 app.ui.list_recent_audio, app.ui.cb_recent_audio);
2527
2528 gui_main_recent_list_update(app.ui.menu.video.open_recent,
2529 app.ui.list_recent_videos, app.ui.cb_recent_videos);
2530
2531 }
2532
2533 GtkWidget *text_editor = gui_main_create_text_editor();
2534 GtkWidget *event_editor = gui_main_create_event_editor();
2535 g_object_ref(text_editor);
2536
2537
2538 app.ui.wave_pane = GTK_PANED(gtk_vpaned_new());
2539 g_signal_connect(app.ui.wave_pane, "notify::position", G_CALLBACK(gui_main_paned_move_cb), notebook);
2540
2541 g_object_ref(vbox_event_edit);
2542
2543 app.ui.hbox_list = GTK_HBOX(gtk_hbox_new(FALSE, 0));
2544 app.ui.hbox_wave = GTK_HBOX(gtk_hbox_new(FALSE, 0));
2545 app.ui.event_editor = event_editor;
2546
2547 gtk_box_pack_start(GTK_BOX(hbox_table), GTK_WIDGET(event_editor), FALSE, FALSE, 0);
2548
2549 gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(hbox_table));
2550 gtk_box_pack_start(GTK_BOX(vbox_event_edit), GTK_WIDGET(frame), FALSE, TRUE, 0);
2551 gtk_box_pack_start(GTK_BOX(vbox_event_edit), text_editor, TRUE, TRUE, 0);
2552
2553 {
2554 app.ui.vbox_waves = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2555 app.ui.waveform_group = KRY_WAVEFORM_GROUP(kry_waveform_group_new());
2556 app.ui.region_list = KRY_REGION_FIXED_LIST(kry_region_fixed_list_new());
2557
2558 kry_waveform_group_set_toolbar(app.ui.waveform_group, GTK_WIDGET(gui_waveforms_create_simple_toolbar()));
2559 kry_waveform_group_set_scrollbar(app.ui.waveform_group, gtk_hscrollbar_new(kry_waveform_group_get_adjustment(app.ui.waveform_group)));
2560
2561 if(!app.opts.advanced_waveform_ui)
2562 kry_waveform_group_enable_simple_interface(app.ui.waveform_group);
2563
2564 gtk_box_pack_start(GTK_BOX(app.ui.vbox_waves), GTK_WIDGET(app.ui.waveform_group), TRUE, TRUE, 0);
2565
2566 kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_event_start);
2567 kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_event_end);
2568 kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_current);
2569 kry_waveform_group_marker_set_active_start(app.ui.waveform_group, app.ui.marker_event_start);
2570 kry_waveform_group_marker_set_active_end(app.ui.waveform_group, app.ui.marker_event_end);
2571 kry_waveform_group_region_add_new(app.ui.waveform_group, app.ui.marker_event_start, app.ui.marker_event_end, WAVEFORM_COLOR_SELECTION_HIGHLIGHT);
2572 kry_waveform_group_region_fixed_list_set(app.ui.waveform_group, app.ui.region_list);
2573 kry_waveform_group_set_drag_selection(app.ui.waveform_group, app.opts.enable_drag_selection);
2574 kry_waveform_group_set_marker_dragging(app.ui.waveform_group, app.opts.enable_marker_dragging);
2575
2576 }
2577
2578 gtk_container_add(GTK_CONTAINER(app.ui.window), GTK_WIDGET(vbox_super));
2579
2580 GtkWidget *tab_video = gui_main_tab_video_create();
2581 app.ui.event_list = gui_event_list_new(FALSE);
2582
2583 gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(gui_event_list_get_view(app.ui.event_list)));
2584 app.ui.vbox_sub_wave = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2585 gtk_box_pack_start(GTK_BOX(app.ui.vbox_sub_wave), GTK_WIDGET(app.ui.vbox_waves), TRUE, TRUE, 0);
2586 gtk_box_pack_start(GTK_BOX(app.ui.hbox_wave), GTK_WIDGET(app.ui.vbox_sub_wave), TRUE, TRUE, 0);
2587
2588 gtk_box_pack_start(GTK_BOX(timing_box), GTK_WIDGET(vbox_text), FALSE, TRUE, 0);
2589 gtk_box_pack_start(GTK_BOX(timing_box), GTK_WIDGET(app.ui.hbox_wave), TRUE, TRUE, 0);
2590
2591 app.ui.vbox_list_super = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2592 gtk_paned_add1(paned_list, GTK_WIDGET(vbox_event_edit));
2593
2594 app.ui.vbox_sub_list = GTK_VBOX(gtk_vbox_new(FALSE, 0));
2595 gtk_box_pack_start(GTK_BOX(app.ui.vbox_sub_list), GTK_WIDGET(sw), TRUE, TRUE, 0);
2596 gtk_box_pack_start(GTK_BOX(app.ui.hbox_list), GTK_WIDGET(app.ui.vbox_sub_list), TRUE, TRUE, 0);
2597 gtk_paned_add2(paned_list, GTK_WIDGET(app.ui.hbox_list));
2598
2599 app.ui.tab_audio_widget = GTK_WIDGET(timing_box);
2600 app.ui.tab_video_widget = GTK_WIDGET(tab_video);
2601
2602 app.ui.tab_audio_label = GTK_LABEL(gtk_label_new(__("Tab|Audio")));
2603 app.ui.tab_video_label = GTK_LABEL(gtk_label_new(__("Tab|Video")));
2604
2605 gtk_notebook_append_page(notebook, GTK_WIDGET(timing_box), GTK_WIDGET(app.ui.tab_audio_label));
2606 gtk_notebook_append_page(notebook, tab_video, GTK_WIDGET(app.ui.tab_video_label));
2607
2608 // setup the status/progress "tab"
2609 {
2610 struct KryStatusBar *bar = gui_status_bar_new();
2611 app.ui.status_bar = bar;
2612
2613 GtkWidget *widget = gui_status_bar_get_widget(bar);
2614 page_progress = GTK_LABEL(gtk_label_new(""));
2615
2616 gtk_notebook_append_page(notebook, GTK_WIDGET(page_progress), widget);
2617 gtk_notebook_set_tab_label_packing(notebook, GTK_WIDGET(page_progress), TRUE, TRUE, GTK_PACK_START);
2618
2619 gui_status_bar_set_text(app.ui.status_bar, STATUS_WELCOME, _("Welcome to Sabbu"));
2620 }
2621
2622 gtk_paned_add2(paned_notebook, GTK_WIDGET(notebook));
2623 gtk_paned_pack1(app.ui.wave_pane, GTK_WIDGET(paned_notebook), FALSE, FALSE);
2624 gtk_paned_pack2(app.ui.wave_pane, GTK_WIDGET(paned_list), TRUE, FALSE);
2625 g_object_ref(vbox_notebook);
2626 g_object_ref(app.ui.vbox_list_super);
2627
2628
2629 gtk_box_pack_start(GTK_BOX(vbox_super), GTK_WIDGET(app.ui.wave_pane), TRUE, TRUE, 0);
2630
2631 gui_main_update_sensitivity();
2632 //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.wave_grab_times), FALSE);
2633
2634 g_signal_connect(app.ui.window, "map", G_CALLBACK(gui_main_play_button_map), gui_status_bar_get_widget(app.ui.status_bar));
2635
2636 gtk_widget_show_all(GTK_WIDGET(app.ui.window));
2637
2638 gui_waveforms_setup(NULL);
2639
2640 {
2641 GtkMenu *menu = GTK_MENU(gtk_menu_new());
2642 #ifdef HAVE_ASPELL
2643 if(spell_is_available())
2644 {
2645 app.ui.speller = spell_create();
2646 GList *list = spell_get_dict_list();
2647 GSList *group = NULL;
2648 char *cur = spell_get_current_dict_name(app.ui.speller);
2649 for(GList *ptr = list; ptr; ptr = ptr->next)
2650 {
2651 char *display = spell_get_dict_name_from_code((char *) ptr->data);
2652 GtkWidget *item = gtk_radio_menu_item_new_with_label(group, display);
2653 group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
2654 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
2655
2656 if(!strcmp(display, cur))
2657 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
2658
2659 g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(gui_main_spellcheck_language_cb), ptr->data);
2660 }
2661
2662 if(!list)
2663 {
2664 GtkWidget *item = gtk_menu_item_new_with_label(_("No Dictionaries Installed"));
2665 gtk_widget_set_sensitive(item, FALSE);
2666 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
2667 }
2668 }
2669 else
2670 {
2671 GtkWidget *item = gtk_menu_item_new_with_label(_("Aspell Not Installed"));
2672 gtk_widget_set_sensitive(item, FALSE);
2673 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
2674 }
2675
2676 gtk_widget_show_all(GTK_WIDGET(menu));
2677 gtk_menu_item_set_submenu(app.ui.menu.event.spellcheck_language, GTK_WIDGET(menu));
2678 #else
2679 GtkWidget *item = gtk_menu_item_new_with_label(_("Aspell Not Enabled"));
2680 gtk_widget_set_sensitive(item, FALSE);
2681 gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
2682
2683 gtk_widget_show_all(GTK_WIDGET(menu));
2684 gtk_menu_item_set_submenu(app.ui.menu.event.spellcheck_language, GTK_WIDGET(menu));
2685 #endif
2686 }
2687
2688 gui_main_load_color_table(app.ui.waveform_color_table);
2689 gui_main_load_color_table(app.ui.list_color_table);
2690 gui_main_load_color_table(app.ui.status_bar_color_table);
2691 gui_main_load_color_table(app.ui.highlight_color_table);
2692
2693 kry_marker_set_value(app.ui.marker_event_start, -1);
2694 kry_marker_set_value(app.ui.marker_event_end, -1);
2695
2696 gtk_toggle_button_set_active(app.ui.tab_video.button_hide, FALSE);
2697
2698 app.ui.ui_mode = UI_MODE_NONE;
2699
2700 delete app.script;
2701 appObj->ScriptNew();
2702
2703 gui_options_load();
2704
2705 gtk_widget_hide(GTK_WIDGET(app.ui.hbox_hide_channels));
2706 gtk_widget_hide(kry_waveform_group_get_scrollbar(app.ui.waveform_group));
2707 gtk_widget_hide(kry_waveform_group_get_toolbar(app.ui.waveform_group));
2708
2709 gtk_paned_set_position(app.ui.wave_pane, 0);
2710
2711 gtk_widget_hide(GTK_WIDGET(app.ui.hbox_karaoke));
2712 gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_vbox_toolbar));
2713 gui_status_bar_hide_progress_bar(app.ui.status_bar);
2714
2715 g_signal_connect(notebook, "switch-page", G_CALLBACK(gui_main_notebook_page_changed), NULL);
2716 g_signal_connect(notebook, "button-press-event", G_CALLBACK(gui_main_notebook_button_press_cb), NULL);
2717
2718 if(app.opts.two_button_mode)
2719 {
2720 gtk_widget_hide(GTK_WIDGET(app.ui.hbox_start_1));
2721 gtk_widget_hide(GTK_WIDGET(app.ui.hbox_end_1));
2722 }
2723
2724 GtkWidget *syntax_widget = gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor);
2725
2726 int min_height = GTK_WIDGET(frame)->allocation.height + 40;
2727 int pos = app.prefs->GetInt("TextEditorPanedPos", -1);
2728
2729 g_object_set_data(G_OBJECT(paned_notebook), "sabbu-min-size", (gpointer) min_height);
2730 g_object_set_data(G_OBJECT(paned_list), "sabbu-min-size", (gpointer) min_height);
2731
2732 if(pos == -1)
2733 {
2734 if(app.opts.text_editor_top)
2735 gtk_paned_set_position(paned_notebook, min_height);
2736 else
2737 gtk_paned_set_position(paned_list, min_height);
2738
2739 }
2740 else
2741 {
2742 if(app.opts.text_editor_top)
2743 gtk_paned_set_position(paned_notebook, pos);
2744 else
2745 gtk_paned_set_position(paned_list, pos);
2746 }
2747
2748 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.script.save_workspace_as), FALSE);
2749 gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.script.close_workspace), FALSE);
2750
2751 g_signal_connect(app.ui.paned_list, "notify::position", G_CALLBACK(gui_main_text_paned_move_cb), NULL);
2752 g_signal_connect(app.ui.paned_notebook, "notify::position", G_CALLBACK(gui_main_text_paned_move_cb), NULL);
2753
2754 g_timeout_add(1000*60*5, gui_main_script_autosave, NULL);
2755 //g_timeout_add(250*60, gui_main_script_autosave, NULL);
2756
2757 g_signal_connect(gui_event_list_get_view(app.ui.event_list), "key-press-event", G_CALLBACK(gui_main_key_press), NULL);
2758 }
2759
2760