/* 
 *	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 "gui_main_style.h"
#include "gui_main_tab_video.h"
#include "gui_text_editor.h"
#include "gui_event_list.h"
#include "sub_preview.h"
#include "stringutils.h"
#include "sound.h" 

// TODO: use proper width/height
extern struct sabbu app;
struct gui_main_tab_video *tab_video = &app.ui.tab_video;
GdkRectangle *subRect = &app.ui.tab_video.subRect;
int *posx = &app.ui.tab_video.posx;
int *posy = &app.ui.tab_video.posy;
int *orgx = &app.ui.tab_video.orgx;
int *orgy = &app.ui.tab_video.orgy;
gboolean *doUpdate = &app.ui.tab_video.doUpdate;
gboolean *doMove = &app.ui.tab_video.doMove;
int width;
int height;

int sub_pos_x(int align)
{
  if(align % 3 == 0)
    return subRect->x + subRect->width;
  else if(align % 3 == 1)
    return subRect->x;
  else if(align % 3 == 2)
    return subRect->x + (subRect->width + 1) / 2;

  return 1337; // lalala make the compiler happy
}

int sub_pos_y(int align)
{
  if(align >= 1 && align <= 3)
    return subRect->y + subRect->height;
  else if(align >= 4 && align <= 6)
    return subRect->y + (subRect->height + 1) / 2;
  else if(align >= 7 && align <= 9)
    return subRect->y;

  return 1337; // damn dumb computers...
}

char *sub_replace_pos(char *str, int x, int y)
{
  char *val, *ptr = str;
  if(strlen(str) < 7)
    return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, str);

  if(strncmp(str, "{\\pos(", 6))
    return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, str);

  val = string_read_token(&ptr, ',');
  if(!val)
    return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, str);
  kry_free(val);

  val = string_read_token(&ptr, ')');
  if(!val)
    return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, str);
  kry_free(val);

  if(ptr[0] == 0 || ptr[0] != '}')
    return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, str);

  return kry_strdup_printf(KRY_LOC  "{\\pos(%d,%d)}%s", x, y, ptr + 1);
}

gboolean sub_extract_pos(char *str, GdkPoint *point)
{
  char *ptr = strstr(str, "{\\pos(");
  char *val;
  int x, y;
  if(!ptr)
    return FALSE;

  ptr += 6;

  val = string_read_token(&ptr, ',');
  if(!val)
    return FALSE;

  x = atoi(val);
  kry_free(val);

  val = string_read_token(&ptr, ')');
  if(!val)
    return FALSE;

  y = atoi(val);
  kry_free(val);

  if(ptr[0] == 0 || ptr[0] != '}')
    return FALSE;

  point->x = x;
  point->y = y;

  return TRUE;
}

kryStyle *sub_get_style()
{
  char *text = KRY_TS(gtk_combo_box_get_active_text(app.ui.combo_style));
  kryStyle *style = app.script->GetStyle(text);
  if(!style)
    style = app.script->GetStyle("Default");
  kry_free(text);
    
  return style;
}

gboolean gui_main_tab_video_move_cb(GtkWidget *widget, GdkEventButton *button, int direction)
{
  kryStyle *style = sub_get_style();
  int dx = 0, dy = 0;
  if(direction % 3 == 1)
    dx = -1;
  else if(direction % 3 == 2)
    dx = 0;
  else if(direction % 3 == 0)
    dx = 1;

  if(direction >= 1 && direction <= 3)
    dy = 1;
  else if(direction >= 4 && direction <= 6)
    dy = 0;
  else if(direction >= 7 && direction <= 9)
    dy = -1;

  if(button->state & GDK_CONTROL_MASK)
  {
    dx *= 10;
    dy *= 10;
  }

  if(subRect->width == 0 || subRect->height == 0)
    return FALSE;

  if(*posx == -1)
    *posx = sub_pos_x(style->GetAlignment());
  if(*posy == -1)
    *posy = sub_pos_y(style->GetAlignment());

  *posx += dx;
  *posy += dy;

  *doUpdate = TRUE;
  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
  while(gtk_events_pending())
    gtk_main_iteration();
  *doUpdate = FALSE;

  return FALSE;
}

gboolean gtk_main_tab_video_key_press_cb(GtkWidget *widget, GdkEventKey *key)
{
  GdkEventButton button;
  int dir = 0;

  button.state = key->state;

  if(key->keyval == GDK_Left)
    dir = 4;
  else if(key->keyval == GDK_Right)
    dir = 6;
  else if(key->keyval == GDK_Up)
    dir = 8;
  else if(key->keyval == GDK_Down)
    dir = 2;

  if(dir != 0)
    gui_main_tab_video_move_cb(widget, &button, dir);

  return TRUE;
}

void gtk_main_tab_video_press_cb(GtkWidget *widget, GdkEventButton *button)
{
  int playresx = 384, playresy = 288;
  kryStyle *style = sub_get_style();
  char *val;
  int rx, ry, rw, rh;

  if((val = app.script->GetProperty("PlayResX")))
    playresx = atoi(val);

  if((val = app.script->GetProperty("PlayResY")))
    playresy = atoi(val);

  gtk_widget_grab_focus(widget);

  button->x /= app.ui.tab_video.zoomf;
  button->y /= app.ui.tab_video.zoomf;

  rx = (int) ((subRect->x / (double) playresx) * width);
  ry = (int) ((subRect->y / (double) playresy) * height);
  rw = (int) ((subRect->width / (double) playresx) * width);
  rh = (int) ((subRect->height / (double) playresy) * height);

  if  (button->x >= rx && button->x <= rx + rw
    && button->y>= ry && button->y <= ry + rh)
  {
    *doMove = TRUE;
    *orgx = (int) (button->x - (sub_pos_x(style->GetAlignment()) / (double) playresx) * width);
    *orgy = (int) (button->y - (sub_pos_y(style->GetAlignment()) / (double) playresy) * height);
  }
  else
  {
    *doMove = FALSE;
  }
}

void gtk_main_tab_video_release_cb(GtkWidget *widge, GdkEventButton *button)
{
}

void gtk_main_tab_video_motion_cb(GtkWidget *widge, GdkEventMotion *motion)
{
  int dx, dy;
  int playresx = 384, playresy = 288;
  char *val;
  if(!*doMove)
    return;

  motion->x /= app.ui.tab_video.zoomf;
  motion->y /= app.ui.tab_video.zoomf;

  dx = *posx;
  dy = *posy;

  if((val = app.script->GetProperty("PlayResX")))
    playresx = atoi(val);

  if((val = app.script->GetProperty("PlayResY")))
    playresy = atoi(val);

  *posx = (int) (((motion->x - *orgx) / (double) width) * playresx);
  *posy = (int) (((motion->y - *orgy) / (double) height) * playresy);

  dx -= *posx;
  dy -= *posy;

  if(app.ui.tab_video.showGrid)
  {
    int every_x = app.ui.tab_video.grid_interval_x;
    int every_y = app.ui.tab_video.grid_interval_y;
    int snap = app.ui.tab_video.grid_snap_distance;

    if((subRect->x - dx) % every_x <= snap)
      *posx -= (((subRect->x - dx) % every_x) - 1);

    if((subRect->y - dy) % every_y <= snap)
      *posy -= (((subRect->y - dy) % every_y) - 1);
  }

  *doUpdate = TRUE;
  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
  while(gtk_events_pending())
    gtk_main_iteration();
  *doUpdate = FALSE;
}

void gtk_main_tab_video_expose_cb(GtkWidget *widget, GdkEventExpose *event, gpointer blahdah)
{
  AVPicture pict;
  int rv;
  int i;
  GdkPixbuf *pixbuf;
  unsigned char *data;
  char *text;
  char *style = kry_strdup("Default");
  char *new_str;
  kryStyle *style_cur;
  GdkPoint point;
  char *val;
  gboolean render_sub = TRUE;
  gboolean need_free = FALSE;
  double zoom;
  GtkRequisition size_request;
  int playresx, playresy;

  if(gtk_notebook_get_current_page(app.ui.notebook) != NOTEBOOK_PAGE_VIDEO)
    return;

  width = 640;
  height = 480;

  if(!app.script)
    return;

  if(app.ui.video_drawing)
    return;

  app.ui.video_drawing = TRUE;
  
  style_cur = sub_get_style();

  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(app.ui.tab_video.button_video)) && app.ui.tab_video.video)
  {
    if(kry_marker_get_value(app.ui.tab_video.marker_start) == -1)
      kry_marker_set_value(app.ui.tab_video.marker_start, 0);

    width = video_get_width(app.ui.tab_video.video);
    height = video_get_height(app.ui.tab_video.video);
    if(kry_marker_get_value(app.ui.tab_video.marker_start) != kry_marker_get_value(app.ui.tab_video.marker_start_prev))
    {
      rv = video_seek(app.ui.tab_video.video, kry_marker_get_value(app.ui.tab_video.marker_start));
      if(!rv)
      {
        kry_free(style);
        app.ui.video_drawing = FALSE;
        return; // draw 'could not seek'
      }

      if(!video_get_picture(app.ui.tab_video.video, &pict))
      {
        kry_free(style);
        app.ui.video_drawing = FALSE;
        return;
      }

      // todo: free pic when video closed
      if(app.ui.tab_video.pict.data[0])
        kry_free(app.ui.tab_video.pict.data[0]);

      app.ui.tab_video.pict = pict;
      kry_marker_set_value(app.ui.tab_video.marker_start_prev, kry_marker_get_value(app.ui.tab_video.marker_start));
    }
    else
    {
      pict = app.ui.tab_video.pict;
    }

  }
  else
  {
    int color = app.ui.tab_video.color_solid;
    pict.data[0] = (uint8_t*) kry_malloc(4 * width * height);

    color = ((color & 0x00FF0000) >> 16) | ((color & 0x000000FF) << 16) | (color & 0x0000FF00);
    for(i = 0; i < width * height; i++)
      ((int *) pict.data[0])[i] = color;

    need_free = TRUE;
  }

  if((val = app.script->GetProperty("PlayResX")))
    playresx = atoi(val);

  if((val = app.script->GetProperty("PlayResY")))
    playresy = atoi(val);


  data = (unsigned char *) kry_malloc(4 * width * height);
  memcpy(data, pict.data[0], 4 * width * height);

  text = gui_text_editor_get_text(app.ui.text_editor);

  char *style_name = KRY_TS(gtk_combo_box_get_active_text(app.ui.combo_style));
  if(app.script->GetStyle(style_name))
  {
    kry_free(style);
    style = style_name;
  }

  

  if(!*doUpdate && sub_extract_pos(text, &point))
  {
    *posx = point.x;
    *posy = point.y;
  }

  if(*posx != -1 && *posy != -1)
  {
    new_str = sub_replace_pos(text, *posx, *posy);
    if(strcmp(text, new_str))
      gui_text_editor_set_text(app.ui.text_editor, new_str);
  }
  else
  {
    new_str = kry_strdup(text);
  }

    playresx = 384;
    playresy = 288;

    if((val = app.script->GetProperty("PlayResX")))
      playresx = atoi(val);

    if((val = app.script->GetProperty("PlayResY")))
      playresy = atoi(val);

#ifdef _WINDOWS
    subtest_init(width, height, playresx, playresy);
#endif

    if(render_sub)
    {
      long start, end, margin_left = 0, margin_right = 0, margin_vertical = 0;
      
      start = kry_marker_get_value(app.ui.marker_active_start);
      if(start == -1)
        start = 0;
      
      end = kry_marker_get_value(app.ui.marker_active_end);
      if(end == -1)
        end = LONG_MAX - 1;

      GtkTreeModel *model;
      GtkTreeSelection *selection = gtk_tree_view_get_selection(gui_event_list_get_view(app.ui.event_list));
      GList *sel_items = gtk_tree_selection_get_selected_rows(selection, &model);
      if(sel_items)
      {
        kryEventDetailed *event;
        GtkTreePath *path = (GtkTreePath *) sel_items->data;
        GtkTreeIter iter;
        gtk_tree_model_get_iter(model, &iter, path);
        gtk_tree_model_get(model, &iter, PTR_COLUMN, &event, -1);
        margin_left = event->GetMarginLeft();
        margin_right = event->GetMarginRight();
        margin_vertical = event->GetMarginVertical();

        g_list_foreach (sel_items, (GFunc) gtk_tree_path_free, NULL);
        g_list_free(sel_items);
      }

#ifdef _WINDOWS
      subtest_set(new_str, app.script->GetStyle((char *) style), start, end, 
        gtk_spin_button_get_value_as_int(app.ui.spin_layer),
        margin_left, margin_right, margin_vertical);
#endif
    }

  if(app.ui.tab_video.showGrid)
  {
    int x,y, index;
    int every_x = app.ui.tab_video.grid_interval_x;
    int every_y = app.ui.tab_video.grid_interval_y;
    for(x = every_x - 1; x < playresx - 1; x += every_x)
    {
      for(y = 0; y < playresy - 1; y++)
      {
        int rx = (int) ((x / (double) playresx) * width);
        int ry = (int) ((y / (double) playresy) * height);

        index = ry * width * 4 + rx * 4;
        data[index] = 192;
        data[index+1] = 192;
        data[index+2] = 192;
      }
    }

    for(y = every_y - 1; y < playresy - 1; y += every_y)
    {
      for(x = 0; x < playresx - 1; x++)
      {
        int rx = (int) ((x / (double) playresx) * width);
        int ry = (int) ((y / (double) playresy) * height);

        index = ry * width * 4 + rx * 4;
        data[index] = 192;
        data[index+1] = 192;
        data[index+2] = 192;
      }
    }

  }

  if(render_sub)
  {
    long time = kry_marker_get_value(app.ui.tab_video.marker_start);
    if(time == -1)
      time = 0;

#ifdef _WINDOWS
    *subRect = subtest_do((char *) data, width, height, time);
#endif
    
    subRect->x = (int) ((subRect->x / (double) width) * playresx);
    subRect->width = (int) ((subRect->width / (double) width) * playresx);

    subRect->y = (int) ((subRect->y / (double) height) * playresy);
    subRect->height = (int) ((subRect->height / (double) height) * playresy);
  }

  if(*posx != -1)
  {
    if(style_cur->GetAlignment() % 3 == 2)
      subRect->x = (*posx - (subRect->width + 1) / 2);
    else if(style_cur->GetAlignment() % 3 == 1)
      subRect->x = *posx;
    else
      subRect->x = (*posx - subRect->width);
  }

  if(*posy != -1)
  {
    if(style_cur->GetAlignment() >= 1 && style_cur->GetAlignment() <= 3)
      subRect->y = *posy - subRect->height;
    else if(style_cur->GetAlignment() >= 4 && style_cur->GetAlignment() <= 6)
      subRect->y = (*posy - (subRect->height + 1) / 2);
    else
      subRect->y = *posy;
  }


  kry_free(new_str);

#ifdef _WINDOWS
  subtest_uninit();
#endif

  for(i = 0; i + 2 < 4 * width * height; i+= 4)
  {
    char temp = data[i];
    data[i] = data[i+2];
    data[i+2] = temp;
  }

  for(i = 0; i + 3 < 4 * width * height; i+= 4)
    data[i+3] = 255;

  pixbuf = gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE, 8, width, height, width * 4, NULL, NULL);
  zoom = app.ui.tab_video.zoomf;
  if(zoom != 1)
  {
    GdkPixbuf *pixbuf_copy = gdk_pixbuf_scale_simple(pixbuf, (int) (width * zoom), (int) (height * zoom), GDK_INTERP_NEAREST);
    g_object_unref(pixbuf);
    pixbuf = pixbuf_copy;
  }

  gtk_widget_size_request(GTK_WIDGET(app.ui.video_area), &size_request);
  if(size_request.width != width * zoom || size_request.height != height * zoom)
    gtk_widget_set_size_request(GTK_WIDGET(app.ui.video_area), (int) (width * zoom), (int) (height * zoom));
  gdk_draw_pixbuf(GTK_WIDGET(app.ui.video_area)->window, NULL, pixbuf, 0, 0, 0, 0, (int) (width * zoom), (int) (height * zoom), GDK_RGB_DITHER_NORMAL, 0, 0);
  g_object_unref(pixbuf);

  if(need_free)
    kry_free(pict.data[0]);

  kry_free(data);
  kry_free(text);
  kry_free(style);

  app.ui.video_drawing = FALSE;

}

void gui_main_tab_video_jump_start_cb(GtkWidget *widget, gpointer data)
{
  long time;
  if(app.ui.tab_video.sync_audio && app.ui.tab_video.video)
    return;

  time = kry_marker_get_value(app.ui.marker_event_start);
  if(time == -1)
    time = 0;

  kry_marker_set_value(app.ui.tab_video.marker_start, time);
}

void gui_main_tab_video_jump_end_cb(GtkWidget *widget, gpointer data)
{
  long time;
  if(app.ui.tab_video.sync_audio && app.ui.tab_video.video)
    return;

  time = kry_marker_get_value(app.ui.marker_event_end);
  if(time == -1)
    time = 0;

  kry_marker_set_value(app.ui.tab_video.marker_start, time);
}

void gui_main_tab_video_zoomin_cb(GtkWidget *widget, gpointer data)
{
  app.ui.tab_video.zoomf *= 2;
  if(app.ui.tab_video.zoomf > 4.5)
    app.ui.tab_video.zoomf = 4;

  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
}

void gui_main_tab_video_zoomout_cb(GtkWidget *widget, gpointer data)
{
  app.ui.tab_video.zoomf /= 2;
  if(app.ui.tab_video.zoomf < 0.20)
    app.ui.tab_video.zoomf = 0.25;

  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
}

void gui_main_tab_video_lock_cb(GtkWidget *widget, gpointer data)
{
  gboolean is_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
  app.ui.tab_video.sync_audio = is_active;

  if(is_active)
  {
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_forward1), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_forward10), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_back1), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_back10), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_jump_start), FALSE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_jump_end), FALSE);
    kry_marker_set_value(app.ui.tab_video.marker_start, kry_marker_get_value(app.ui.marker_active_start));
    if(app.ui.video_area)
      gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
  }
  else
  {
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_forward1), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_forward10), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_back1), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_back10), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_jump_start), TRUE);
    gtk_widget_set_sensitive(GTK_WIDGET(app.ui.tab_video.button_jump_end), TRUE);
  }
}

void gui_main_tab_video_seek_cb(GdkEventButton *event, int offset /* ms */)
{
  long time;
  if(app.ui.tab_video.sync_audio && app.ui.tab_video.video || app.ui.video_drawing)
    return;

  time = kry_marker_get_value(app.ui.tab_video.marker_start);
  if(time == -1)
    time = 0;

  time += offset;

  if(time < 0)
    time = 0;

  kry_marker_set_value(app.ui.tab_video.marker_start, time);
}

void gui_main_tab_video_video_cb(GtkWidget *widget, gpointer data)
{
  if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
    return;

  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
}

void gui_main_tab_video_solid_cb(GtkWidget *widget, gpointer data)
{
  if(!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
    return;

  gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
}

void gui_main_tab_video_player_marker_changed_cb(KryMarker *marker, long old_position, gpointer data)
{
  char *str = time_mili_to_string(kry_marker_get_value(marker), app.ui.ui_mode == UI_MODE_SRT);
  if(app.ui.tab_video.entry_time)
    gtk_entry_set_text(app.ui.tab_video.entry_time, str);
  kry_free(str);

  if(app.ui.video_area)
    gtk_widget_queue_draw(GTK_WIDGET(app.ui.video_area));
}

void gui_main_tab_video_marker_changed_cb(KryMarker *marker, long old_position, gpointer data)
{
  kry_marker_set_value(app.ui.tab_video.marker_start, kry_marker_get_value(marker));
}

void gui_main_tab_video_style_hide(GtkWidget *widget, GtkWidget *widget_affected)
{
  GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
  while(children)
  {
    gtk_container_remove(GTK_CONTAINER(widget), GTK_WIDGET(children->data));
    children = children->next;
  }

  if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
  {
    gtk_container_add(GTK_CONTAINER(widget), gtk_image_new_from_pixbuf(app.ui.pixbufs.show));
    gtk_widget_show(GTK_WIDGET(widget_affected));
  }
  else
  {
    gtk_container_add(GTK_CONTAINER(widget), gtk_image_new_from_pixbuf(app.ui.pixbufs.hide));
    gtk_widget_hide(GTK_WIDGET(widget_affected));
  }

  gtk_widget_show_all(widget);
}


GtkWidget* gui_main_tab_video_create()
{
  GtkTable *table = GTK_TABLE(gtk_table_new(3, 3, 0));
  GtkHBox *hbox = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  GtkVBox *vbox_appearence = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  GtkVBox *vbox_transformations = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  
  GtkButton *button_up = GTK_BUTTON(gtk_button_new());
  GtkButton *button_up_left = GTK_BUTTON(gtk_button_new());
  GtkButton *button_down = GTK_BUTTON(gtk_button_new());
  GtkButton *button_down_left = GTK_BUTTON(gtk_button_new());
  GtkButton *button_left = GTK_BUTTON(gtk_button_new());
  GtkButton *button_up_right = GTK_BUTTON(gtk_button_new());
  GtkButton *button_right = GTK_BUTTON(gtk_button_new());
  GtkButton *button_down_right = GTK_BUTTON(gtk_button_new());

  gtk_container_add(GTK_CONTAINER(button_up), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_up)));
  gtk_container_add(GTK_CONTAINER(button_up_left), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_up_left)));
  gtk_container_add(GTK_CONTAINER(button_down), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_down)));
  gtk_container_add(GTK_CONTAINER(button_down_left), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_down_left)));
  gtk_container_add(GTK_CONTAINER(button_left), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_left)));
  gtk_container_add(GTK_CONTAINER(button_up_right), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_up_right)));
  gtk_container_add(GTK_CONTAINER(button_right), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_right)));
  gtk_container_add(GTK_CONTAINER(button_down_right), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.sarrow_down_right)));

  GtkScrolledWindow *sw = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
  GtkFrame *frame_alignment = GTK_FRAME(gtk_frame_new(__("Style|Alignment")));
  GtkFrame *frame_margins = GTK_FRAME(gtk_frame_new(__("Style|Margins")));
  GtkFrame *frame_colors = GTK_FRAME(gtk_frame_new(__("Style|Colors")));
  GtkFrame *frame_border = GTK_FRAME(gtk_frame_new(__("Style|Border")));
  GtkHBox *toolbar = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkButton *button_lock = GTK_BUTTON(gtk_toggle_button_new_with_label("sabbu-lock"));
  GtkButton *button_back1 = GTK_BUTTON(gtk_button_new());
  GtkButton *button_forward1 = GTK_BUTTON(gtk_button_new());
  GtkButton *button_back10 = GTK_BUTTON(gtk_button_new());
  GtkButton *button_forward10 = GTK_BUTTON(gtk_button_new());
  GtkEntry *entry_time = GTK_ENTRY(gtk_entry_new());
  GtkHBox *hbox_zoom = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkHBox *hbox_nav = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkNotebook *notebook = GTK_NOTEBOOK(gtk_notebook_new());
  GtkProgressBar *progress_bar = GTK_PROGRESS_BAR(gtk_progress_bar_new());
  GtkButton *button_video = GTK_BUTTON(gtk_radio_button_new_with_label(NULL, __("VideoBackround|Video")));
  GSList *group_video = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button_video));
  GtkButton *button_solid = GTK_BUTTON(gtk_radio_button_new_with_label(group_video, __("VideoBackround|Solid Color")));
  GtkButton *button_solid_color;
  GtkVBox *vbox_notebook = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  GtkHBox *hbox_align = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkVBox *vbox_notebook_hide = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  GtkHBox *hbox_hide_style = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkVBox *vbox_align = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  char *str;
  struct gui_main_style_editor *ui = &app.ui.style_editor;

  gtk_container_add(GTK_CONTAINER(button_back1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left)));
  gtk_container_add(GTK_CONTAINER(button_back10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_left2)));
  gtk_container_add(GTK_CONTAINER(button_forward1), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right)));
  gtk_container_add(GTK_CONTAINER(button_forward10), GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.time_right2)));
  gtk_button_set_use_stock(GTK_BUTTON(button_lock), TRUE);

  GtkButton *button_jump_start = GTK_BUTTON(gtk_button_new_from_stock("sabbu-jump-start"));
  GtkButton *button_jump_end = GTK_BUTTON(gtk_button_new_from_stock("sabbu-jump-end"));
  GtkButton *button_zoomin = GTK_BUTTON(gtk_button_new_from_stock("sabbu-zoom-in"));
  GtkButton *button_zoomout = GTK_BUTTON(gtk_button_new_from_stock("sabbu-zoom-out"));

  app.ui.tab_video.posx = -1;
  app.ui.tab_video.posy = -1;
  app.ui.tab_video.orgx = -1;
  app.ui.tab_video.orgy = -1;
  app.ui.tab_video.grid_interval_x = 20;
  app.ui.tab_video.grid_interval_y = 20;
  app.ui.tab_video.grid_snap_distance = 5;
  app.ui.tab_video.zoomf = 1;
  app.ui.tab_video.color_solid = 0x00FFFFFF;

  app.ui.tab_video.marker_start = KRY_MARKER(kry_marker_new(MARKER_START, 10));
  app.ui.tab_video.marker_start_prev = KRY_MARKER(kry_marker_new(MARKER_START, 10));

  g_signal_connect(app.ui.marker_event_start, "value-changed", G_CALLBACK(gui_main_tab_video_marker_changed_cb), NULL);
  g_signal_connect(app.ui.tab_video.marker_start, "value-changed", G_CALLBACK(gui_main_tab_video_player_marker_changed_cb), NULL);

  gtk_widget_set_sensitive(GTK_WIDGET(button_video), FALSE);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_solid), TRUE);

  g_signal_connect(button_video, "toggled", G_CALLBACK(gui_main_tab_video_video_cb), NULL);
  g_signal_connect(button_solid, "toggled", G_CALLBACK(gui_main_tab_video_solid_cb), NULL);

  app.ui.tab_video.button_back1 = button_back1;
  app.ui.tab_video.button_forward1 = button_forward1;
  app.ui.tab_video.button_back10 = button_back10;
  app.ui.tab_video.button_forward10 = button_forward10;
  app.ui.tab_video.button_lock = button_lock;
  app.ui.tab_video.button_video = button_video;
  app.ui.tab_video.button_solid = button_solid;

  struct hold_button_callback_info *info_start_less1 = kry_new0(struct hold_button_callback_info);
  info_start_less1->func = (kryButtonCallback) gui_main_tab_video_seek_cb;
  info_start_less1->data = (gpointer) - 10;
  g_signal_connect(button_back1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less1);
  g_signal_connect(button_back1, "released", G_CALLBACK(gui_main_hold_button_release), info_start_less1);

  struct hold_button_callback_info *info_start_more1 = kry_new0(struct hold_button_callback_info);
  info_start_more1->func = (kryButtonCallback) gui_main_tab_video_seek_cb;
  info_start_more1->data = (gpointer) 10;
  g_signal_connect(button_forward1, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more1);
  g_signal_connect(button_forward1, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more1);

  struct hold_button_callback_info *info_start_less10 = kry_new0(struct hold_button_callback_info);
  info_start_less10->func = (kryButtonCallback) gui_main_tab_video_seek_cb;
  info_start_less10->data = (gpointer) -100;
  g_signal_connect(button_back10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_less10);
  g_signal_connect(button_back10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_less10);

  struct hold_button_callback_info *info_start_more10 = kry_new0(struct hold_button_callback_info);
  info_start_more10->func = (kryButtonCallback) gui_main_tab_video_seek_cb;
  info_start_more10->data = (gpointer) 100;
  g_signal_connect(button_forward10, "button-press-event", G_CALLBACK(gui_main_hold_button_press), info_start_more10);
  g_signal_connect(button_forward10, "released", G_CALLBACK(gui_main_hold_button_release), info_start_more10);

  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_back1), _("Rewind 0.01s"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_forward1), _("Forward 0.01s"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_back10), _("Rewind 0.1s"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_forward10), _("Forward 0.1s"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_zoomin), _("Zoom In"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_zoomout), _("Zoom Out"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_video), _("Use Video as Background"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_solid), _("Use Solid Color as Background"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_lock), _("Sync with Event Start Marker"), NULL);

  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_up), _("Move Text Up"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_left), _("Move Text Left"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_right), _("Move Text Right"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_down), _("Move Text Down"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_up_left), _("Move Text Up & Left"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_up_right), _("Move Text Up & Right"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_down_left), _("Move Text Down & Left"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_down_right), _("Move Text Down & Right"), NULL);


  gtk_button_set_relief(button_lock, GTK_RELIEF_NONE);
  gtk_button_set_relief(button_zoomin, GTK_RELIEF_NONE);
  gtk_button_set_relief(button_zoomout, GTK_RELIEF_NONE);

  gtk_box_pack_start(GTK_BOX(hbox_nav), GTK_WIDGET(button_back10), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_nav), GTK_WIDGET(button_back1), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_nav), GTK_WIDGET(entry_time), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_nav), GTK_WIDGET(button_forward1), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_nav), GTK_WIDGET(button_forward10), FALSE, TRUE, 0);

  str = time_mili_to_string(0);
  gtk_widget_set_sensitive(GTK_WIDGET(entry_time), FALSE);
  gtk_entry_set_editable(entry_time, FALSE);
  gtk_entry_set_width_chars(entry_time, 12);
  gtk_entry_set_text(entry_time, str);
  kry_free(str);

  GtkHBox *hbox_jump = GTK_HBOX(gtk_hbox_new(FALSE, 0));

  gtk_widget_set_sensitive(GTK_WIDGET(button_jump_start), FALSE);
  gtk_widget_set_sensitive(GTK_WIDGET(button_jump_end), FALSE);


  app.ui.tab_video.button_jump_start = button_jump_start;
  app.ui.tab_video.button_jump_end = button_jump_end;

  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_jump_start), _("Seek to Event Start Time"), NULL);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_jump_end), _("Seek to Event End Time"), NULL);

  gtk_button_set_relief(button_jump_start, GTK_RELIEF_NONE);
  gtk_button_set_relief(button_jump_end, GTK_RELIEF_NONE);

  gtk_box_pack_start(GTK_BOX(hbox_jump), GTK_WIDGET(button_jump_start), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_jump), GTK_WIDGET(button_jump_end), FALSE, TRUE, 0);

  gtk_box_pack_start(GTK_BOX(hbox_zoom), GTK_WIDGET(button_zoomin), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_zoom), GTK_WIDGET(button_zoomout), FALSE, TRUE, 0);

  GtkButton *button_hide = GTK_BUTTON(gtk_toggle_button_new());
  gtk_container_add(GTK_CONTAINER(button_hide), gtk_image_new_from_pixbuf(app.ui.pixbufs.show));
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_hide), TRUE);
  gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_hide), __("HideStyleEditor|Hide"), NULL);
  gtk_box_pack_start(GTK_BOX(vbox_notebook_hide), GTK_WIDGET(vbox_notebook), FALSE, TRUE, 0);
  g_signal_connect(button_hide, "toggled", G_CALLBACK(gui_main_tab_video_style_hide), vbox_notebook);
  app.ui.tab_video.button_hide = GTK_TOGGLE_BUTTON(button_hide);


  gtk_box_pack_start(GTK_BOX(hbox_hide_style), GTK_WIDGET(gtk_label_new(NULL)), TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_hide_style), GTK_WIDGET(button_hide), FALSE, TRUE, 0);

  kryColorTable *color_table = new kryColorTable(TAB_VIDEO_COLOR_COUNT);
  app.ui.style_color_table = color_table;
  
  color_table->Set(TAB_VIDEO_COLOR_BACKGROUND, "TabVideoBackground", NULL, 0xFF, 0xFF, 0xFF);
  button_solid_color = gui_main_color_button_new(NULL, color_table->Get(TAB_VIDEO_COLOR_BACKGROUND));

  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(button_lock), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(hbox_nav), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(hbox_jump), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(hbox_zoom), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(progress_bar), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(button_video), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(button_solid), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(button_solid_color), FALSE, TRUE, 4);
  gtk_box_pack_start(GTK_BOX(toolbar), GTK_WIDGET(hbox_hide_style), TRUE, TRUE, 4);

  gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), FALSE, TRUE, 0);

  g_signal_connect(button_lock, "toggled", G_CALLBACK(gui_main_tab_video_lock_cb), NULL);


  g_signal_connect(button_zoomin, "clicked", G_CALLBACK(gui_main_tab_video_zoomin_cb), NULL);
  g_signal_connect(button_zoomout, "clicked", G_CALLBACK(gui_main_tab_video_zoomout_cb), NULL);

  g_signal_connect(button_jump_start, "clicked", G_CALLBACK(gui_main_tab_video_jump_start_cb), NULL);
  g_signal_connect(button_jump_end, "clicked", G_CALLBACK(gui_main_tab_video_jump_end_cb), NULL);

  gtk_widget_set_sensitive(GTK_WIDGET(button_lock), FALSE);

  app.ui.tab_video.entry_time = entry_time;
  app.ui.tab_video.progress_bar = progress_bar;


  // setup style picker frame
  {
    GtkVBox *vbox_style = GTK_VBOX(gtk_vbox_new(FALSE, 0));
    GtkHBox *hbox_buttons = GTK_HBOX(gtk_hbox_new(FALSE, 0));
    GtkButton *button_new = GTK_BUTTON(gtk_button_new_from_stock("sabbu-new"));
    GtkButton *button_rename = GTK_BUTTON(gtk_button_new_from_stock("sabbu-edit"));
    GtkButton *button_delete = GTK_BUTTON(gtk_button_new_from_stock("sabbu-delete"));
    GtkButton *button_manager = GTK_BUTTON(gtk_button_new_from_stock("sabbu-manager"));
    GtkFrame *frame_style = GTK_FRAME(gtk_frame_new(_("Style")));
    GtkHBox *hbox_combo = GTK_HBOX(gtk_hbox_new(FALSE, 0));

    g_signal_connect(button_new, "clicked", G_CALLBACK(gui_main_style_new_cb), NULL);
    g_signal_connect(button_rename, "clicked", G_CALLBACK(gui_main_style_rename_cb), NULL);
    g_signal_connect(button_delete, "clicked", G_CALLBACK(gui_main_style_delete_cb), NULL);
    g_signal_connect(button_manager, "clicked", G_CALLBACK(gui_main_style_manager_cb), NULL);

    gtk_box_pack_start(GTK_BOX(hbox_buttons), GTK_WIDGET(button_new), TRUE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(hbox_buttons), GTK_WIDGET(button_rename), TRUE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(hbox_buttons), GTK_WIDGET(button_manager), TRUE, FALSE, 2);
    gtk_box_pack_start(GTK_BOX(hbox_buttons), GTK_WIDGET(button_delete), TRUE, FALSE, 2);

    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_new), __("StyleEditor|New Style"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_rename), __("StyleEditor|Rename Style"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_manager), __("StyleEditor|Manage Styles"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(button_delete), __("StyleEditor|Delete Style"), NULL);

    
    ui->combo_style = GTK_COMBO_BOX(gtk_combo_box_new_text());
    gtk_combo_box_set_model(ui->combo_style, GTK_TREE_MODEL(app.ui.style_store));

    gtk_box_pack_start(GTK_BOX(hbox_combo), GTK_WIDGET(ui->combo_style), TRUE, TRUE, 2);

    gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(hbox_combo), TRUE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(vbox_style), GTK_WIDGET(hbox_buttons), FALSE, TRUE, 2);

    gtk_container_add(GTK_CONTAINER(frame_style), GTK_WIDGET(vbox_style));
    g_signal_connect(ui->combo_style, "changed", G_CALLBACK(gui_main_style_changed_cb), NULL);

    gtk_box_pack_start(GTK_BOX(vbox_notebook), GTK_WIDGET(frame_style), FALSE, TRUE, 0);
  }

  // setup font frame
  {
    GtkButton *button_font = GTK_BUTTON(gtk_button_new_with_label("..."));
    GtkFrame *frame_font = GTK_FRAME(gtk_frame_new(_("Font")));
    app.ui.style_editor.entry_font_name = GTK_ENTRY(gtk_entry_new());

    ui->button_font_bold = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label("sabbu-bold"));
    ui->button_font_italic = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label("sabbu-italic"));
    ui->button_font_underline = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label("sabbu-underline"));
    ui->button_font_strikethrough = GTK_TOGGLE_BUTTON(gtk_toggle_button_new_with_label("sabbu-strikethrough"));
    ui->spin_font_size = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 999, 1));

    gtk_button_set_relief(GTK_BUTTON(ui->button_font_bold), GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(ui->button_font_italic), GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(ui->button_font_underline), GTK_RELIEF_NONE);
    gtk_button_set_relief(GTK_BUTTON(ui->button_font_strikethrough), GTK_RELIEF_NONE);

    gtk_button_set_use_stock(GTK_BUTTON(ui->button_font_bold), TRUE);
    gtk_button_set_use_stock(GTK_BUTTON(ui->button_font_italic), TRUE);
    gtk_button_set_use_stock(GTK_BUTTON(ui->button_font_underline), TRUE);
    gtk_button_set_use_stock(GTK_BUTTON(ui->button_font_strikethrough), TRUE);

    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->button_font_bold), _("Bold"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->button_font_italic), _("Italic"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->button_font_underline), _("Underline"), NULL);
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->button_font_strikethrough), _("Strikethrough"), NULL);

    gtk_entry_set_width_chars(app.ui.style_editor.entry_font_name, 20);

    GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));

    GtkHBox *hbox_font1 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
    gtk_box_pack_start(GTK_BOX(hbox_font1), GTK_WIDGET(ui->entry_font_name), FALSE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(hbox_font1), GTK_WIDGET(ui->spin_font_size), FALSE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(hbox_font1), GTK_WIDGET(button_font), FALSE, TRUE, 2);

    GtkHBox *hbox_font2 = GTK_HBOX(gtk_hbox_new(FALSE, 0));
    gtk_box_pack_start(GTK_BOX(hbox_font2), GTK_WIDGET(ui->button_font_bold), TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox_font2), GTK_WIDGET(ui->button_font_italic), TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox_font2), GTK_WIDGET(ui->button_font_underline), TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox_font2), GTK_WIDGET(ui->button_font_strikethrough), TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox_font1), FALSE, TRUE, 2);
    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox_font2), FALSE, TRUE, 2);

    gtk_container_add(GTK_CONTAINER(frame_font), GTK_WIDGET(vbox));
    gtk_box_pack_start(GTK_BOX(vbox_appearence), GTK_WIDGET(frame_font), FALSE, TRUE, 0);

    g_signal_connect(button_font, "clicked", G_CALLBACK(gui_main_style_font_cb), NULL);
    g_signal_connect(ui->spin_font_size, "value-changed", G_CALLBACK(gui_main_style_font_size_cb), NULL);
    g_signal_connect(ui->button_font_bold, "toggled", G_CALLBACK(gui_main_style_bold_cb), NULL);
    g_signal_connect(ui->button_font_italic, "toggled", G_CALLBACK(gui_main_style_italic_cb), NULL);
    g_signal_connect(ui->button_font_underline, "toggled", G_CALLBACK(gui_main_style_underline_cb), NULL);
    g_signal_connect(ui->button_font_strikethrough, "toggled", G_CALLBACK(gui_main_style_strikethrough_cb), NULL);

    gtk_entry_set_editable(ui->entry_font_name, FALSE);
  }

  // setup alignment frame
  {
    GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
    GSList *group = NULL;
    GtkTable *table = GTK_TABLE(gtk_table_new(3, 3, FALSE));
    int i;

    GdkPixbuf *captions[9] = { 
      app.ui.pixbufs.sarrow_down_left, app.ui.pixbufs.sarrow_down, app.ui.pixbufs.sarrow_down_right, 
      app.ui.pixbufs.sarrow_left, app.ui.pixbufs.sarrow_center, app.ui.pixbufs.sarrow_right, 
      app.ui.pixbufs.sarrow_up_left, app.ui.pixbufs.sarrow_up, app.ui.pixbufs.sarrow_up_right
    };

    for(i = 0; i < 9; i++)
    {
      GtkImage *image = GTK_IMAGE(gtk_image_new_from_pixbuf(captions[i]));
      ui->button_align[i] = GTK_RADIO_BUTTON(gtk_radio_button_new(group));
      gtk_container_add(GTK_CONTAINER(ui->button_align[i]), GTK_WIDGET(image));
      gtk_toggle_button_set_mode(GTK_TOGGLE_BUTTON(ui->button_align[i]), FALSE);
      group = gtk_radio_button_get_group(ui->button_align[i]);

      if(i == 1)
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->button_align[1]), TRUE);

      gtk_table_attach_defaults(table, GTK_WIDGET(ui->button_align[i]), i % 3, i % 3 + 1, 2 - i / 3, 2 - (i / 3) + 1);

      g_signal_connect(ui->button_align[i], "toggled", G_CALLBACK(gui_main_align_changed_cb), (gpointer) (i + 1));
    }
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->button_align[1]), TRUE);

    gtk_container_set_border_width(GTK_CONTAINER(table), 4);

    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, TRUE, 0);

    gtk_container_set_border_width(GTK_CONTAINER(frame_alignment), 0);
    gtk_container_add(GTK_CONTAINER(frame_alignment), GTK_WIDGET(vbox));
    gtk_box_pack_start(GTK_BOX(vbox_align), GTK_WIDGET(hbox_align), FALSE, TRUE, 2);


    gtk_box_pack_start(GTK_BOX(vbox_align), GTK_WIDGET(frame_alignment), FALSE, TRUE, 2);

    
  }

  // setup margin frame
  {
    GtkTable *table = GTK_TABLE(gtk_table_new(3, 2, FALSE));
    GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));

    gtk_container_set_border_width(GTK_CONTAINER(table), 4);
    gtk_table_set_col_spacings(table, 4);

    ui->spin_margin_left = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 9999, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_margin_left), _("Left Margin"), NULL);

    ui->spin_margin_right = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 9999, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_margin_right), _("Right Margin"), NULL);

    ui->spin_margin_vertical = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 9999, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_margin_vertical), _("Vertical Margin"), NULL);

    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.margin_left)), 0, 1, 0, 1);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_margin_left), 1, 2, 0, 1);

    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.margin_right)), 0, 1, 1, 2);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_margin_right), 1, 2, 1, 2);

    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.margin_vertical)), 0, 1, 2, 3);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_margin_vertical), 1, 2, 2, 3);

    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, TRUE, 0);

    gtk_container_add(GTK_CONTAINER(frame_margins), GTK_WIDGET(vbox));
    gtk_box_pack_start(GTK_BOX(hbox_align), GTK_WIDGET(frame_margins), FALSE, TRUE, 2);

    g_signal_connect(ui->spin_margin_left, "value-changed", G_CALLBACK(gui_main_margin_changed_cb), NULL);
    g_signal_connect(ui->spin_margin_right, "value-changed", G_CALLBACK(gui_main_margin_changed_cb), NULL);
    g_signal_connect(ui->spin_margin_vertical, "value-changed", G_CALLBACK(gui_main_margin_changed_cb), NULL);
  }

  gtk_box_pack_start(GTK_BOX(vbox_transformations), GTK_WIDGET(vbox_align), FALSE, TRUE, 0);

  // setup font transformations frame
  {
    GtkVBox *vbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
    GtkFrame *frame = GTK_FRAME(gtk_frame_new(__("Style|Font")));
    GtkTable *table = GTK_TABLE(gtk_table_new(3, 2, FALSE));

    ui->frame_style_font = frame;

    gtk_container_set_border_width(GTK_CONTAINER(table), 4);
    gtk_table_set_col_spacings(table, 4);

    ui->spin_angle = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(-3600, 3600, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_angle), _("Angle"), NULL);
    gtk_spin_button_set_digits(ui->spin_angle, 2);
    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.angle)), 0, 1, 0, 1);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_angle), 1, 2, 0, 1);

    ui->spin_scalex = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 1000, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_scalex), _("Horizontal Scaling"), NULL);
    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.scalex)), 0, 1, 1, 2);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_scalex), 1, 2, 1, 2);

    ui->spin_scaley = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 1000, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_scaley), _("Vertical Scaling"), NULL);
    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.scaley)), 0, 1, 2, 3);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_scaley), 1, 2, 2, 3);

    ui->spin_spacing = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 100, 1));
    gtk_tooltips_set_tip(app.ui.tooltips, GTK_WIDGET(ui->spin_spacing), _("Spacing"), NULL);
    gtk_table_attach_defaults(table, GTK_WIDGET(gtk_image_new_from_pixbuf(app.ui.pixbufs.spacing)), 0, 1, 4, 5);
    gtk_table_attach_defaults(table, GTK_WIDGET(ui->spin_spacing), 1, 2, 4, 5);

    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, TRUE, 0);
    gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(vbox));
    gtk_box_pack_start(GTK_BOX(hbox_align), GTK_WIDGET(frame), FALSE, TRUE, 2);

    g_signal_connect(ui->spin_scalex, "value-changed", G_CALLBACK(gui_main_scalex_changed_cb), NULL);
    g_signal_connect(ui->spin_scaley, "value-changed", G_CALLBACK(gui_main_scaley_changed_cb), NULL);
    g_signal_connect(ui->spin_spacing, "value-changed", G_CALLBACK(gui_main_spacing_changed_cb), NULL);
    g_signal_connect(ui->spin_angle, "value-changed", G_CALLBACK(gui_main_angle_changed_cb), NULL);
  }

  {
    // setup colors frame
    GtkTable *table = GTK_TABLE(gtk_table_new(2, 4, 0));
    GtkLabel *label_primary = GTK_LABEL(gtk_label_new(__("StyleColor|Primary:")));
    GtkLabel *label_secondary = GTK_LABEL(gtk_label_new(__("StyleColor|Secondary:")));
    GtkLabel *label_tertiary = GTK_LABEL(gtk_label_new(__("StyleColor|Tertiary:")));
    GtkLabel *label_outline = GTK_LABEL(gtk_label_new(__("StyleColor|Outline:")));
    GtkLabel *label_shadow = GTK_LABEL(gtk_label_new(__("StyleColor|Shadow:")));
    GtkLabel *label_back = GTK_LABEL(gtk_label_new(__("StyleColor|Back:")));

    GtkButton *button_primary;
    GtkButton *button_secondary;
    GtkButton *button_tertiary;
    GtkButton *button_outline;
    GtkButton *button_shadow;
    GtkButton *button_back;


    gtk_misc_set_alignment(GTK_MISC(label_primary), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_secondary), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_tertiary), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_outline), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_shadow), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_back), 1.0, 0.5);

    gtk_misc_set_padding(GTK_MISC(label_primary), 2, 0);
    gtk_misc_set_padding(GTK_MISC(label_secondary), 2, 0);
    gtk_misc_set_padding(GTK_MISC(label_tertiary), 2, 0);
    gtk_misc_set_padding(GTK_MISC(label_outline), 2, 0);
    gtk_misc_set_padding(GTK_MISC(label_shadow), 2, 0);
    gtk_misc_set_padding(GTK_MISC(label_back), 2, 0);

    color_table->Set(TAB_VIDEO_COLOR_PRIMARY, NULL, NULL, 0xFF, 0xFF, 0xFF);
    color_table->Set(TAB_VIDEO_COLOR_SECONDARY, NULL, NULL, 0xFF, 0xFF, 0);
    color_table->Set(TAB_VIDEO_COLOR_TERTIARY, NULL, NULL, 0xFF, 0xFF, 0);
    color_table->Set(TAB_VIDEO_COLOR_OUTLINE, NULL, NULL, 0, 0, 0);
    color_table->Set(TAB_VIDEO_COLOR_SHADOW, NULL, NULL, 0, 0, 0);
    color_table->Set(TAB_VIDEO_COLOR_BACK, NULL, NULL, 0, 0, 0);
    color_table->EnableOpacity();
    color_table->Get(TAB_VIDEO_COLOR_BACKGROUND)->DisableOpacity();

    button_primary = gui_main_color_button_new(&app.ui.style_editor.draw_primary, color_table->Get(TAB_VIDEO_COLOR_PRIMARY));
    button_secondary = gui_main_color_button_new(&app.ui.style_editor.draw_secondary, color_table->Get(TAB_VIDEO_COLOR_SECONDARY));
    button_tertiary = gui_main_color_button_new(&app.ui.style_editor.draw_tertiary, color_table->Get(TAB_VIDEO_COLOR_TERTIARY));
    button_outline = gui_main_color_button_new(&app.ui.style_editor.draw_outline, color_table->Get(TAB_VIDEO_COLOR_OUTLINE));
    button_shadow = gui_main_color_button_new(&app.ui.style_editor.draw_shadow, color_table->Get(TAB_VIDEO_COLOR_SHADOW));
    button_back = gui_main_color_button_new(&app.ui.style_editor.draw_back, color_table->Get(TAB_VIDEO_COLOR_BACK));

    ui->label_tertiary = label_tertiary;
    ui->label_outline = label_outline;
    ui->label_shadow = label_shadow;
    ui->label_back = label_back;

    ui->button_tertiary = button_tertiary;
    ui->button_outline = button_outline;
    ui->button_shadow = button_shadow;
    ui->button_back = button_back;

    color_table->ConnectSignal(kryColorTable::SIGNAL_COLOR_CHANGED, (krySignalFunc0) gui_main_style_color_changed_cb);

    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_primary), 0, 1, 0, 1);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_primary), 1, 2, 0, 1);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_secondary), 2, 3, 0, 1);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_secondary), 3, 4, 0, 1);

    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_outline), 0, 1, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_outline), 1, 2, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_tertiary), 0, 1, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_tertiary), 1, 2, 1, 2);

    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_shadow), 2, 3, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_shadow), 3, 4, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(label_back), 2, 3, 1, 2);
    gtk_table_attach_defaults(GTK_TABLE(table), GTK_WIDGET(button_back), 3, 4, 1, 2);

    gtk_container_set_border_width(GTK_CONTAINER(table), 2);

    gtk_container_add(GTK_CONTAINER(frame_colors), GTK_WIDGET(table));
    gtk_box_pack_start(GTK_BOX(vbox_appearence), GTK_WIDGET(frame_colors), FALSE, TRUE, 0);
  }

  // setup alpha level frame

  {
    // setup frame border frame
    GtkTable *table = GTK_TABLE(gtk_table_new(2, 2, 0));
    GtkHBox *box = GTK_HBOX(gtk_hbox_new(FALSE, 0));
    GtkHBox *hbox_combo = GTK_HBOX(gtk_hbox_new(FALSE, 0));
    GtkVBox *vbox_combo = GTK_VBOX(gtk_vbox_new(FALSE, 0));
    GtkLabel *label_r = GTK_LABEL(gtk_label_new(__("Style|Size:")));
    GtkLabel *label_v = GTK_LABEL(gtk_label_new(__("Style|Distance:")));
    GtkComboBox *combo = GTK_COMBO_BOX(gtk_combo_box_new_text());
    ui->spin_border_size = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 100, 1));
    ui->spin_shadow_size = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(0, 100, 1));

    gtk_spin_button_set_digits(ui->spin_border_size, 2);
    gtk_spin_button_set_digits(ui->spin_shadow_size, 2);

    gtk_combo_box_append_text(combo, __("StyleBorder|Outline"));
    gtk_combo_box_append_text(combo, __("StyleBorder|Opaque Box"));

    gtk_widget_set_size_request(GTK_WIDGET(combo), 80, -1);

    gtk_misc_set_alignment(GTK_MISC(label_r), 1.0, 0.5);
    gtk_misc_set_alignment(GTK_MISC(label_v), 1.0, 0.5);

    gtk_table_attach_defaults(table, GTK_WIDGET(label_r), 0, 1, 0, 1);
    gtk_table_attach(table, GTK_WIDGET(ui->spin_border_size), 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
    gtk_table_attach_defaults(table, GTK_WIDGET(label_v), 0, 1, 1, 2);
    gtk_table_attach(table, GTK_WIDGET(ui->spin_shadow_size), 1, 2, 1, 2, GTK_FILL, GTK_FILL, 0, 0);

    gtk_box_pack_start(GTK_BOX(hbox_combo), GTK_WIDGET(combo), TRUE, TRUE, 6);
    gtk_box_pack_start(GTK_BOX(vbox_combo), GTK_WIDGET(hbox_combo), TRUE, FALSE, 0);

    gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(vbox_combo), FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(table), TRUE, TRUE, 0);

    g_signal_connect(combo, "changed", G_CALLBACK(gui_main_border_style_changed_cb), NULL);
    g_signal_connect(ui->spin_border_size, "value-changed", G_CALLBACK(gui_main_margin_changed_cb), NULL);
    g_signal_connect(ui->spin_shadow_size, "value-changed", G_CALLBACK(gui_main_margin_changed_cb), NULL);

    ui->combo_border = combo;

    gtk_container_add(GTK_CONTAINER(frame_border), GTK_WIDGET(box));

    gtk_box_pack_start(GTK_BOX(vbox_appearence), GTK_WIDGET(frame_border), FALSE, TRUE, 0);
  }




  app.ui.tab_video.vbox_notebook = GTK_WIDGET(vbox_notebook);

  gtk_notebook_append_page(notebook, GTK_WIDGET(vbox_appearence), gtk_label_new(__("StyleEditorTab|Appearance")));
  gtk_notebook_append_page(notebook, GTK_WIDGET(vbox_transformations), gtk_label_new(__("StyleEditorTab|Transformations")));


  app.ui.video_area = GTK_DRAWING_AREA(gtk_drawing_area_new());
  g_object_set(app.ui.video_area, "can-focus", TRUE, NULL);
  gtk_widget_add_events(GTK_WIDGET(app.ui.video_area), GDK_BUTTON_PRESS_MASK 
    | GDK_BUTTON_RELEASE_MASK 
    | GDK_BUTTON_MOTION_MASK
    | GDK_KEY_PRESS_MASK
    | GDK_KEY_RELEASE_MASK);

  g_signal_connect (G_OBJECT (app.ui.video_area), "expose_event",  
                    G_CALLBACK (gtk_main_tab_video_expose_cb), NULL);
  g_signal_connect (G_OBJECT(app.ui.video_area), "button-press-event", G_CALLBACK(gtk_main_tab_video_press_cb), NULL);
  g_signal_connect (G_OBJECT(app.ui.video_area), "button-release-event", G_CALLBACK(gtk_main_tab_video_release_cb), NULL);
  g_signal_connect (G_OBJECT(app.ui.video_area), "motion-notify-event", G_CALLBACK(gtk_main_tab_video_motion_cb), NULL);
  g_signal_connect (G_OBJECT(app.ui.video_area), "key-press-event", G_CALLBACK(gtk_main_tab_video_key_press_cb), NULL);


  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), GTK_WIDGET(app.ui.video_area));
  gtk_widget_set_size_request(GTK_WIDGET(app.ui.video_area), 640, 480);
  gtk_widget_set_size_request(GTK_WIDGET(sw), 400, -1);

  GtkHBox *hbox_video = GTK_HBOX(gtk_hbox_new(FALSE, 0));
  GtkVBox *vbox_control = GTK_VBOX(gtk_vbox_new(FALSE, 0));
  GtkFrame *frame_move = GTK_FRAME(gtk_frame_new(__("Subtitle|Move")));

  gtk_container_add(GTK_CONTAINER(frame_move), GTK_WIDGET(table));
  gtk_box_pack_start(GTK_BOX(vbox_control), GTK_WIDGET(frame_move), FALSE, TRUE, 0);
  
  gtk_box_pack_start(GTK_BOX(hbox_video), GTK_WIDGET(vbox_control), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox_video), GTK_WIDGET(sw), TRUE, TRUE, 0);

  gtk_button_set_relief((button_up_left), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_up), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_up_right), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_left), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_right), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_down_left), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_down), GTK_RELIEF_NONE);
  gtk_button_set_relief((button_down_right), GTK_RELIEF_NONE);

  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_up_left), 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_up), 1, 2, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_up_right), 2, 3, 0, 1, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_left), 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_right), 2, 3, 1, 2, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_down_left), 0, 1, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_down), 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
  gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(button_down_right), 2, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0);

  gtk_box_pack_start(GTK_BOX(vbox_notebook), GTK_WIDGET(notebook), TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(hbox_video), TRUE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox_notebook_hide), FALSE, TRUE, 0);
  gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), TRUE, TRUE, 0);
  

  g_signal_connect(button_up_left, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 7);
  g_signal_connect(button_up, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 8);
  g_signal_connect(button_up_right, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 9);
  g_signal_connect(button_left, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 4);
  g_signal_connect(button_right, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 6);
  g_signal_connect(button_down_left, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 1);
  g_signal_connect(button_down, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 2);
  g_signal_connect(button_down_right, "button-release-event", G_CALLBACK(gui_main_tab_video_move_cb), (gpointer) 3);

  return GTK_WIDGET(vbox);
}