/* * Copyright (C) 2004-2005 Vadim Berezniker * http://www.kryptolus.com * * This Program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This Program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GNU Make; see the file COPYING. If not, write to * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * http://www.gnu.org/copyleft/gpl.html * */ #include "stdafx.h" #include "common.h" #include "sabbu.h" #include "kryArray.h" #include "kryString.h" #include "krySSACommandParser.h" #include "krySSACommandHighlighter.h" #include "sound.h" #include "gui_properties.h" #include "gui_options.h" #include "gui_workspace.h" #include "gui_waveforms.h" #include "gui_event_list.h" #include "gui_menu.h" #include "gui_main_help.h" #include "gui_main_script.h" #include "gui_main_video.h" #include "gui_main_event.h" #include "gui_main_karaoke.h" #include "gui_main_navigation.h" #include "gui_main_tool.h" #include "gui_main_tab_video.h" #include "gui_text_editor.h" #include "gui_main_fontsel.h" #include "gui_status_bar.h" #include "gui_time_entry.h" #include "spell.h" #include "resource.h" #include "stringutils.h" extern struct sabbu app; extern krySabbu *appObj; void gui_main_set_ui_mode(enum ui_mode ui_mode) { if(app.ui.ui_mode == ui_mode) return; app.ui.ui_mode = ui_mode; gui_event_list_update_visible_columns(app.ui.event_list, ui_mode); if(app.ui.ui_mode == UI_MODE_SSA) { gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_font_underline)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_font_strikethrough)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.frame_style_font)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_outline)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_outline)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_tertiary)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_tertiary)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_shadow)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_shadow)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_back)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_back)); kryColor *back = app.ui.style_color_table->Get(TAB_VIDEO_COLOR_BACK); kryColor *outline = app.ui.style_color_table->Get(TAB_VIDEO_COLOR_OUTLINE); back->SetColor(outline->GetRed(), outline->GetGreen(), outline->GetBlue()); back->SetAlpha(outline->GetAlpha()); gtk_widget_show(GTK_WIDGET(app.ui.label_style)); gtk_widget_show(GTK_WIDGET(app.ui.combo_style)); gtk_widget_show(GTK_WIDGET(app.ui.label_name)); gtk_widget_show(GTK_WIDGET(app.ui.combo_name)); gtk_widget_hide(GTK_WIDGET(app.ui.label_layer)); gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer)); gtk_widget_show(GTK_WIDGET(app.ui.karaoke_hbox_switch)); gtk_widget_show(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor)); if(gtk_notebook_get_current_page(app.ui.notebook) == NOTEBOOK_PAGE_VIDEO) gtk_widget_show(GTK_WIDGET(app.ui.tab_video.vbox_notebook)); gtk_widget_show(GTK_WIDGET(app.ui.tab_video.button_hide)); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), TRUE); //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), TRUE); kry_marker_set_multiple(app.ui.marker_event_start, 10); kry_marker_set_multiple(app.ui.marker_event_end, 10); } else if(app.ui.ui_mode == UI_MODE_ASS) { gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_font_underline)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_font_strikethrough)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.frame_style_font)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_outline)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_outline)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_tertiary)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_tertiary)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.label_shadow)); gtk_widget_show(GTK_WIDGET(app.ui.style_editor.button_shadow)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.label_back)); gtk_widget_hide(GTK_WIDGET(app.ui.style_editor.button_back)); gtk_widget_show(GTK_WIDGET(app.ui.label_style)); gtk_widget_show(GTK_WIDGET(app.ui.combo_style)); gtk_widget_show(GTK_WIDGET(app.ui.label_name)); gtk_widget_show(GTK_WIDGET(app.ui.combo_name)); gtk_widget_show(GTK_WIDGET(app.ui.label_layer)); gtk_widget_show(GTK_WIDGET(app.ui.spin_layer)); gtk_widget_show(GTK_WIDGET(app.ui.karaoke_hbox_switch)); gtk_widget_show(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor)); if(gtk_notebook_get_current_page(app.ui.notebook) == NOTEBOOK_PAGE_VIDEO) gtk_widget_show(GTK_WIDGET(app.ui.tab_video.vbox_notebook)); gtk_widget_show(GTK_WIDGET(app.ui.tab_video.button_hide)); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), TRUE); //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), TRUE); kry_marker_set_multiple(app.ui.marker_event_start, 10); kry_marker_set_multiple(app.ui.marker_event_end, 10); } else if(ui_mode == UI_MODE_SRT) { gtk_widget_hide(GTK_WIDGET(app.ui.label_style)); gtk_widget_hide(GTK_WIDGET(app.ui.combo_style)); gtk_widget_hide(GTK_WIDGET(app.ui.label_name)); gtk_widget_hide(GTK_WIDGET(app.ui.combo_name)); gtk_widget_hide(GTK_WIDGET(app.ui.label_layer)); gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer)); gui_text_editor_set_syntax_highlight_mode(app.ui.text_editor, SYNTAX_HIGHLIGHT_NONE); gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_hbox_switch)); gtk_widget_hide(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor)); //gtk_widget_hide(GTK_WIDGET(app.ui.vbox_sw gtk_widget_hide(GTK_WIDGET(app.ui.tab_video.vbox_notebook)); gtk_widget_hide(GTK_WIDGET(app.ui.tab_video.button_hide)); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.type), FALSE); //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.karaoke.me), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), FALSE); kry_marker_set_multiple(app.ui.marker_event_start, 1); kry_marker_set_multiple(app.ui.marker_event_end, 1); } else if(ui_mode == UI_MODE_KARAOKE) { gtk_widget_hide(GTK_WIDGET(app.ui.label_style)); gtk_widget_hide(GTK_WIDGET(app.ui.combo_style)); gtk_widget_hide(GTK_WIDGET(app.ui.label_name)); gtk_widget_hide(GTK_WIDGET(app.ui.combo_name)); gtk_widget_hide(GTK_WIDGET(app.ui.label_layer)); gtk_widget_hide(GTK_WIDGET(app.ui.spin_layer)); gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_hbox_switch)); gtk_widget_hide(gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor)); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_above), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.event.add_separator_below), FALSE); } gui_main_notebook_page_changed(app.ui.notebook, NULL, (notebook_page) gtk_notebook_get_current_page(app.ui.notebook), NULL); } double gui_spin_button_get_value(GtkSpinButton *button) { double val = gtk_spin_button_get_value(button); if(val > -0.0000001 && val < 0.0000001) return 0; return (val + (val > 0 ? 0.0000001 : -0.0000001)); } void gui_main_sync_point_set(GtkWidget *widget, int action, gpointer data) { KryMarker *marker = app.ui.marker_event_start; if(kry_marker_get_value(marker) == -1) { gui_warning(_("Please set the start time before trying to place a sync point")); return; } char *time = time_mili_to_string(kry_marker_get_value(marker)); app.script->SetProperty("Sync Point Time", time); app.script->SetModifiedFlag(TRUE); } void gui_main_sync_event_to_wave(GtkWidget *widget, int action, gpointer data) { KryMarker *marker = app.ui.marker_event_start; if(kry_marker_get_value(marker) == -1) { gui_warning(_("Please select the time to which the selected event will be synced to")); return; } GtkTreeModel *model; GtkTreeSelection *selection = gui_event_list_get_selection(app.ui.event_list); GList *children = gtk_tree_selection_get_selected_rows(selection, &model); if(!children) { gui_warning(_("Please select the event you wish to sync")); return; } kryEvent *event; GtkTreeIter iter; GtkTreePath *path = (GtkTreePath *) children->data; gtk_tree_model_get_iter(model, &iter, path); gtk_tree_model_get(model, &iter, PTR_COLUMN, &event, -1); g_list_foreach(children, (GFunc) gtk_tree_path_free, NULL); g_list_free(children); if(event->GetType() != kryEvent::EVENT_DIALOG) { gui_warning(_("The event being synced must be a Dialog line")); return; } long time_wave = kry_marker_get_value(marker); long time_event = event->GetStart(); long time_diff; gboolean backward; if(time_wave > time_event) { time_diff = time_wave - time_event; backward = FALSE; } else { time_diff = time_event - time_wave; backward = TRUE; } gui_shift_times_show_custom(time_diff, backward ? SHIFT_BACKWARD : SHIFT_FORWARD, SHIFT_ALL); } void gui_main_sync_point_sync(GtkWidget *widget, int action, gpointer data) { gboolean backward = FALSE; KryMarker *marker = app.ui.marker_event_start; long time_cur = kry_marker_get_value(marker); if(kry_marker_get_value(marker) == -1) { gui_warning(_("Please set the start time where the two scripts will be synchronized")); return; } kryScript *script = gui_main_script_open(); if(!script) return; char *val = script->GetProperty("Sync Point Time"); if(!val) { gui_warning(_("The specified script does not contain a sync point")); delete script; return; } long time_file = time_string_to_mili(val, -1); if(time_file == -1) { gui_warning(_("The specified script contains an invalid sync point")); delete script; return; } delete script; long time_diff; if(time_file > time_cur) { time_diff = time_file - time_cur; backward = FALSE; } else { time_diff = time_cur - time_file; backward = TRUE; } gui_shift_times_show_custom(time_diff, backward ? SHIFT_BACKWARD : SHIFT_FORWARD, SHIFT_ALL); } void gui_main_focus_on_wave() { GList *list = kry_waveform_group_waveform_get_list(app.ui.waveform_group); if(!list) return; KryWaveformGroupItem *item = KRY_WAVEFORM_GROUP_ITEM(list->data); gtk_widget_grab_focus(GTK_WIDGET(kry_waveform_group_item_get_waveform(item))); } void gui_main_set_time_modified(gboolean val) { app.ui.time_modified = val; if(val) { GdkColor red; red.red = 257*255; red.green = 257*64; red.blue = 257*64; red.pixel = 0; gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, &red); gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_end), GTK_STATE_NORMAL, &red); } else { gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, NULL); gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_end), GTK_STATE_NORMAL, NULL); } } void gui_main_play_button_map(GtkWidget *widget, GtkWidget *target) { if(app.ui.color_bg.red || app.ui.color_bg.green || app.ui.color_bg.blue || app.ui.color_bg.pixel) return; GdkPixbuf *pixbuf = gdk_pixbuf_get_from_drawable(NULL, target->window, NULL, 0, 0, 0, 0, 5, 5); if(!pixbuf) return; guchar *pixels = gdk_pixbuf_get_pixels (pixbuf); guchar red = pixels[0]; guchar green = pixels[1]; guchar blue = pixels[2]; app.ui.color_bg.red = red * 257; app.ui.color_bg.green = green * 257; app.ui.color_bg.blue = blue * 257; app.ui.color_bg.pixel = 0; g_object_unref(pixbuf); } int gui_main_select_font(struct fontsel_info * fontsel_info) { int rv; gui_main_disable(); KryFontSelectionDialog *dialog = KRY_FONT_SELECTION_DIALOG(kry_font_selection_dialog_new(__("FontSelectionDialogTitle|Style Font"), fontsel_info)); gtk_window_set_transient_for(GTK_WINDOW(dialog), app.ui.window); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); rv = gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(GTK_WIDGET(dialog)); gui_main_enable(); if(rv == GTK_RESPONSE_OK) return TRUE; else return FALSE; } void gui_main_check_theme() { #ifdef _WINDOWS int show_first_time_warning = app.prefs->GetInt("ShowFirstRunWarning", 1); app.prefs->SetInt("ShowFirstRunWarning", 0); if(show_first_time_warning) { while(gtk_events_pending()) gtk_main_iteration(); HWND wnd = HWND(GDK_WINDOW_HWND(GTK_WIDGET(app.ui.window)->window)); 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); gunichar2 *title = g_utf8_to_utf16(_("First Run Notice"), -1, NULL, NULL, NULL); MessageBoxW(wnd, msg, title, MB_OK | MB_ICONWARNING); g_free(msg); g_free(title); } if(gtk_major_version <= 2 && gtk_minor_version <= 6 && gtk_micro_version < 8) { while(gtk_events_pending()) gtk_main_iteration(); app.prefs->SetInt("GTKCheckPre2.6.8", 0); HWND wnd = HWND(GDK_WINDOW_HWND(GTK_WIDGET(app.ui.window)->window)); 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); gunichar2 *title = g_utf8_to_utf16(_("GTK Version Notice"), -1, NULL, NULL, NULL); MessageBoxW(wnd, msg, title, MB_OK | MB_ICONWARNING); g_free(msg); g_free(title); exit(0); } #endif } void gui_main_save_window_state() { if(gdk_window_get_state(GTK_WIDGET(app.ui.window)->window) & GDK_WINDOW_STATE_MAXIMIZED) { app.prefs->SetInt("StartMaximized", 1); return; } app.prefs->SetInt("StartMaximized", 0); int width, height; gdk_drawable_get_size(GDK_DRAWABLE(GTK_WIDGET(app.ui.window)->window), &width, &height); app.prefs->SetInt("WindowMainWidth", width); app.prefs->SetInt("WindowMainHeight", height); int x, y; gtk_window_get_position(app.ui.window, &x, &y); app.prefs->SetInt("WindowMainX", x); app.prefs->SetInt("WindowMainY", y); } gboolean gui_main_cb_configure(GtkWidget *widget, GdkEventConfigure *event, gpointer data) { gui_main_save_window_state(); return FALSE; } void gui_main_error_sound() { #ifdef _WINDOWS MessageBeep(MB_ICONASTERISK); #endif } void gui_main_marker_changed_cb(KryMarker *marker, long old_position) { long miliseconds; long start, end; char *str; long mili_val = kry_marker_get_value(marker); if(mili_val < 0) mili_val = 0; str = time_mili_to_string(mili_val, app.ui.ui_mode == UI_MODE_SRT); if(marker == app.ui.marker_active_start) gui_time_entry_set_text(app.ui.time_start, str); else if(marker == app.ui.marker_active_end) gui_time_entry_set_text(app.ui.time_end, str); kry_free(str); start = kry_marker_get_value(app.ui.marker_active_start); end = kry_marker_get_value(app.ui.marker_active_end); if(start != -1 && end != -1 && start <= end) miliseconds = end - start; else miliseconds = 0; str = time_mili_to_string(miliseconds, app.ui.ui_mode == UI_MODE_SRT); gui_time_entry_set_text(app.ui.time_dur, str); kry_free(str); if((marker == app.ui.marker_active_start || marker == app.ui.marker_active_end) && kry_marker_get_value(marker) != old_position) gui_main_set_time_modified(TRUE); } void gui_main_marker_start_move(GdkEventButton *event, int amount) { long newVal; if(app.ui.video_drawing) return; if(event->state & GDK_CONTROL_MASK && (amount == 100 || amount == -100)) amount /= 10; newVal = kry_marker_get_value(app.ui.marker_active_start) + amount; if(newVal < 0) newVal = 0; kry_marker_set_value(app.ui.marker_active_start, newVal); gui_main_focus_on_wave(); } void gui_main_marker_end_move(GdkEventButton *event, int amount) { long newVal; if(app.ui.video_drawing) return; if(event->state & GDK_CONTROL_MASK && (amount == 100 || amount == -100)) amount /= 10; newVal = kry_marker_get_value(app.ui.marker_active_end) + amount; if(newVal < 0) newVal = 0; kry_marker_set_value(app.ui.marker_active_end, newVal); gui_main_focus_on_wave(); } /* * Updates widget sensitivity states based on the state of the application. */ void gui_main_update_sensitivity() { if(app.ui.sound_info == NULL) { gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.close), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.save_selection_as_wav), FALSE); } else { gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.close), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.audio.save_selection_as_wav), TRUE); } if(app.ui.tab_video.video == NULL) gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.video.close), FALSE); else gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.video.close), TRUE); } int gui_warning_internal(GtkWindow *parent, char *format, va_list list, GtkMessageType type, int buttons) { int rv; GtkDialog *dialog; char *str; gboolean disabled = !gui_main_is_enabled(); if(app.ui.window) gui_main_disable(); if(parent && parent != app.ui.window) gtk_widget_set_sensitive(GTK_WIDGET(parent), FALSE); str = kry_strdup_vprintf(format, list); dialog = GTK_DIALOG(gtk_message_dialog_new(parent, GTK_DIALOG_DESTROY_WITH_PARENT, type, (GtkButtonsType) buttons, str)); rv = gtk_dialog_run(dialog); gtk_widget_destroy(GTK_WIDGET(dialog)); kry_free(str); if(parent) { gtk_window_present(parent); if(parent == app.ui.window) gui_main_focus_on_wave(); } if(app.ui.window && !disabled) gui_main_enable(); if(parent && parent != app.ui.window) gtk_widget_set_sensitive(GTK_WIDGET(parent), TRUE); return rv; } gboolean gui_warning_yes_no(char *format, ...) { gboolean rv; va_list list; va_start(list, format); if(gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_WARNING, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES) rv = TRUE; else rv = FALSE; va_end(list); return rv; } gboolean gui_question_yes_no(GtkWindow *parent, char *format, ...) { gboolean rv; va_list list; va_start(list, format); if(gui_warning_internal(parent, format, list, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES) rv = TRUE; else rv = FALSE; va_end(list); return rv; } gboolean gui_question_yes_no(char *format, ...) { gboolean rv; va_list list; va_start(list, format); if(gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO) == GTK_RESPONSE_YES) rv = TRUE; else rv = FALSE; va_end(list); return rv; } void gui_warning(char *format, ...) { va_list list; va_start(list, format); gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK); va_end(list); } void gui_error(char *format, ...) { va_list list; va_start(list, format); gui_warning_internal(app.ui.window, format, list, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK); va_end(list); } void gui_error(GtkWindow *parent, char *format, ...) { va_list list; va_start(list, format); gui_warning_internal(parent, format, list, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK); va_end(list); } gboolean gui_main_cb_delete(GtkWidget *widget, GdkEvent *event, gpointer data) { gui_main_save_window_state(); kry_recent_list_save(app.ui.list_recent_scripts, "Recent File"); kry_recent_list_save(app.ui.list_recent_workspaces, "Recent Workspace"); kry_recent_list_save(app.ui.list_recent_audio, "Recent Audio"); kry_recent_list_save(app.ui.list_recent_videos, "Recent Video"); if(app.ui.pane_video_pos) app.prefs->SetInt("PanePositionVideoB", app.ui.pane_video_pos); app.prefs->SetInt("SearchMatchCase", app.gui_find_replace_options.match_case); app.prefs->SetInt("SearchMatchWholeWord", app.gui_find_replace_options.match_wholeword); app.prefs->SetInt("SearchMatchSearchUp", app.gui_find_replace_options.search_up); app.prefs->SetInt("SearchMatchSearchText", app.gui_find_replace_options.search_text); app.prefs->SetInt("SearchMatchSearchStyle", app.gui_find_replace_options.search_style); app.prefs->SetInt("SearchMatchSearchName", app.gui_find_replace_options.search_name); kry_recent_list_save(app.gui_find_replace_options.target_history, "SearchHistory"); if(!app.prefs->Save()) { if(!gui_warning_yes_no(_("Error saving preferences.\n\nWould you like to quit anyway?"))) return TRUE; } if(app.script && app.script->GetModifiedFlag()) if(!gui_main_script_save(FALSE, TRUE, FALSE)) return TRUE; if(app.workspace && !gui_workspace_save(app.workspace)) if(!gui_warning_yes_no(_("Error saving current workspace.\n\nWould you like to quit anyway?"))) return TRUE; if(app.script) { app.script->SetModifiedFlag(FALSE); if(!appObj->ScriptClose()) return TRUE; } gui_status_bar_text_only_mode(app.ui.status_bar); gui_waveforms_destroy(); if(app.workspace) kry_free(app.workspace); #ifdef HAVE_ASPELL if(app.ui.speller) spell_destroy(app.ui.speller); #endif gtk_main_quit(); // yeah.. save again... app.prefs->Save(); sabbu_exit(); return FALSE; } void gui_main_title_update() { char *title; char *filename; char *workspace; char *flags; char *encoding = ""; char *format = ""; if(app.script->GetFilename() == NULL) filename = kry_strdup(_("Untitled")); else filename = KRY_TS(g_path_get_basename(app.script->GetFilename())); if(!app.workspace) { workspace = kry_strdup(""); } else { char *base = KRY_TS(g_path_get_basename(app.workspace)); workspace = kry_strdup_printf(KRY_LOC " (%s)", base); kry_free(base); } if(app.script->GetEncoding() == ENCODING_UTF8) encoding = " UTF8"; else if(app.script->GetEncoding() == ENCODING_UTF16) encoding = " UTF16"; if(app.script->GetType() == KRY_FORMAT_SSA) format = "SSA"; else if(app.script->GetType() == KRY_FORMAT_ASS) format = "ASS"; else if(app.script->GetType() == KRY_FORMAT_SRT) format = "SRT"; flags = kry_strdup_printf(KRY_LOC "%s%s", format, encoding); title = kry_strdup_printf(KRY_LOC "Sabbu (%s) - %s (%s)%s", app.version, filename, flags, workspace); gtk_window_set_title(GTK_WINDOW(app.ui.window), title); #ifdef _WINDOWS gunichar2 *title_utf16 = g_utf8_to_utf16(title, -1, NULL, NULL, NULL); HWND wnd = (HWND) GDK_WINDOW_HWND (GTK_WIDGET(app.ui.window)->window); SetWindowTextW(wnd, title_utf16); g_free(title_utf16); #endif kry_free(flags); kry_free(title); kry_free(filename); kry_free(workspace); } void gui_main_waveform_toolbar_advanced(struct waveform_info *info) { gtk_widget_show(GTK_WIDGET(info->button_mute)); gtk_widget_show(GTK_WIDGET(info->frame_name)); gtk_widget_show(GTK_WIDGET(info->button_hide)); gtk_widget_show(GTK_WIDGET(info->button_set_name)); gtk_widget_show(GTK_WIDGET(info->button_clone)); gtk_widget_show(GTK_WIDGET(info->sep1)); //gtk_widget_show(GTK_WIDGET(info->sep2)); gtk_widget_show(GTK_WIDGET(info->sep3)); } GtkWidget *gui_main_create_control_toolbar(control_widget_type type) { GtkButton *button_play_start = GTK_BUTTON(gtk_button_new()); if(type == CONTROLS_VBOX || type == CONTROLS_TABLE) gtk_container_add(GTK_CONTAINER(button_play_start), gtk_image_new_from_pixbuf(app.ui.pixbufs.play)); else gtk_container_add(GTK_CONTAINER(button_play_start), gtk_label_new(_("Play"))); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_start), _("Play"), NULL); g_signal_connect(G_OBJECT(button_play_start), "clicked", G_CALLBACK(gui_main_menu_audio_play_start), NULL); GtkButton *button_play_stop = GTK_BUTTON(gtk_button_new()); if(type == CONTROLS_VBOX || type == CONTROLS_TABLE) gtk_container_add(GTK_CONTAINER(button_play_stop), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_stop)); else gtk_container_add(GTK_CONTAINER(button_play_stop), gtk_label_new(_("Stop"))); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_stop), _("Stop"), NULL); g_signal_connect(G_OBJECT(button_play_stop), "clicked", G_CALLBACK(gui_main_menu_audio_stop), NULL); GtkButton *button_play_selection = GTK_BUTTON(gtk_button_new()); if(type == CONTROLS_VBOX || type == CONTROLS_TABLE) gtk_container_add(GTK_CONTAINER(button_play_selection), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_selection)); else gtk_container_add(GTK_CONTAINER(button_play_selection), gtk_label_new(_("Play Selection"))); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_selection), _("Play Selection"), NULL); g_signal_connect(G_OBJECT(button_play_selection), "clicked", G_CALLBACK(gui_main_play_selected), NULL); GtkButton *button_play_last = GTK_BUTTON(gtk_button_new()); if(type == CONTROLS_VBOX || type == CONTROLS_TABLE) gtk_container_add(GTK_CONTAINER(button_play_last), gtk_image_new_from_pixbuf(app.ui.pixbufs.play_last)); else gtk_container_add(GTK_CONTAINER(button_play_last), gtk_label_new(_("Play Last 0.5 seconds"))); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_play_last), _("Play Last 0.5 seconds"), NULL); g_signal_connect(G_OBJECT(button_play_last), "clicked", G_CALLBACK(gui_main_menu_audio_play_last), NULL); GtkButton *button_grab_times = GTK_BUTTON(gtk_button_new()); if(type == CONTROLS_VBOX || type == CONTROLS_TABLE) gtk_container_add(GTK_CONTAINER(button_grab_times), gtk_image_new_from_pixbuf(app.ui.pixbufs.grab_times)); else gtk_container_add(GTK_CONTAINER(button_grab_times), gtk_label_new(_("Grab Times"))); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_grab_times), _("Grab Times"), NULL); g_signal_connect(G_OBJECT(button_grab_times), "clicked", G_CALLBACK(gui_main_grab_times_cb), (gpointer) TRUE); gtk_button_set_relief(button_play_start, GTK_RELIEF_NONE); gtk_button_set_relief(button_play_stop, GTK_RELIEF_NONE); gtk_button_set_relief(button_play_selection, GTK_RELIEF_NONE); gtk_button_set_relief(button_play_last, GTK_RELIEF_NONE); gtk_button_set_relief(button_grab_times, GTK_RELIEF_NONE); if(type == CONTROLS_TABLE) { GtkTable *table = GTK_TABLE(gtk_table_new(4, 2, FALSE)); gtk_table_attach(table, GTK_WIDGET(button_play_start), 0, 1, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(table, GTK_WIDGET(button_play_selection), 1, 2, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(table, GTK_WIDGET(button_play_last), 2, 3, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(table, GTK_WIDGET(button_play_stop), 3, 4, 0, 1, GTK_FILL, GTK_EXPAND, 0, 0); gtk_table_attach(table, GTK_WIDGET(button_grab_times), 0, 1, 1, 2, GTK_FILL, GTK_EXPAND, 0, 0); return GTK_WIDGET(table); } else { GtkBox *box; if(type == CONTROLS_VBOX) box = GTK_BOX(gtk_vbox_new(FALSE, 0)); else box = GTK_BOX(gtk_hbox_new(FALSE, 0)); gtk_box_pack_start(box, GTK_WIDGET(button_play_start), FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(button_play_selection), FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(button_play_last), FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(button_play_stop), FALSE, TRUE, 0); gtk_box_pack_start(box, GTK_WIDGET(button_grab_times), FALSE, TRUE, 0); return GTK_WIDGET(box); } } void gui_main_advanced_waveform_ui_switch(gboolean val) { if(val) { app.opts.advanced_waveform_ui = TRUE; kry_waveform_group_disable_simple_interface(app.ui.waveform_group); } else { app.opts.advanced_waveform_ui = FALSE; if(app.ui.sound_info) kry_waveform_group_enable_simple_interface(app.ui.waveform_group); } } GtkToolbar *gui_main_create_wave_toolbar(gboolean horizontal) { GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new()); if(horizontal) { gtk_toolbar_set_orientation(toolbar, GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(toolbar, GTK_TOOLBAR_TEXT); } else { gtk_toolbar_set_orientation(toolbar, GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style(toolbar, GTK_TOOLBAR_ICONS); } app.ui.tool_play_start = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play"), __("WaveToolbarTooltip|Play"), NULL, gtk_image_new_from_stock("sabbu-play", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_start), NULL)); app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.tool_play_start); g_signal_connect(app.ui.tool_play_start, "key-press-event", G_CALLBACK(gui_main_key_press), NULL); app.ui.tool_play_stop = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Stop"), __("WaveToolbarTooltip|Stop"), NULL, gtk_image_new_from_stock("sabbu-stop", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_start), NULL)); app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.tool_play_stop); gtk_widget_hide(GTK_WIDGET(app.ui.tool_play_stop)); app.ui.wave_play_selected = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play Selection"), __("WaveToolbarTooltip|Play Selection"), NULL, gtk_image_new_from_stock("sabbu-play-selected", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_play_selected), NULL)); app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.wave_play_selected); GtkWidget *widget = gtk_toolbar_append_item(toolbar, __("WaveToolbar|Play Last 0.5s"), __("WaveToolbarTooltip|Play Last 0.5 seconds"), NULL, gtk_image_new_from_stock("sabbu-play-last", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_last), NULL); app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, widget); app.ui.wave_grab_times = GTK_BUTTON(gtk_toolbar_append_item(toolbar, __("WaveToolbar|Grab Times"), __("WaveToolbarTooltip|Grab Times"), NULL, gtk_image_new_from_stock("sabbu-check-mark", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_grab_times_cb), (gpointer) TRUE)); app.ui.list_play_toolbar = g_list_append(app.ui.list_play_toolbar, app.ui.wave_grab_times); gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR); app.ui.play_toolbar = toolbar; return toolbar; } void gui_main_auto_time_select_cb(GtkToggleButton *button, gpointer data) { app.opts.disable_automatic_wave_jump = gtk_toggle_button_get_active(button); app.prefs->SetInt("DisableAutomaticWaveJump", app.opts.disable_automatic_wave_jump); gui_main_focus_on_wave(); } GtkToolbar *gui_main_create_list_toolbar(gboolean horizontal) { GtkToolbar *list_toolbar = GTK_TOOLBAR(gtk_toolbar_new()); if(horizontal) { gtk_toolbar_set_orientation(list_toolbar, GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(list_toolbar, GTK_TOOLBAR_TEXT); } else { gtk_toolbar_set_orientation(list_toolbar, GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style(list_toolbar, GTK_TOOLBAR_ICONS); } gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Previous Row"), __("EventListToolbarTooltip|Play Previous Row"), NULL, gtk_image_new_from_stock("sabbu-play-previous", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_previous_row), NULL); gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Current Row"), __("EventListToolbarTooltip|Play Current Row"), NULL, gtk_image_new_from_stock("sabbu-play-current", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_current_row), NULL); gtk_toolbar_append_item(list_toolbar, __("EventListToolbar|Play Next Row"), __("EventListToolbarTooltip|Play Next Row"), NULL, gtk_image_new_from_stock("sabbu-play-next", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_menu_audio_play_next_row), NULL); gtk_toolbar_append_space(list_toolbar); GtkButton *button_auto_select = GTK_BUTTON(gtk_toggle_button_new_with_label(__("EventListToolbar|DS"))); gtk_button_set_relief(button_auto_select, GTK_RELIEF_NONE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_auto_select), FALSE); g_signal_connect(button_auto_select, "toggled", G_CALLBACK(gui_main_auto_time_select_cb), NULL); 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); gtk_toolbar_set_icon_size(list_toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR); return list_toolbar; } void gui_main_update_pane_position(int page) { if(page != NOTEBOOK_PAGE_VIDEO && app.ui.pane_other_pos) { gtk_paned_set_position(app.ui.wave_pane, app.ui.pane_other_pos); } else { if(app.ui.pane_video_pos) gtk_paned_set_position(app.ui.wave_pane, app.ui.pane_video_pos); } } gboolean gui_main_notebook_button_press_cb(GtkNotebook *notebook, GdkEventButton *button, gpointer data) { if(!GTK_WIDGET_SENSITIVE(app.ui.menu.me)) return TRUE; return FALSE; } void gui_main_notebook_page_changed(GtkNotebook *notebook, GtkNotebookPage *page_unused, enum notebook_page page, gpointer data_unused) { GtkWidget *child1 = gtk_paned_get_child1(app.ui.wave_pane); GtkWidget *child2 = gtk_paned_get_child2(app.ui.wave_pane); g_object_set_data(G_OBJECT(app.ui.wave_pane), "sabbu-signal-ignore", (gpointer) TRUE); if(app.ui.ui_mode == UI_MODE_SSA || app.ui.ui_mode == UI_MODE_ASS) { if(page != NOTEBOOK_PAGE_VIDEO) { GtkWidget *temp = child1; child1 = child2; child2 = temp; gtk_toggle_button_set_active(app.ui.tab_video.button_hide, FALSE); } else { gtk_toggle_button_set_active(app.ui.tab_video.button_hide, TRUE); } } gui_main_update_pane_position(page); g_object_set_data(G_OBJECT(app.ui.wave_pane), "sabbu-signal-ignore", FALSE); g_object_set(G_OBJECT(app.ui.wave_pane), "position-set", TRUE, NULL); gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child1), "resize", TRUE, NULL); gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child1), "shrink", FALSE, NULL); gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child2), "resize", FALSE, NULL); gtk_container_child_set(GTK_CONTAINER(app.ui.wave_pane), GTK_WIDGET(child2), "shrink", FALSE, NULL); gui_main_focus_on_wave(); } void gui_main_entry_style_changed_cb(GtkWidget *widget, gpointer data) { if(app.ui.video_area) gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); char *text = KRY_TS(gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget))); if(strcmp(text, "")) gui_main_layer_style_changed_cb(widget, data); kry_free(text); gui_main_focus_on_wave(); } gboolean gui_main_entry_name_press_cb(GtkWidget *widget, GdkEventKey *event, GtkWidget *combo) { if(event->keyval != GDK_Return) g_object_set_data(G_OBJECT(combo), "user-key-press", (gpointer) 1); return FALSE; } gboolean gui_main_entry_name_release_cb(GtkWidget *widget, GdkEventKey *event, GtkWidget *combo) { g_object_set_data(G_OBJECT(combo), "user-key-press", (gpointer) 0); return FALSE; } void gui_main_entry_name_changed_cb(GtkWidget *widget, GtkComboBox *combo) { if((long) g_object_get_data(G_OBJECT(widget), "user-key-press") == 1) return; if(app.ui.video_area) gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area)); const char *text = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo)))); if(text) gui_main_layer_style_changed_cb(widget, NULL); gui_main_focus_on_wave(); } gboolean gui_main_entry_style_button_release_cb(GtkPaned *paned, GParamSpec *spec, GtkNotebook *notebook) { g_warning("test"); gui_main_focus_on_wave(); return FALSE; } gboolean gui_main_scroll_press(GtkWidget *widget, GdkEvent *event, gpointer button) { if(event->scroll.direction == 0 || event->scroll.direction == 1) { long val = 0; GtkAdjustment *adj = kry_waveform_get_adjustment(KRY_WAVEFORM(widget)); if(event->scroll.direction == 0) val = (int) (gtk_adjustment_get_value(adj) - adj->step_increment); else if(event->scroll.direction == 1) val = (int) (gtk_adjustment_get_value(adj) + adj->step_increment); if(val > adj->upper - adj->page_size) val = (long) (adj->upper - adj->page_size); gtk_adjustment_set_value(adj, val); return TRUE; } return FALSE; } gboolean gui_main_key_press(GtkWidget *widget, GdkEventKey *event, gpointer button) { if(!app.ui.sound_info) return FALSE; if(event->keyval == GDK_g || event->keyval == GDK_G || event->keyval == GDK_KP_Add) { if(app.ui.karaoke_mode != KARAOKE_MODE_OFF) { gui_karaoke_grab_times_cb(NULL, NULL); } else { gui_main_grab_times(GRAB_ADVANCE); } return TRUE; } else if(event->keyval == GDK_s || event->keyval == GDK_S || event->keyval == GDK_Clear) { gui_main_play_selected(NULL, NULL); return TRUE; } else if(event->keyval == GDK_d || event->keyval == GDK_D || event->keyval == GDK_Up) { if(event->state & GDK_CONTROL_MASK) gui_main_menu_audio_play_next(NULL, 0, NULL); else gui_main_menu_audio_play_last(NULL, 0, NULL); return TRUE; } else if(event->keyval == GDK_w || event->keyval == GDK_W) { gui_main_menu_audio_play_start(NULL, 0, NULL); } else if(event->keyval == GDK_e || event->keyval == GDK_E) { gui_main_advance_markers(); } else if(event->keyval == GDK_q || event->keyval == GDK_Q) { gui_main_menu_audio_stop(); } else if(event->keyval == GDK_KP_Multiply) { gui_main_menu_audio_play_previous(NULL, 0, NULL); return TRUE; } else if(event->keyval == GDK_KP_Divide) { kry_waveform_group_focus_selected(app.ui.waveform_group); return TRUE; } else if(event->keyval == GDK_a || event->keyval == GDK_A || event->keyval == GDK_f || event->keyval == GDK_F || event->keyval == GDK_Page_Down || event->keyval == GDK_End) { GtkAdjustment *adj = NULL; int val; if(KRY_IS_WAVEFORM(widget)) adj = kry_waveform_get_adjustment(KRY_WAVEFORM(widget)); else adj = kry_waveform_group_get_adjustment(app.ui.waveform_group); if(event->keyval == GDK_f || event->keyval == GDK_F || event->keyval == GDK_Page_Down) val = (int) (gtk_adjustment_get_value(adj) + adj->step_increment); else val = (int) (gtk_adjustment_get_value(adj) - adj->step_increment); if(val > adj->upper - adj->page_size) val = (long) (adj->upper - adj->page_size); gtk_adjustment_set_value(adj, val); return TRUE; } else if(event->keyval == GDK_Left || event->keyval == GDK_Home || event->keyval == GDK_Right || event->keyval == GDK_Page_Up) { KryMarker *marker = NULL; long mili; int offset; if(event->keyval == GDK_Left || event->keyval == GDK_Right) marker = app.ui.marker_active_start; else marker = app.ui.marker_active_end; if(!marker) return FALSE; if(event->state & GDK_CONTROL_MASK) offset = 100; else offset = 10; mili = kry_marker_get_value(marker); if(mili == -1) mili = 0; if(event->keyval == GDK_Left || event->keyval == GDK_Home) mili -= offset; else if(event->keyval == GDK_Right || event->keyval == GDK_Page_Up) mili += offset; if(mili < 0) mili = 0; kry_marker_set_value(marker, mili); return TRUE; } return FALSE; } int uniq_button_counter = 0; gboolean gui_main_button_press_timer(struct hold_button_callback_info *info) { if(info->released) { info->running--; return FALSE; } if(info->running > 1) { info->running--; return FALSE; } if(GTK_WIDGET_IS_SENSITIVE(info->widget)) info->func(&info->event, info->data); return TRUE; } gboolean gui_main_hold_button_press(GtkWidget *widget, GdkEventButton *event, struct hold_button_callback_info *info) { if(info->released == FALSE && info->running || event->button != 1) return FALSE; info->func(event, info->data); info->released = FALSE; info->running++; info->widget = widget; info->event = *event; info->id = uniq_button_counter++; g_timeout_add(125, (GSourceFunc) gui_main_button_press_timer, info); gui_main_focus_on_wave(); return FALSE; } gboolean gui_main_hold_button_release(GtkWidget *widget, struct hold_button_callback_info *info) { info->released = TRUE; gui_main_focus_on_wave(); return FALSE; } void gui_main_load_color_table(kryColorTable *table) { for(int i = 0; i < table->GetColorCount(); i++) { char *str; kryColor *color = table->Get(i); if(color->IsInitialized() && (str = app.prefs->GetString("Colors", color->GetTextID()))) { int ncolor = atoi(str); color->SetColor(ncolor >> 16, (ncolor >> 8) & 0xFF, ncolor & 0xFF); } } } void gui_main_layer_style_changed_cb(GtkWidget *widget, gpointer data) { if(g_object_get_data(G_OBJECT(gui_event_list_get_view(app.ui.event_list)), "layer-internal-change")) return; GtkTreeModel *model; GtkTreeSelection *selection = gui_event_list_get_selection(app.ui.event_list); GList *sel_items = gtk_tree_selection_get_selected_rows(selection, &model); GtkTreeIter iter; kryEventDetailed *event; for(GList *ptr = sel_items; ptr; ptr = ptr->next) { GtkTreePath *path = (GtkTreePath *) ptr->data; gtk_tree_model_get_iter(model, &iter, path); gtk_tree_model_get(model, &iter, PTR_COLUMN, &event, -1); if(event->GetType() != kryEvent::EVENT_BLANK && event->GetType() != kryEvent::EVENT_COMMENT_STRING && event->GetType() != kryEvent::EVENT_COMMENT_BLANK) { char *cur_style = KRY_TS(gtk_combo_box_get_active_text(app.ui.combo_style)); const char *cur_name = gtk_entry_get_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(app.ui.combo_name)))); if(event->GetLayer() != gtk_spin_button_get_value_as_int(app.ui.spin_layer) || strcmp(event->GetStyle(), cur_style) || strcmp(event->GetName(), cur_name)) app.script->SetModifiedFlag(TRUE); event->SetLayer(gtk_spin_button_get_value_as_int(app.ui.spin_layer)); event->SetStyle(cur_style); event->SetName((char *) cur_name); gui_event_list_update_line(app.ui.event_list, event, &iter); gui_event_list_color_collisions(app.ui.event_list); // bad idea to call this every time kry_free(cur_style); } } g_list_foreach(sel_items, (GFunc) gtk_tree_path_free, NULL); g_list_free(sel_items); gui_main_focus_on_wave(); } gboolean gui_combo_box_set_text(GtkComboBox *combo, char *text, gboolean numeric) { GtkTreeIter iter; GtkTreeModel *model = gtk_combo_box_get_model(combo); char *combo_text; if(!gtk_tree_model_get_iter_first(model, &iter)) { //g_warning("tried to set combo value to '%s' but failed", text); return FALSE; } do { gtk_tree_model_get(model, &iter, 0, &combo_text, -1); combo_text = KRY_TS(combo_text); if(!strcmp(combo_text, text) || numeric && atof(combo_text) == atof(text)) { gtk_combo_box_set_active_iter(combo, &iter); kry_free(combo_text); return TRUE; } kry_free(combo_text); } while(gtk_tree_model_iter_next(model, &iter)); return FALSE; //g_warning("tried to set combo value to '%s' but failed", text); } void gui_combo_box_add_text(GtkComboBox *combo, char *text, gboolean numeric) { if(gui_combo_box_set_text(combo, text, numeric)) return; GtkTreeModel *model = gtk_combo_box_get_model(combo); GtkTreeIter iter; gtk_list_store_append(GTK_LIST_STORE(model), &iter); gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, text, -1); gui_combo_box_set_text(combo, text); } gboolean gui_combo_fps_select_cb(GtkEntry *entry, GdkEventFocus *focus, GtkComboBox *combo) { char *text = KRY_TS(gtk_combo_box_get_active_text(combo)); double val = atof(text); char *new_text = kry_strdup_printf(KRY_LOC "%.12f", val); int i; for(i = 0; text[i] != 0 && new_text[i] != 0 && text[i] == new_text[i]; i++); if(i == 0) { gui_combo_box_add_text(combo, "0", TRUE); } else { new_text[i] = 0; gui_combo_box_add_text(combo, new_text, TRUE); } kry_free(text); kry_free(new_text); return FALSE; } GtkComboBoxEntry *gui_combo_box_fps_new(gboolean ntsc_pal_only) { GtkComboBoxEntry *combo_fps = GTK_COMBO_BOX_ENTRY(gtk_combo_box_entry_new_text()); if(!ntsc_pal_only) { gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "23.976"); } gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "25 (PAL)"); gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "29.97 (NTSC)"); if(!ntsc_pal_only) { gtk_combo_box_append_text(GTK_COMBO_BOX(combo_fps), "119.880"); } gtk_widget_set_size_request(GTK_WIDGET(combo_fps), 120, -1); GtkEntry *entry = GTK_ENTRY(gtk_bin_get_child(GTK_BIN(combo_fps))); gtk_entry_set_max_length(entry, 12); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(gui_combo_fps_select_cb), combo_fps); g_signal_connect(G_OBJECT(entry), "activate", G_CALLBACK(gui_combo_fps_select_cb), combo_fps); return combo_fps; } void gui_main_script_modified(gboolean modified) { if(modified) { gui_status_bar_set_text_with_color(app.ui.status_bar, STATUS_MODIFIED, _("There are UNSAVED Changes"), app.ui.status_bar_color_table->Get(STATUS_COLOR_UNSAVED)); } else { gui_status_bar_set_text(app.ui.status_bar, STATUS_NOT_MODIFIED, _("No Changes Since Last Save")); } } gboolean gui_main_is_enabled() { return GTK_WIDGET_IS_SENSITIVE(app.ui.menu.me); } void gui_main_disable() { gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.me), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.paned_list), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_widget), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_widget), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_label), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_label), FALSE); if(app.gui_find_replace && app.gui_find_replace->window) gtk_widget_set_sensitive(GTK_WIDGET(app.gui_find_replace->window), FALSE); } void gui_main_enable() { gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.me), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.paned_list), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_widget), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_widget), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_audio_label), TRUE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video_label), TRUE); if(app.gui_find_replace && app.gui_find_replace->window) gtk_widget_set_sensitive(GTK_WIDGET(app.gui_find_replace->window), TRUE); } void gui_main_recent_list_update(GtkMenuItem *parent, GList *list, GCallback cb) { GtkMenu *menu = GTK_MENU(gtk_menu_new()); while(list) { GtkMenuItem *menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label((const gchar *) list->data)); g_signal_connect(menu_item, "activate", cb, list->data); gtk_menu_append(menu, GTK_WIDGET(menu_item)); list = list->next; } gtk_menu_item_set_submenu(parent, GTK_WIDGET(menu)); gtk_widget_show_all(GTK_WIDGET(menu)); } void gui_main_recent_list_add(GtkMenuItem *parent, GList **list, GCallback cb, char *filename) { kry_recent_list_add(list, filename); gui_main_recent_list_update(parent, *list, cb); } void gui_main_recent_list_save(GList *list, char *key) { app.prefs->Remove(key); while(list) { app.prefs->SetListAddString(key, (char *) list->data); list = list->next; } } void gui_main_setup_stock_icons() { GdkPixbuf *pixbuf_scaleup = gui_main_load_image(IDR_SCALE_UP); GdkPixbuf *pixbuf_scaledown = gui_main_load_image(IDR_SCALE_DOWN); GtkIconFactory *icon_factory = gtk_icon_factory_new(); app.ui.pixbufs.sarrow_up_left = gui_main_load_image(IDR_SARROW_UP_LEFT); app.ui.pixbufs.sarrow_up = gui_main_load_image(IDR_SARROW_UP); app.ui.pixbufs.sarrow_up_right = gui_main_load_image(IDR_SARROW_UP_RIGHT); app.ui.pixbufs.sarrow_left = gui_main_load_image(IDR_SARROW_LEFT); app.ui.pixbufs.sarrow_center = gui_main_load_image(IDR_SARROW_CENTER); app.ui.pixbufs.sarrow_right = gui_main_load_image(IDR_SARROW_RIGHT); app.ui.pixbufs.sarrow_down_left = gui_main_load_image(IDR_SARROW_DOWN_LEFT); app.ui.pixbufs.sarrow_down = gui_main_load_image(IDR_SARROW_DOWN); app.ui.pixbufs.sarrow_down_right = gui_main_load_image(IDR_SARROW_DOWN_RIGHT); GtkIconSet *icon_set; GtkIconSet *iconset_show; GtkIconSet *iconset_hide; GtkIconSet *iconset_scaleup; GtkIconSet *iconset_scaledown; #define STOCK_ITEM_COUNT 37 GtkStockItem items[STOCK_ITEM_COUNT] = { {"sabbu-zoom-in", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-zoom-out", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-stop", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play-selected", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-check-mark", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play-last", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-show", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-hide", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-scale-up", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-scale-down", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-name", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-clone", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-close", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-wave-jump", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play-previous", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play-current", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-play-next", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-left", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-right", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-up", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-down", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-jump-start", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-jump-end", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-new", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-edit", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-delete", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-manager", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-plus-sign", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-x-mark", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-scissors", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-star", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-bold", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-italic", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-underline", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-strikethrough", "", (GdkModifierType) 0, 0, "sabbu-fake"}, {"sabbu-lock", "", (GdkModifierType) 0, 0, "sabbu-fake"}, }; iconset_show = gtk_icon_set_new_from_pixbuf(app.ui.pixbufs.show); iconset_hide = gtk_icon_set_new_from_pixbuf(app.ui.pixbufs.hide); iconset_scaleup= gtk_icon_set_new_from_pixbuf(pixbuf_scaleup); iconset_scaledown = gtk_icon_set_new_from_pixbuf(pixbuf_scaledown); gtk_icon_factory_add(icon_factory, "sabbu-wave-show", iconset_show); gtk_icon_factory_add(icon_factory, "sabbu-wave-hide", iconset_hide); gtk_icon_factory_add(icon_factory, "sabbu-wave-scale-up", iconset_scaleup); gtk_icon_factory_add(icon_factory, "sabbu-wave-scale-down", iconset_scaledown); gtk_icon_factory_add_default(icon_factory); icon_set = gtk_icon_factory_lookup_default("gtk-zoom-in"); gtk_icon_factory_add(icon_factory, "sabbu-zoom-in", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-zoom-out"); gtk_icon_factory_add(icon_factory, "sabbu-zoom-out", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-media-play"); gtk_icon_factory_add(icon_factory, "sabbu-play", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-media-stop"); gtk_icon_factory_add(icon_factory, "sabbu-stop", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-goto-last"); gtk_icon_factory_add(icon_factory, "sabbu-play-selected", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-jump-to"); gtk_icon_factory_add(icon_factory, "sabbu-play-last", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-apply"); gtk_icon_factory_add(icon_factory, "sabbu-check-mark", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-properties"); gtk_icon_factory_add(icon_factory, "sabbu-wave-name", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-copy"); gtk_icon_factory_add(icon_factory, "sabbu-wave-clone", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-close"); gtk_icon_factory_add(icon_factory, "sabbu-wave-close", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-redo"); gtk_icon_factory_add(icon_factory, "sabbu-wave-jump", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-up"); gtk_icon_factory_add(icon_factory, "sabbu-play-previous", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-forward"); gtk_icon_factory_add(icon_factory, "sabbu-play-current", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-down"); gtk_icon_factory_add(icon_factory, "sabbu-play-next", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-back"); gtk_icon_factory_add(icon_factory, "sabbu-left", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-forward"); gtk_icon_factory_add(icon_factory, "sabbu-right", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-up"); gtk_icon_factory_add(icon_factory, "sabbu-up", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-go-down"); gtk_icon_factory_add(icon_factory, "sabbu-down", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-goto-last"); gtk_icon_factory_add(icon_factory, "sabbu-jump-end", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-goto-first"); gtk_icon_factory_add(icon_factory, "sabbu-jump-start", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-delete"); gtk_icon_factory_add(icon_factory, "sabbu-delete", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-new"); gtk_icon_factory_add(icon_factory, "sabbu-new", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-edit"); gtk_icon_factory_add(icon_factory, "sabbu-edit", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-dnd-multiple"); gtk_icon_factory_add(icon_factory, "sabbu-manager", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-add"); gtk_icon_factory_add(icon_factory, "sabbu-plus-sign", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-cancel"); gtk_icon_factory_add(icon_factory, "sabbu-x-mark", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-cut"); gtk_icon_factory_add(icon_factory, "sabbu-scissors", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-about"); gtk_icon_factory_add(icon_factory, "sabbu-star", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-bold"); gtk_icon_factory_add(icon_factory, "sabbu-bold", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-italic"); gtk_icon_factory_add(icon_factory, "sabbu-italic", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-underline"); gtk_icon_factory_add(icon_factory, "sabbu-underline", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-strikethrough"); gtk_icon_factory_add(icon_factory, "sabbu-strikethrough", icon_set); icon_set = gtk_icon_factory_lookup_default("gtk-dialog-authentication"); gtk_icon_factory_add(icon_factory, "sabbu-lock", icon_set); gtk_stock_add((GtkStockItem *) &items, STOCK_ITEM_COUNT); } gboolean gui_text_editor_keypress_cb(GtkWidget *widget, GdkEventKey *event, struct KryTextEditor *editor) { if(gtk_im_context_filter_keypress (GTK_TEXT_VIEW (editor->view)->im_context, event)) { GTK_TEXT_VIEW (editor->view)->need_im_reset = TRUE; return TRUE; } if(event->keyval == GDK_Return && event->state & GDK_SHIFT_MASK && app.ui.ui_mode == UI_MODE_SRT) return FALSE; if(event->keyval == GDK_Return) { if(app.ui.karaoke_mode == KARAOKE_MODE_LINE) { char *text = gui_text_editor_get_text(editor); gui_main_karaoke_split_word(text); kry_free(text); } else { gui_main_grab_times((enum grab_flags) (GRAB_ADVANCE | GRAB_ENTERKEY)); } return TRUE; } return FALSE; } /* Creates the "Text Editor" widget. This widget contains the actual Text Editor, plus the toggles for code highlighting and the karaoke features */ GtkWidget *gui_main_create_text_editor() { GtkFrame *frame_text = GTK_FRAME(gtk_frame_new(NULL)); GtkHBox *hbox_input = GTK_HBOX(gtk_hbox_new(FALSE, 0)); app.ui.karaoke_container = GTK_LAYOUT(gtk_layout_new(NULL, NULL)); app.ui.hbox_karaoke = GTK_HBOX(gtk_hbox_new(FALSE, 0)); app.ui.text_editor = gui_text_editor_new(); g_signal_connect(G_OBJECT(gui_text_editor_get_view(app.ui.text_editor)), "key-press-event", G_CALLBACK(gui_text_editor_keypress_cb), app.ui.text_editor); GtkVBox *vbox_karaoke_switch = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkHBox *hbox_karaoke_switch = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkButton *button_box = GTK_BUTTON(gtk_button_new()); GtkButton *button_line = GTK_BUTTON(gtk_button_new()); GtkImage *image_box = GTK_IMAGE(gtk_image_new_from_pixbuf(app.ui.pixbufs.karaoke_box)); GtkImage *image_line = GTK_IMAGE(gtk_image_new_from_pixbuf(app.ui.pixbufs.karaoke_line)); gtk_container_add(GTK_CONTAINER(button_box), GTK_WIDGET(image_box)); gtk_container_add(GTK_CONTAINER(button_line), GTK_WIDGET(image_line)); //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(button_box), FALSE, TRUE, 1); //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(button_line), FALSE, TRUE, 1); gtk_container_set_border_width(GTK_CONTAINER(hbox_karaoke_switch), 1); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_box), _("Karaoke Box Mode"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_line), _("Karaoke Line Mode"), NULL); g_signal_connect(G_OBJECT(button_box), "clicked", G_CALLBACK(gui_main_karaoke_mode_on), (gpointer) 0); g_signal_connect(G_OBJECT(button_line), "clicked", G_CALLBACK(gui_main_karaoke_mode_on), (gpointer) 1); gtk_box_pack_start(GTK_BOX(vbox_karaoke_switch), GTK_WIDGET(hbox_karaoke_switch), FALSE, TRUE, 1); app.ui.karaoke_hbox_switch = hbox_karaoke_switch; app.ui.karaoke_vbox_switch = vbox_karaoke_switch; app.ui.karaoke_button_box = button_box; app.ui.karaoke_button_line = button_line; GtkVBox *vbox_toolbar = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkToolbar *toolbar = GTK_TOOLBAR(gtk_toolbar_new()); GtkComboBox *combo = GTK_COMBO_BOX(gtk_combo_box_new_text()); gtk_combo_box_append_text(combo, "\\k"); gtk_combo_box_append_text(combo, "\\K"); gtk_combo_box_append_text(combo, "\\ko"); g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(gui_main_karaoke_type_changed_cb), NULL); g_signal_connect(G_OBJECT(combo), "key-press-event", G_CALLBACK(gui_main_key_press), NULL); app.ui.karaoke_type_combo = combo; gtk_toolbar_append_item(toolbar, NULL, _("Exit Karaoke Mode"), _("Exit Karaoke Mode"), gtk_image_new_from_stock("sabbu-x-mark", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_karaoke_mode_off_cb), (gpointer)1); gtk_toolbar_append_item(toolbar, NULL, _("Save Changes"), _("Save Changes"), gtk_image_new_from_stock("sabbu-check-mark", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_karaoke_mode_off_cb), 0); gtk_toolbar_append_widget(toolbar, GTK_WIDGET(combo), _("Karaoke Type"), NULL); app.ui.karaoke_toolbar_split = gtk_toolbar_append_item(toolbar, NULL, _("Split Word"), _("Split Word"), gtk_image_new_from_stock("sabbu-scissors", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_karaoke_split_word_cb), NULL); /*gtk_toolbar_append_item(toolbar, NULL, _("Add Silence"), _("Add Silence"), gtk_image_new_from_stock("sabbu-plus-sign", GTK_ICON_SIZE_SMALL_TOOLBAR), GTK_SIGNAL_FUNC(gui_main_karaoke_add_silence_before_cb), NULL);*/ app.ui.karaoke_vbox_toolbar = vbox_toolbar; gtk_toolbar_set_icon_size(toolbar, GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_box_pack_start(GTK_BOX(vbox_toolbar), GTK_WIDGET(toolbar), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(app.ui.hbox_karaoke), GTK_WIDGET(app.ui.karaoke_container), TRUE, TRUE, 0); //GtkVSeparator *karaoke_separator = GTK_VSEPARATOR(gtk_vseparator_new()); //gtk_box_pack_start(GTK_BOX(hbox_karaoke_switch), GTK_WIDGET(karaoke_separator), TRUE, TRUE, 2); gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(vbox_karaoke_switch), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(vbox_toolbar), FALSE, TRUE, 5); gtk_box_pack_start(GTK_BOX(hbox_input), gui_text_editor_get_widget(app.ui.text_editor), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox_input), GTK_WIDGET(app.ui.hbox_karaoke), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame_text), GTK_WIDGET(hbox_input)); return GTK_WIDGET(frame_text); } void gui_main_time_start_enter_cb() { gui_main_grab_times(GRAB_TIME_START_ONLY); gtk_widget_grab_focus(GTK_WIDGET(gui_time_entry_get_view(app.ui.time_end))); } void gui_main_time_end_enter_cb() { gui_main_grab_times(GRAB_TIME_END_ONLY); gtk_widget_grab_focus(GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor))); } void gui_main_time_dur_enter_cb() { gui_main_grab_times(GRAB_TIME_START_ONLY); gui_main_grab_times(GRAB_TIME_END_ONLY); gtk_widget_grab_focus(GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor))); } void gui_main_time_text_field_changed_cb(char *val, KryMarker **marker) { if(app.ui.ui_mode == UI_MODE_SRT) kry_marker_set_value(*marker, time_string_to_mili(val, 0, TRUE, FALSE)); else kry_marker_set_value(*marker, time_string_to_mili(val, 0)); } void gui_main_time_dur_field_changed_cb(char *val, gpointer data) { int dur; if(app.ui.ui_mode == UI_MODE_SRT) dur = time_string_to_mili(val, 0, TRUE, FALSE); else dur = time_string_to_mili(val, 0); kry_marker_set_value(app.ui.marker_active_end, kry_marker_get_value(app.ui.marker_active_start) + dur); } gboolean gui_main_time_box_key_press_cb(GtkWidget *widget, GdkEventKey *key, gpointer data) { if(key->keyval == GDK_Tab || key->keyval == GDK_ISO_Left_Tab) { GtkWidget *widgets[3] = { GTK_WIDGET(g_object_get_data(G_OBJECT(app.ui.time_start), "text_view")), GTK_WIDGET(g_object_get_data(G_OBJECT(app.ui.time_end), "text_view")), GTK_WIDGET(gui_text_editor_get_view(app.ui.text_editor)) }; int cur = -1; int count = sizeof(widgets) / sizeof(GtkWidget *); for(int i = 0; i < count; i++) if(widgets[i] == widget) cur = i; if(cur == -1) return FALSE; if(key->state & GDK_SHIFT_MASK) cur--; else cur++; if(cur < 0) cur = count - 1; if(cur >= count) cur = 0; gtk_widget_grab_focus(widgets[cur]); return TRUE; } return FALSE; } void gui_main_leadin_cb(GtkWidget *widget, gpointer data) { KryMarker *marker = app.ui.marker_active_start; int offset = app.opts.leadin; int val = kry_marker_get_value(marker) - offset; if(val < 0) val = 0; kry_marker_set_value(marker, val); gui_main_focus_on_wave(); } void gui_main_leadout_cb(GtkWidget *widget, gpointer data) { KryMarker *marker = app.ui.marker_active_end; int offset = app.opts.leadout; int val = kry_marker_get_value(marker) + offset; kry_marker_set_value(marker, val); gui_main_focus_on_wave(); } void gui_main_leadboth_cb(GtkWidget *widget, gpointer data) { gui_main_leadin_cb(widget, data); gui_main_leadout_cb(widget, data); } void gui_main_play_speed_cb(GtkComboBox *combo, gpointer data) { char *text = gtk_combo_box_get_active_text(combo); int speed = atoi(text); kry_free(text); app.ui.play_speed = speed; } /* Creates the event editor widget. (The remaining edit controls after the text editor) */ GtkWidget *gui_main_create_event_editor() { GtkButton *button_leadin = GTK_BUTTON(gtk_button_new()); GtkButton *button_leadout = GTK_BUTTON(gtk_button_new()); GtkButton *button_leadboth = GTK_BUTTON(gtk_button_new()); GtkButton *button_start_less_10 = GTK_BUTTON(gtk_button_new()); GtkButton *button_start_more_10 = GTK_BUTTON(gtk_button_new()); GtkButton *button_start_less_1 = GTK_BUTTON(gtk_button_new()); GtkButton *button_start_more_1 = GTK_BUTTON(gtk_button_new()); GtkButton *button_end_less_10 = GTK_BUTTON(gtk_button_new());; GtkButton *button_end_more_10 = GTK_BUTTON(gtk_button_new()); GtkButton *button_end_less_1 = GTK_BUTTON(gtk_button_new()); GtkButton *button_end_more_1 = GTK_BUTTON(gtk_button_new()); GtkHBox *hbox_start_10 = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkHBox *hbox_end_10 = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkHBox *hbox_start_1 = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkHBox *hbox_end_1 = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkLabel *label_start = GTK_LABEL(gtk_label_new(_("Start:"))); GtkLabel *label_end = GTK_LABEL(gtk_label_new(_("End:"))); GtkLabel *label_dur = GTK_LABEL(gtk_label_new(_("Dur:"))); GtkLabel *label_style = GTK_LABEL(gtk_label_new(_("Style:"))); GtkLabel *label_name = GTK_LABEL(gtk_label_new(_("Name:"))); GtkLabel *label_layer = GTK_LABEL(gtk_label_new(_("Layer:"))); GtkLabel *label_speed = GTK_LABEL(gtk_label_new(_("Play Speed"))); GtkSpinButton *spin_layer = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 99, 1)); GtkTable *table; GtkComboBox *combo_box = GTK_COMBO_BOX(gtk_combo_box_new_text()); g_signal_connect(G_OBJECT(combo_box), "changed", G_CALLBACK(gui_main_play_speed_cb), NULL); gtk_combo_box_append_text(combo_box, "25%"); gtk_combo_box_append_text(combo_box, "50%"); gtk_combo_box_append_text(combo_box, "100%"); gui_combo_box_set_text(combo_box, "100%", FALSE); gtk_container_add(GTK_CONTAINER(button_leadin), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadin))); gtk_container_add(GTK_CONTAINER(button_leadout), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadout))); gtk_container_add(GTK_CONTAINER(button_leadboth), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.leadboth))); gtk_container_add(GTK_CONTAINER(button_start_less_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left2))); gtk_container_add(GTK_CONTAINER(button_end_less_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left2))); gtk_container_add(GTK_CONTAINER(button_start_more_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right2))); gtk_container_add(GTK_CONTAINER(button_end_more_10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right2))); gtk_container_add(GTK_CONTAINER(button_start_less_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left))); gtk_container_add(GTK_CONTAINER(button_end_less_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left))); gtk_container_add(GTK_CONTAINER(button_start_more_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right))); gtk_container_add(GTK_CONTAINER(button_end_more_1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right))); g_signal_connect(spin_layer, "value-changed", G_CALLBACK(gui_main_layer_style_changed_cb), NULL); app.ui.label_layer = label_layer; app.ui.spin_layer = spin_layer; table = GTK_TABLE(gtk_table_new(2, 10, 0)); struct hold_button_callback_info *info_start_less1 = kry_new0(struct hold_button_callback_info); info_start_less1->func = (kryButtonCallback) gui_main_marker_start_move; info_start_less1->data = (gpointer) - 10; struct hold_button_callback_info *info_start_less10 = kry_new0(struct hold_button_callback_info); info_start_less10->func = (kryButtonCallback) gui_main_marker_start_move; info_start_less10->data = (gpointer) - 100; struct hold_button_callback_info *info_start_more1 = kry_new0(struct hold_button_callback_info); info_start_more1->func = (kryButtonCallback) gui_main_marker_start_move; info_start_more1->data = (gpointer) 10; struct hold_button_callback_info *info_start_more10 = kry_new0(struct hold_button_callback_info); info_start_more10->func = (kryButtonCallback) gui_main_marker_start_move; info_start_more10->data = (gpointer) 100; struct hold_button_callback_info *info_end_less1 = kry_new0(struct hold_button_callback_info); info_end_less1->func = (kryButtonCallback) gui_main_marker_end_move; info_end_less1->data = (gpointer) - 10; struct hold_button_callback_info *info_end_less10 = kry_new0(struct hold_button_callback_info); info_end_less10->func = (kryButtonCallback) gui_main_marker_end_move; info_end_less10->data = (gpointer) - 100; struct hold_button_callback_info *info_end_more1 = kry_new0(struct hold_button_callback_info); info_end_more1->func = (kryButtonCallback) gui_main_marker_end_move; info_end_more1->data = (gpointer) 10; struct hold_button_callback_info *info_end_more10 = kry_new0(struct hold_button_callback_info); info_end_more10->func = (kryButtonCallback) gui_main_marker_end_move; info_end_more10->data = (gpointer) 100; app.ui.button_start_less_10 = button_start_less_10; app.ui.button_start_more_10 = button_start_more_10; app.ui.button_start_less_1 = button_start_less_1; app.ui.button_start_more_1 = button_start_more_1; g_signal_connect(button_leadin, "clicked", G_CALLBACK(gui_main_leadin_cb), NULL); g_signal_connect(button_leadout, "clicked", G_CALLBACK(gui_main_leadout_cb), NULL); g_signal_connect(button_leadboth, "clicked", G_CALLBACK(gui_main_leadboth_cb), NULL); g_signal_connect(button_start_less_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less1); g_signal_connect(button_start_less_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less10); g_signal_connect(button_start_more_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more1); g_signal_connect(button_start_more_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more10); g_signal_connect(button_end_less_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_less1); g_signal_connect(button_end_less_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_less10); g_signal_connect(button_end_more_1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_more1); g_signal_connect(button_end_more_10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_end_more10); g_signal_connect(button_start_less_1, "released", G_CALLBACK(gui_main_hold_button_release ), info_start_less1); g_signal_connect(button_start_less_10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_less10); g_signal_connect(button_start_more_1, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more1); g_signal_connect(button_start_more_10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more10); g_signal_connect(button_end_less_1, "released", G_CALLBACK(gui_main_hold_button_release), info_end_less1); g_signal_connect(button_end_less_10, "released", G_CALLBACK(gui_main_hold_button_release), info_end_less10); g_signal_connect(button_end_more_1, "released", G_CALLBACK(gui_main_hold_button_release), info_end_more1); g_signal_connect(button_end_more_10, "released", G_CALLBACK(gui_main_hold_button_release), info_end_more10); app.ui.info_start_less1 = info_start_less1; app.ui.info_start_less10 = info_start_less10; app.ui.info_start_more1 = info_start_more1; app.ui.info_start_more10 = info_start_more10; app.ui.info_end_less1 = info_end_less1; app.ui.info_end_less10 = info_end_less10; app.ui.info_end_more1 = info_end_more1; app.ui.info_end_more10 = info_end_more10; gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadin), _("Add Lead-In"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadout), _("Add Lead-Out"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_leadboth), _("Add Lead-In & Lead-Out"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_less_1), _("Start -0.01 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_less_10), _("Start -0.1 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_more_1), _("Start +0.01 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_start_more_10), _("Start +0.1 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_less_1), _("End -0.01 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_less_10), _("End -0.1 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_more_1), _("End +0.01 s"), NULL); gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_end_more_10), _("End +0.1 s"), NULL); gtk_box_pack_start(GTK_BOX(hbox_start_10), GTK_WIDGET(button_start_less_10), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_start_10), GTK_WIDGET(button_start_more_10), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_end_10), GTK_WIDGET(button_end_less_10), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_end_10), GTK_WIDGET(button_end_more_10), FALSE, TRUE, 1); app.ui.hbox_start_1 = hbox_start_1; gtk_box_pack_start(GTK_BOX(hbox_start_1), GTK_WIDGET(button_start_less_1), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_start_1), GTK_WIDGET(button_start_more_1), FALSE, TRUE, 1); app.ui.hbox_end_1 = hbox_end_1; gtk_box_pack_start(GTK_BOX(hbox_end_1), GTK_WIDGET(button_end_less_1), FALSE, TRUE, 1); gtk_box_pack_start(GTK_BOX(hbox_end_1), GTK_WIDGET(button_end_more_1), FALSE, TRUE, 1); GtkWidget *border_start2 = gtk_event_box_new(); { GtkWidget *border_start1 = gtk_event_box_new(); app.ui.time_start = gui_time_entry_new( G_CALLBACK(gui_main_time_text_field_changed_cb), G_CALLBACK(gui_main_time_start_enter_cb), &app.ui.marker_active_start); gtk_container_add(GTK_CONTAINER(border_start1), GTK_WIDGET(app.ui.time_start)); gtk_container_add(GTK_CONTAINER(border_start2), GTK_WIDGET(border_start1)); gtk_container_set_border_width(GTK_CONTAINER(border_start1), 2); app.ui.box_time_start = GTK_WIDGET(border_start2); } /*GdkColor red; red.red = 257*255; red.green = 257*64; red.blue = 257*64; red.pixel = 0; gtk_widget_modify_bg(GTK_WIDGET(app.ui.box_time_start), GTK_STATE_NORMAL, &red);*/ GtkWidget *border_end2 = gtk_event_box_new(); { GtkWidget *border_end1 = gtk_event_box_new(); app.ui.time_end = gui_time_entry_new( G_CALLBACK(gui_main_time_text_field_changed_cb), G_CALLBACK(gui_main_time_end_enter_cb), &app.ui.marker_active_end); gtk_container_add(GTK_CONTAINER(border_end1), GTK_WIDGET(app.ui.time_end)); gtk_container_add(GTK_CONTAINER(border_end2), GTK_WIDGET(border_end1)); gtk_container_set_border_width(GTK_CONTAINER(border_end1), 2); app.ui.box_time_end = GTK_WIDGET(border_end2); } GtkWidget *border_dur2 = gtk_event_box_new(); { GtkWidget *border_dur1 = gtk_event_box_new(); app.ui.time_dur = gui_time_entry_new( G_CALLBACK(gui_main_time_dur_field_changed_cb), G_CALLBACK(gui_main_time_dur_enter_cb), NULL); gtk_container_add(GTK_CONTAINER(border_dur1), GTK_WIDGET(app.ui.time_dur)); gtk_container_add(GTK_CONTAINER(border_dur2), GTK_WIDGET(border_dur1)); gtk_container_set_border_width(GTK_CONTAINER(border_dur1), 2); } //gtk_widget_set_sensitive(app.ui.time_dur, FALSE); app.ui.label_style = label_style; app.ui.label_name = label_name; app.ui.combo_style = GTK_COMBO_BOX(gtk_combo_box_entry_new_text()); gtk_combo_box_set_model(app.ui.combo_style, GTK_TREE_MODEL(app.ui.style_store)); gtk_editable_set_editable(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(app.ui.combo_style))), FALSE); gtk_widget_set_size_request(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(app.ui.combo_style))), 100, -1); gtk_combo_box_set_focus_on_click(app.ui.combo_style, FALSE); g_signal_connect(app.ui.combo_style, "changed", G_CALLBACK(gui_main_entry_style_changed_cb), NULL); g_signal_connect(app.ui.combo_style, "key-press-event", G_CALLBACK(gui_main_key_press), NULL); app.ui.name_store = gtk_list_store_new(1, G_TYPE_STRING); app.ui.name_store_sorted = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(app.ui.name_store)); app.ui.combo_name = GTK_COMBO_BOX(gtk_combo_box_entry_new_text()); gtk_combo_box_set_model(app.ui.combo_name, GTK_TREE_MODEL(app.ui.name_store_sorted)); //gtk_editable_set_editable(GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(app.ui.combo_name))), FALSE); gtk_widget_set_size_request(GTK_WIDGET(gtk_bin_get_child(GTK_BIN(app.ui.combo_name))), 100, -1); gtk_combo_box_set_focus_on_click(app.ui.combo_name, FALSE); //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); 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); 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); 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); g_signal_connect(GTK_WIDGET(app.ui.combo_name), "changed", G_CALLBACK(gui_main_entry_name_changed_cb), app.ui.combo_name); gtk_misc_set_alignment(GTK_MISC(label_start), 1.0, 0.5); gtk_misc_set_alignment(GTK_MISC(label_end), 1.0, 0.5); gtk_misc_set_alignment(GTK_MISC(label_style), 1.0, 0.5); gtk_misc_set_alignment(GTK_MISC(label_name), 1.0, 0.5); gtk_misc_set_alignment(GTK_MISC(label_dur), 1.0, 0.5); gtk_misc_set_alignment(GTK_MISC(label_layer), 1.0, 0.5); app.ui.table_event_editor = table; // controls { GtkFrame *controls = GTK_FRAME(gtk_frame_new(NULL)); GtkWidget *widget = gui_main_create_control_toolbar(CONTROLS_TABLE); gtk_container_add(GTK_CONTAINER(controls), widget); gtk_table_attach(app.ui.table_event_editor, GTK_WIDGET(controls), 0, 4, 0, 2, GTK_FILL, GTK_FILL, 2, 0); gtk_widget_show_all(GTK_WIDGET(controls)); app.ui.frame_controls = controls; } gtk_table_attach(table, GTK_WIDGET(button_leadin), 5, 6, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(button_leadout), 5, 6, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(button_leadboth), 4, 5, 0, 2, GTK_FILL, GTK_FILL, 2, 2); int off = 6; gtk_table_attach(table, GTK_WIDGET(label_start), off + 0, off + 1, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(hbox_start_10), off + 1, off + 2, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(border_start2), off + 2, off + 3, 0, 1, GTK_FILL, GTK_FILL, 0, 2); gtk_table_attach(table, GTK_WIDGET(hbox_start_1), off + 3, off + 4, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(label_end), off + 0, off + 1, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(hbox_end_10), off + 1, off + 2, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(border_end2), off + 2, off + 3, 1, 2, GTK_FILL, GTK_FILL, 0, 2); gtk_table_attach(table, GTK_WIDGET(hbox_end_1), off + 3, off + 4, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(label_dur), off + 4, off + 5, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(border_dur2), off + 5, off + 6, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(label_layer), off + 4, off + 5, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(spin_layer), off + 5, off + 6, 1, 2, GTK_FILL, GTK_FILL, 3, 2); gtk_table_attach(table, GTK_WIDGET(label_style), off + 6, off + 7, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(app.ui.combo_style), off + 7, off + 8, 0, 1, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(label_name), off + 6, off + 7, 1, 2, GTK_FILL, GTK_FILL, 2, 2); gtk_table_attach(table, GTK_WIDGET(app.ui.combo_name), off + 7, off + 8, 1, 2, GTK_FILL, GTK_FILL, 2, 2); GtkFrame *frame_speed = GTK_FRAME(gtk_frame_new(NULL)); GtkVBox *vbox_speed = GTK_VBOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(vbox_speed), GTK_WIDGET(label_speed), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_speed), GTK_WIDGET(combo_box), TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(frame_speed), GTK_WIDGET(vbox_speed)); gtk_container_set_border_width(GTK_CONTAINER(vbox_speed), 2); //gtk_table_attach(table, GTK_WIDGET(frame_speed), off + 8, off + 9, 0, 2, GTK_FILL, GTK_FILL, 2, 2); return GTK_WIDGET(table); } void gui_main_paned_move_cb(GtkPaned *paned, GParamSpec *spec, GtkNotebook *notebook) { if(g_object_get_data(G_OBJECT(paned), "sabbu-signal-ignore")) return; int page = gtk_notebook_get_current_page(notebook); int pos = gtk_paned_get_position(paned); if(page == NOTEBOOK_PAGE_VIDEO) app.ui.pane_video_pos = pos; else if(page == NOTEBOOK_PAGE_AUDIO) app.ui.pane_other_pos = pos; } void gui_main_text_paned_move_cb(GtkPaned *paned, GParamSpec *spec, gpointer data) { long min_height = (long) g_object_get_data(G_OBJECT(paned), "sabbu-min-size"); int pos = gtk_paned_get_position(paned); if(pos < min_height) { gtk_paned_set_position(paned, min_height); return; } app.prefs->SetInt("TextEditorPanedPos", pos); } GtkMenuItem *gui_main_get_menu_item(char *text, GtkItemFactory *item_factory) { char *text2 = string_replace(text, "_", ""); char *menu_text = kry_strdup_printf(KRY_LOC "%s", text2); GtkMenuItem *menu = GTK_MENU_ITEM(gtk_item_factory_get_item(item_factory, menu_text)); kry_free(menu_text); kry_free(text2); if(!menu) g_warning("unable to lookup menu item: %s", text); return menu; } void gui_main_focus() { gtk_window_present(app.ui.window); gui_main_focus_on_wave(); } void gui_main_spellcheck_language_cb(GtkWidget *widget, char *lang) { #ifdef HAVE_ASPELL if(app.ui.speller) { spell_destroy(app.ui.speller); app.ui.speller = NULL; } app.ui.speller = spell_create((char *) lang); #endif } void gui_main_create() { GtkAccelGroup *accel_group = gtk_accel_group_new(); GtkWidget *menu_widget; GtkVBox *vbox_super = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkFrame *frame = GTK_FRAME(gtk_frame_new(NULL)); GtkVBox *vbox_text = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkHBox *hbox_table = GTK_HBOX(gtk_hbox_new(FALSE, 0)); GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL)); GtkVBox *vbox_notebook = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new()); GtkVBox *timing_box = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkLabel *page_progress; GtkVBox *vbox_event_edit = GTK_VBOX(gtk_vbox_new(FALSE, 0)); GtkPaned *paned_notebook = GTK_PANED(gtk_vpaned_new()); GtkPaned *paned_list = GTK_PANED(gtk_vpaned_new()); app.ui.notebook = notebook; // event list colors { kryColorTable *table = new kryColorTable(LIST_COLOR_COUNT); table->Set(LIST_COLOR_COMMENT, "EventListComment", __("Color|Comment"), 0xCC, 0xCC, 0xFF); table->Set(LIST_COLOR_COLLISION, "EventListCollision", __("Color|Collision"), 0xFF, 0xBB, 0xBB); table->Set(LIST_COLOR_COLLISION_HIGHLIGHT, "EventListCollisionHighlight", __("Color|Collision Highlight"), 0xFF, 0x77, 0x77); for(int i = 0; i < table->GetColorCount(); i++) { if(table->Get(i)->IsInitialized()) gui_event_list_color_change_string(table->Get(i)); } app.ui.list_color_table = table; } // status bar colors { kryColorTable *table = new kryColorTable(STATUS_COLOR_COUNT); table->Set(STATUS_COLOR_SUCCESS, "StatusSuccess", __("Color|Success"), 0, 0xFF, 0); table->Set(STATUS_COLOR_UNSAVED, "StatusUnsaved", __("Color|Unsaved Changes"), 0xFF, 0xC0, 0xC0); app.ui.status_bar_color_table = table; } // syntax highlighting colors { kryColorTable *table = new kryColorTable(HIGHLIGHT_COLOR_COUNT); table->Set(HIGHLIGHT_COLOR_COMMAND1, "HighlightCommand1", __("Color|Command 1"), 0xAA, 0x22, 0x22); table->Set(HIGHLIGHT_COLOR_COMMAND2, "HighlightCommand2", __("Color|Command 2"), 0x22, 0xAA, 0x22); table->Set(HIGHLIGHT_COLOR_TEXT, "HighlightText", __("Color|Text"), 0x00, 0x00, 0xFF); table->Set(HIGHLIGHT_COLOR_ERROR, "HighlightError", __("Color|Error"), 0xFF, 0x00, 0x00); app.ui.highlight_color_table = table; } // setup find options { app.gui_find_replace_options.match_case = app.prefs->GetInt("SearchMatchCase", 0); app.gui_find_replace_options.match_wholeword = app.prefs->GetInt("SearchMatchWholeWord", 0); app.gui_find_replace_options.search_up = app.prefs->GetInt("SearchMatchSearchUp", 0); app.gui_find_replace_options.search_text = app.prefs->GetInt("SearchMatchSearchText", 1); app.gui_find_replace_options.search_style = app.prefs->GetInt("SearchMatchSearchStyle", 0); app.gui_find_replace_options.search_name = app.prefs->GetInt("SearchMatchSearchName", 0); app.gui_find_replace_options.target_history = kry_recent_list_load("SearchHistory"); } // setup the markers { app.ui.marker_event_start = KRY_MARKER(kry_marker_new(MARKER_START, 10)); app.ui.marker_event_end = KRY_MARKER(kry_marker_new(MARKER_END, 10)); app.ui.marker_current = KRY_MARKER(kry_marker_new(MARKER_CURRENT, 1)); app.ui.marker_active_start = app.ui.marker_event_start; app.ui.marker_active_end = app.ui.marker_event_end; g_signal_connect(app.ui.marker_event_start, "value-changed", G_CALLBACK(gui_main_marker_changed_cb), NULL); g_signal_connect(app.ui.marker_event_end, "value-changed", G_CALLBACK(gui_main_marker_changed_cb), NULL); } // initialize common stuff { app.ui.tooltips = gtk_tooltips_new(); app.ui.style_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); app.ui.pixbufs.show = gui_main_load_image(IDR_ARROW_DOWN); app.ui.pixbufs.hide = gui_main_load_image(IDR_ARROW_RIGHT); app.ui.pixbufs.gear = gui_main_load_image(IDR_GEAR); app.ui.pixbufs.syntax = gui_main_load_image(IDR_SYNTAX); app.ui.pixbufs.syntax_off = gui_main_load_image(IDR_SYNTAX_OFF); app.ui.pixbufs.karaoke_box = gui_main_load_image(IDR_KARAOKE_BOX); app.ui.pixbufs.karaoke_line = gui_main_load_image(IDR_KARAOKE_LINE); app.ui.pixbufs.search_indicator = gui_main_load_image(IDR_SEARCH_INDICATOR); app.ui.pixbufs.margin_left = gui_main_load_image(IDR_MARGIN_LEFT); app.ui.pixbufs.margin_right = gui_main_load_image(IDR_MARGIN_RIGHT); app.ui.pixbufs.margin_vertical = gui_main_load_image(IDR_MARGIN_VERTICAL); app.ui.pixbufs.angle = gui_main_load_image(IDR_ANGLE); app.ui.pixbufs.scalex = gui_main_load_image(IDR_SCALEX); app.ui.pixbufs.scaley = gui_main_load_image(IDR_SCALEY); app.ui.pixbufs.spacing = gui_main_load_image(IDR_SPACING); app.ui.pixbufs.time_left = gui_main_load_image(IDR_TIME_LEFT); app.ui.pixbufs.time_left2 = gui_main_load_image(IDR_TIME_LEFT2); app.ui.pixbufs.time_right = gui_main_load_image(IDR_TIME_RIGHT); app.ui.pixbufs.time_right2 = gui_main_load_image(IDR_TIME_RIGHT2); app.ui.pixbufs.sync_scroll = gui_main_load_image(IDR_SYNC_SCROLL); app.ui.pixbufs.sync_zoom = gui_main_load_image(IDR_SYNC_ZOOM); app.ui.pixbufs.sync_scale = gui_main_load_image(IDR_SYNC_SCALE); app.ui.pixbufs.play = gui_main_load_image(IDR_PLAY); app.ui.pixbufs.play_last = gui_main_load_image(IDR_PLAY_LAST); app.ui.pixbufs.play_selection = gui_main_load_image(IDR_PLAY_SELECTION); app.ui.pixbufs.play_stop = gui_main_load_image(IDR_PLAY_STOP); app.ui.pixbufs.grab_times = gui_main_load_image(IDR_GRAB_TIMES); app.ui.pixbufs.focus_selected = gui_main_load_image(IDR_FOCUS_SELECTED); app.ui.pixbufs.show_time = gui_main_load_image(IDR_SHOW_TIME); app.ui.pixbufs.show_keyframes = gui_main_load_image(IDR_SHOW_KEYFRAMES); app.ui.pixbufs.leadin = gui_main_load_image(IDR_LEADIN); app.ui.pixbufs.leadout = gui_main_load_image(IDR_LEADOUT); app.ui.pixbufs.leadboth = gui_main_load_image(IDR_LEADBOTH); app.ui.paned_notebook = paned_notebook; app.ui.paned_list = paned_list; app.ui.vbox_event_edit = vbox_event_edit; gui_main_setup_stock_icons(); } // setup main window properties { app.ui.window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); app.ui.window_focus = app.ui.window; if(app.prefs->GetInt("StartMaximized", 0)) gtk_window_maximize(app.ui.window); gtk_widget_set_usize (GTK_WIDGET(app.ui.window), -1, 600); gtk_window_set_default_size(app.ui.window, app.prefs->GetInt("WindowMainWidth", -1), app.prefs->GetInt("WindowMainHeight", -1)); int x = app.prefs->GetInt("WindowMainX", -1); int y = app.prefs->GetInt("WindowMainY", -1); if(x != -1 && y != -1) gtk_window_move(app.ui.window, x, y); gtk_window_add_accel_group(app.ui.window, accel_group); g_signal_connect(app.ui.window, "delete-event", G_CALLBACK(gui_main_cb_delete), NULL); g_signal_connect(app.ui.window, "configure-event", G_CALLBACK(gui_main_cb_configure), NULL); } // setup menus { menu_widget = GTK_WIDGET(gui_menu_create()); app.ui.menu.me = GTK_MENU_BAR(menu_widget); gtk_box_pack_start(GTK_BOX(vbox_super), GTK_WIDGET(menu_widget), FALSE, TRUE, 0); gui_main_karaoke_disable_menus(); { GtkMenu *menu = GTK_MENU(gtk_menu_new()); GtkMenuItem *menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label(__("EventType|Dialog"))); g_signal_connect(menu_item, "activate", G_CALLBACK(gui_main_menu_event_type), (gpointer) kryEvent::EVENT_DIALOG); gtk_menu_append(menu, GTK_WIDGET(menu_item)); menu_item = GTK_MENU_ITEM(gtk_menu_item_new_with_label(__("EventType|Comment"))); g_signal_connect(menu_item, "activate", G_CALLBACK(gui_main_menu_event_type), (gpointer) kryEvent::EVENT_COMMENT_DIALOG); gtk_menu_append(menu, GTK_WIDGET(menu_item)); gtk_menu_item_set_submenu(app.ui.menu.event.type, GTK_WIDGET(menu)); } app.ui.list_recent_scripts = kry_recent_list_load("Recent File"); app.ui.list_recent_workspaces = kry_recent_list_load("Recent Workspace"); app.ui.list_recent_audio = kry_recent_list_load("Recent Audio"); app.ui.list_recent_videos = kry_recent_list_load("Recent Video"); app.ui.cb_recent_scripts = (GCallback) gui_main_menu_script_openrecent; app.ui.cb_recent_workspaces = (GCallback) gui_workspace_openrecent_cb; app.ui.cb_recent_audio = (GCallback) gui_main_menu_audio_openrecent; app.ui.cb_recent_videos = (GCallback) gui_main_menu_video_openrecent; gui_main_recent_list_update(app.ui.menu.script.open_recent, app.ui.list_recent_scripts, app.ui.cb_recent_scripts); gui_main_recent_list_update(app.ui.menu.script.open_recent_workspace, app.ui.list_recent_workspaces, app.ui.cb_recent_workspaces); gui_main_recent_list_update(app.ui.menu.audio.open_recent, app.ui.list_recent_audio, app.ui.cb_recent_audio); gui_main_recent_list_update(app.ui.menu.video.open_recent, app.ui.list_recent_videos, app.ui.cb_recent_videos); } GtkWidget *text_editor = gui_main_create_text_editor(); GtkWidget *event_editor = gui_main_create_event_editor(); g_object_ref(text_editor); app.ui.wave_pane = GTK_PANED(gtk_vpaned_new()); g_signal_connect(app.ui.wave_pane, "notify::position", G_CALLBACK(gui_main_paned_move_cb), notebook); g_object_ref(vbox_event_edit); app.ui.hbox_list = GTK_HBOX(gtk_hbox_new(FALSE, 0)); app.ui.hbox_wave = GTK_HBOX(gtk_hbox_new(FALSE, 0)); app.ui.event_editor = event_editor; gtk_box_pack_start(GTK_BOX(hbox_table), GTK_WIDGET(event_editor), FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(hbox_table)); gtk_box_pack_start(GTK_BOX(vbox_event_edit), GTK_WIDGET(frame), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_event_edit), text_editor, TRUE, TRUE, 0); { app.ui.vbox_waves = GTK_VBOX(gtk_vbox_new(FALSE, 0)); app.ui.waveform_group = KRY_WAVEFORM_GROUP(kry_waveform_group_new()); app.ui.region_list = KRY_REGION_FIXED_LIST(kry_region_fixed_list_new()); kry_waveform_group_set_toolbar(app.ui.waveform_group, GTK_WIDGET(gui_waveforms_create_simple_toolbar())); kry_waveform_group_set_scrollbar(app.ui.waveform_group, gtk_hscrollbar_new(kry_waveform_group_get_adjustment(app.ui.waveform_group))); if(!app.opts.advanced_waveform_ui) kry_waveform_group_enable_simple_interface(app.ui.waveform_group); gtk_box_pack_start(GTK_BOX(app.ui.vbox_waves), GTK_WIDGET(app.ui.waveform_group), TRUE, TRUE, 0); kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_event_start); kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_event_end); kry_waveform_group_marker_add(app.ui.waveform_group, app.ui.marker_current); kry_waveform_group_marker_set_active_start(app.ui.waveform_group, app.ui.marker_event_start); kry_waveform_group_marker_set_active_end(app.ui.waveform_group, app.ui.marker_event_end); kry_waveform_group_region_add_new(app.ui.waveform_group, app.ui.marker_event_start, app.ui.marker_event_end, WAVEFORM_COLOR_SELECTION_HIGHLIGHT); kry_waveform_group_region_fixed_list_set(app.ui.waveform_group, app.ui.region_list); kry_waveform_group_set_drag_selection(app.ui.waveform_group, app.opts.enable_drag_selection); kry_waveform_group_set_marker_dragging(app.ui.waveform_group, app.opts.enable_marker_dragging); } gtk_container_add(GTK_CONTAINER(app.ui.window), GTK_WIDGET(vbox_super)); GtkWidget *tab_video = gui_main_tab_video_create(); app.ui.event_list = gui_event_list_new(FALSE); gtk_container_add(GTK_CONTAINER(sw), GTK_WIDGET(gui_event_list_get_view(app.ui.event_list))); app.ui.vbox_sub_wave = GTK_VBOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(app.ui.vbox_sub_wave), GTK_WIDGET(app.ui.vbox_waves), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(app.ui.hbox_wave), GTK_WIDGET(app.ui.vbox_sub_wave), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(timing_box), GTK_WIDGET(vbox_text), FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(timing_box), GTK_WIDGET(app.ui.hbox_wave), TRUE, TRUE, 0); app.ui.vbox_list_super = GTK_VBOX(gtk_vbox_new(FALSE, 0)); gtk_paned_add1(paned_list, GTK_WIDGET(vbox_event_edit)); app.ui.vbox_sub_list = GTK_VBOX(gtk_vbox_new(FALSE, 0)); gtk_box_pack_start(GTK_BOX(app.ui.vbox_sub_list), GTK_WIDGET(sw), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(app.ui.hbox_list), GTK_WIDGET(app.ui.vbox_sub_list), TRUE, TRUE, 0); gtk_paned_add2(paned_list, GTK_WIDGET(app.ui.hbox_list)); app.ui.tab_audio_widget = GTK_WIDGET(timing_box); app.ui.tab_video_widget = GTK_WIDGET(tab_video); app.ui.tab_audio_label = GTK_LABEL(gtk_label_new(__("Tab|Audio"))); app.ui.tab_video_label = GTK_LABEL(gtk_label_new(__("Tab|Video"))); gtk_notebook_append_page(notebook, GTK_WIDGET(timing_box), GTK_WIDGET(app.ui.tab_audio_label)); gtk_notebook_append_page(notebook, tab_video, GTK_WIDGET(app.ui.tab_video_label)); // setup the status/progress "tab" { struct KryStatusBar *bar = gui_status_bar_new(); app.ui.status_bar = bar; GtkWidget *widget = gui_status_bar_get_widget(bar); page_progress = GTK_LABEL(gtk_label_new("")); gtk_notebook_append_page(notebook, GTK_WIDGET(page_progress), widget); gtk_notebook_set_tab_label_packing(notebook, GTK_WIDGET(page_progress), TRUE, TRUE, GTK_PACK_START); gui_status_bar_set_text(app.ui.status_bar, STATUS_WELCOME, _("Welcome to Sabbu")); } gtk_paned_add2(paned_notebook, GTK_WIDGET(notebook)); gtk_paned_pack1(app.ui.wave_pane, GTK_WIDGET(paned_notebook), FALSE, FALSE); gtk_paned_pack2(app.ui.wave_pane, GTK_WIDGET(paned_list), TRUE, FALSE); g_object_ref(vbox_notebook); g_object_ref(app.ui.vbox_list_super); gtk_box_pack_start(GTK_BOX(vbox_super), GTK_WIDGET(app.ui.wave_pane), TRUE, TRUE, 0); gui_main_update_sensitivity(); //gtk_widget_set_sensitive(GTK_WIDGET(app.ui.wave_grab_times), FALSE); g_signal_connect(app.ui.window, "map", G_CALLBACK(gui_main_play_button_map), gui_status_bar_get_widget(app.ui.status_bar)); gtk_widget_show_all(GTK_WIDGET(app.ui.window)); gui_waveforms_setup(NULL); { GtkMenu *menu = GTK_MENU(gtk_menu_new()); #ifdef HAVE_ASPELL if(spell_is_available()) { app.ui.speller = spell_create(); GList *list = spell_get_dict_list(); GSList *group = NULL; char *cur = spell_get_current_dict_name(app.ui.speller); for(GList *ptr = list; ptr; ptr = ptr->next) { char *display = spell_get_dict_name_from_code((char *) ptr->data); GtkWidget *item = gtk_radio_menu_item_new_with_label(group, display); group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); if(!strcmp(display, cur)) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(gui_main_spellcheck_language_cb), ptr->data); } if(!list) { GtkWidget *item = gtk_menu_item_new_with_label(_("No Dictionaries Installed")); gtk_widget_set_sensitive(item, FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); } } else { GtkWidget *item = gtk_menu_item_new_with_label(_("Aspell Not Installed")); gtk_widget_set_sensitive(item, FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); } gtk_widget_show_all(GTK_WIDGET(menu)); gtk_menu_item_set_submenu(app.ui.menu.event.spellcheck_language, GTK_WIDGET(menu)); #else GtkWidget *item = gtk_menu_item_new_with_label(_("Aspell Not Enabled")); gtk_widget_set_sensitive(item, FALSE); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); gtk_widget_show_all(GTK_WIDGET(menu)); gtk_menu_item_set_submenu(app.ui.menu.event.spellcheck_language, GTK_WIDGET(menu)); #endif } gui_main_load_color_table(app.ui.waveform_color_table); gui_main_load_color_table(app.ui.list_color_table); gui_main_load_color_table(app.ui.status_bar_color_table); gui_main_load_color_table(app.ui.highlight_color_table); kry_marker_set_value(app.ui.marker_event_start, -1); kry_marker_set_value(app.ui.marker_event_end, -1); gtk_toggle_button_set_active(app.ui.tab_video.button_hide, FALSE); app.ui.ui_mode = UI_MODE_NONE; delete app.script; appObj->ScriptNew(); gui_options_load(); gtk_widget_hide(GTK_WIDGET(app.ui.hbox_hide_channels)); gtk_widget_hide(kry_waveform_group_get_scrollbar(app.ui.waveform_group)); gtk_widget_hide(kry_waveform_group_get_toolbar(app.ui.waveform_group)); gtk_paned_set_position(app.ui.wave_pane, 0); gtk_widget_hide(GTK_WIDGET(app.ui.hbox_karaoke)); gtk_widget_hide(GTK_WIDGET(app.ui.karaoke_vbox_toolbar)); gui_status_bar_hide_progress_bar(app.ui.status_bar); g_signal_connect(notebook, "switch-page", G_CALLBACK(gui_main_notebook_page_changed), NULL); g_signal_connect(notebook, "button-press-event", G_CALLBACK(gui_main_notebook_button_press_cb), NULL); if(app.opts.two_button_mode) { gtk_widget_hide(GTK_WIDGET(app.ui.hbox_start_1)); gtk_widget_hide(GTK_WIDGET(app.ui.hbox_end_1)); } GtkWidget *syntax_widget = gui_text_editor_get_syntax_highlight_controls(app.ui.text_editor); int min_height = GTK_WIDGET(frame)->allocation.height + 40; int pos = app.prefs->GetInt("TextEditorPanedPos", -1); g_object_set_data(G_OBJECT(paned_notebook), "sabbu-min-size", (gpointer) min_height); g_object_set_data(G_OBJECT(paned_list), "sabbu-min-size", (gpointer) min_height); if(pos == -1) { if(app.opts.text_editor_top) gtk_paned_set_position(paned_notebook, min_height); else gtk_paned_set_position(paned_list, min_height); } else { if(app.opts.text_editor_top) gtk_paned_set_position(paned_notebook, pos); else gtk_paned_set_position(paned_list, pos); } gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.script.save_workspace_as), FALSE); gtk_widget_set_sensitive(GTK_WIDGET(app.ui.menu.script.close_workspace), FALSE); g_signal_connect(app.ui.paned_list, "notify::position", G_CALLBACK(gui_main_text_paned_move_cb), NULL); g_signal_connect(app.ui.paned_notebook, "notify::position", G_CALLBACK(gui_main_text_paned_move_cb), NULL); g_timeout_add(1000*60*5, gui_main_script_autosave, NULL); //g_timeout_add(250*60, gui_main_script_autosave, NULL); g_signal_connect(gui_event_list_get_view(app.ui.event_list), "key-press-event", G_CALLBACK(gui_main_key_press), NULL); }