xref: /dports/multimedia/sabbu/sabbu-0.3.0/Source/gui_main.cpp

/*
 *	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 "<main_menu>%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);
}