gui/main.c

   1 #include <gtk/gtk.h>
   2 #include <gdk/gdkkeysyms.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <stdarg.h>
   6 #include "../src/mark.h"
   7 #ifdef WITH_OPENCV
   8 #include "../src/opticalflow.h"
   9 #endif
  10 #include "main.h"
  11 #include "menu.h"
  12 #include "toolbar.h"
  13 #include "image.h"
  14 #include "palette.h"
  15 #include "timeline.h"
  16 #include "colorize.h"
  17 #include "brightcontrast.h"
  18 #include "level.h"
  19 #include "fill.h"
  20 #ifdef WITH_OPENCV
  21 #include "flow.h"
  22 #endif
  23
  24 #define CC_APP_TITLE "Colorize GTK"
  25 GtkWidget *main_window;
  26 GtkWidget *img_scroll;
  27 GtkWidget *img_drawing_area = NULL;
  28 GtkWidget *timeline_drawing_area;
  29 GtkWidget *timeline_scroll;
  30 GtkWidget *palette_treeview = NULL;
  31 GtkLabel *img_label;
  32 GtkToggleButton *show_highlighted_button, *show_preview_button, *show_colorized_button;
  33 #ifdef WITH_OPENCV
  34 GtkToggleButton *show_flow_button;
  35 #endif
  36 int button_down = 0, button_down_x = -1000, button_down_y = -1000, shift_pressed = 0, button_num = 1;
  37 int brush_size;
  38 int highlight = 0, preview = 0, rendered = 0, draw_mode = 1, move_mode = 0, fill_mode = 0, pick_mode = 0, flowview = 0;
  39 int mouse_over_palette_area = 0, mouse_over_drawing_area = 0, mouse_over_timeline_area = 0;
  40 #define min(x,y) ((x < y) ? x : y)
  41 #define abs(x,y) ((x < y) ? y - x : x - y)
  42
  43 /* error requester */
  44 void printerror(const char *fmt, ...)
  45 {
  46         char buffer[4096];
  47         va_list args;
  48
  49         va_start(args,fmt);
  50         vsprintf(buffer,fmt,args);
  51         buffer[sizeof(buffer)-1]=0;
  52         va_end(args);
  53
  54         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
  55                 GTK_DIALOG_DESTROY_WITH_PARENT,
  56                 GTK_MESSAGE_ERROR,
  57                 GTK_BUTTONS_CLOSE,
  58                 "%s", buffer);
  59         gtk_dialog_run (GTK_DIALOG (dialog));
  60         gtk_widget_destroy (dialog);
  61 }
  62
  63 static int already_destroyed = 0;
  64
  65 /* exit program and save current mask / palette */
  66 void main_destroy(void)
  67 {
  68         if (anything_modified) {
  69                 int ret;
  70                 GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
  71                         GTK_DIALOG_DESTROY_WITH_PARENT,
  72                         GTK_MESSAGE_ERROR,
  73                         GTK_BUTTONS_OK_CANCEL,
  74                         "Image has been changed, really quit?");
  75                 ret = gtk_dialog_run(GTK_DIALOG (dialog));
  76                 gtk_widget_destroy(dialog);
  77                 if (ret != GTK_RESPONSE_OK)
  78                         return;
  79         }
  80         already_destroyed = 1;
  81         gtk_main_quit();
  82 }
  83
  84
  85 static void destroy(GtkWidget *widget, gpointer data)
  86 {
  87         if (!already_destroyed)
  88                 main_destroy();
  89 }
  90
  91 /*
  92  * keypress
  93  */
  94
  95 /* event handler for main window keys */
  96 static gboolean on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
  97 {
  98         int frame;
  99
 100 //      if (mouse_over_palette_area)
 101         if (!mouse_over_drawing_area && !mouse_over_timeline_area)
 102                 return FALSE;
 103
 104         switch (event->keyval) {
 105         case GDK_q:
 106         case GDK_w:
 107                 if (event->state & GDK_CONTROL_MASK) {
 108                         main_destroy();
 109                         return TRUE;
 110                 }
 111                 break;
 112         case GDK_Right:
 113                 frame = timeline_selected + 1;
 114                 if (event->state & GDK_SHIFT_MASK) {
 115                         while(frame < timeline_frames && frame_list[frame].marked == 0 && frame_list[frame].keyframe == 0)
 116                                 frame++;
 117                 }
 118                 if (frame < timeline_frames)
 119                         timeline_select_and_save(timeline_selected, frame);
 120                 return TRUE;
 121         case GDK_Left:
 122                 frame = timeline_selected - 1;
 123                 if (event->state & GDK_SHIFT_MASK) {
 124                         while(frame >= 0 && frame_list[frame].marked == 0 && frame_list[frame].keyframe == 0)
 125                                 frame--;
 126                 }
 127                 if (frame >= 0)
 128                         timeline_select_and_save(timeline_selected, frame);
 129                 return TRUE;
 130         case GDK_Home:
 131                 frame = 0;
 132                 timeline_select_and_save(timeline_selected, frame);
 133                 return TRUE;
 134         case GDK_End:
 135                 frame = timeline_frames - 1;
 136                 timeline_select_and_save(timeline_selected, frame);
 137                 return TRUE;
 138         case GDK_u:
 139         case GDK_z:
 140                 undo_event(NULL);
 141                 return TRUE;
 142         case GDK_r:
 143                 redo_event(NULL);
 144                 return TRUE;
 145         case GDK_c:
 146                 if (event->state & GDK_CONTROL_MASK) {
 147                         copy_event(NULL);
 148                         return TRUE;
 149                 }
 150                 break;
 151         case GDK_v:
 152                 if (event->state & GDK_CONTROL_MASK) {
 153                         paste_event(NULL);
 154                         return TRUE;
 155                 }
 156                 break;
 157         case GDK_k:
 158                 toggle_keyframe();
 159                 return TRUE;
 160         case GDK_Shift_L:
 161         case GDK_Shift_R:
 162                 shift_pressed = 1;
 163                 break;
 164 //      default:
 165 //              printf("press %x\n", event->keyval);
 166         }
 167
 168         return FALSE;
 169 }
 170
 171 /* event handler for main window keys */
 172 static gboolean on_key_release(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 173 {
 174         switch (event->keyval) {
 175         case GDK_Shift_L:
 176         case GDK_Shift_R:
 177                 shift_pressed = 0;
 178                 break;
 179 //      default:
 180 //              printf("release %x\n", event->keyval);
 181         }
 182
 183         return FALSE;
 184 }
 185
 186 /*
 187  * image area
 188  */
 189
 190 /* events if mouse is over palette area */
 191 static gboolean enter_palette_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 192 {
 193         mouse_over_palette_area = 1;
 194         return FALSE;
 195 }
 196 static gboolean leave_palette_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 197 {
 198         mouse_over_palette_area = 0;
 199         return FALSE;
 200 }
 201
 202 /* events if mouse is over image area */
 203 static gboolean enter_drawing_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 204 {
 205         mouse_over_drawing_area = 1;
 206         return FALSE;
 207 }
 208 static gboolean leave_drawing_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 209 {
 210         mouse_over_drawing_area = 0;
 211         return FALSE;
 212 }
 213
 214 /* events if mouse is over timeline area */
 215 static gboolean enter_timeline_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 216 {
 217         mouse_over_timeline_area = 1;
 218         return FALSE;
 219 }
 220 static gboolean leave_timeline_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 221 {
 222         mouse_over_timeline_area = 0;
 223         timeline_point(-1, -1);
 224         return FALSE;
 225 }
 226
 227 /* ugly non-bresenham.... */
 228 static void draw_line(int x, int y, int paint)
 229 {
 230         double step_x = 0, step_y = 0;
 231
 232         if (abs(x,button_down_x) > abs(y,button_down_y)) {
 233                 while(42) {
 234                         if (button_down_x < x) {
 235                                 step_x++;
 236                                 step_y += (double)(button_down_y - y) / (double)(button_down_x - x);
 237                         } else {
 238                                 step_x--;
 239                                 step_y -= (double)(button_down_y - y) / (double)(button_down_x - x);
 240                         }
 241                         paint_brush(button_down_x+step_x, button_down_y+step_y, brush_size, paint);
 242                         draw_image(button_down_x+step_x-(brush_size*img_scale_x/16)+1, button_down_y+step_y-(brush_size*img_scale_y/16)+1, brush_size*2*img_scale_x/16, brush_size*2*img_scale_y/16);
 243                         if (x == button_down_x+step_x)
 244                                 break;
 245                 }
 246         } else {
 247                 while(42) {
 248                         if (y == button_down_y) /* no move at all */
 249                                 break;
 250                         if (button_down_y < y) {
 251                                 step_y++;
 252                                 step_x += (double)(button_down_x - x) / (double)(button_down_y - y);
 253                         } else {
 254                                 step_y--;
 255                                 step_x -= (double)(button_down_x - x) / (double)(button_down_y - y);
 256                         }
 257                         paint_brush(button_down_x+step_x, button_down_y+step_y, brush_size, paint);
 258                         draw_image(button_down_x+step_x-(brush_size*img_scale_x/16)+1, button_down_y+(step_y-brush_size*img_scale_y/16)+1, brush_size*2*img_scale_x/16, brush_size*2*img_scale_y/16);
 259                         if (y == button_down_y+step_y)
 260                                 break;
 261                 }
 262         }
 263         paint_brush(x, y, brush_size, paint);
 264         draw_image(x-(brush_size*img_scale_x/16)+1, y-(brush_size*img_scale_y/16)+1, brush_size*2*img_scale_x/16, brush_size*2*img_scale_y/16);
 265         button_down_x = x;
 266         button_down_y = y;
 267 }
 268
 269 /* notify movement of mouse inside image area */
 270 static gint motion_notify_event( GtkWidget *widget,
 271                                  GdkEventMotion *event )
 272 {
 273         int x, y;
 274         GdkModifierType state;
 275
 276         if (event->is_hint)
 277                 gdk_window_get_pointer (event->window, &x, &y, &state);
 278         else
 279         {
 280                 x = event->x;
 281                 y = event->y;
 282                 state = event->state;
 283         }
 284
 285         if ((state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK))) {
 286                 if (button_down && pick_mode) {
 287                         pick_color(x, y);
 288                 }
 289                 if (button_down && !pick_mode) {
 290                         if (move_mode) {
 291                                 move_mark((x-button_down_x)*16/img_scale_x, (y-button_down_y)*16/img_scale_y);
 292                                 draw_image(0, 0, -1, -1);
 293                         } else
 294                         if (draw_mode) {
 295                                 draw_line(x, y, button_num == 1);
 296                         }
 297                 }
 298         } else {
 299                 if (button_down && pick_mode)
 300                         release_pick_mode();
 301                 button_down = 0;
 302         }
 303
 304         return TRUE;
 305 }
 306
 307 /* button press event inside image area */
 308 static gint button_press_event (GtkWidget *widget, GdkEventButton *event)
 309 {
 310         int x,y;
 311
 312         x = event->x;
 313         y = event->y;
 314         button_num = event->button;
 315
 316         if (!button_down && !pick_mode)
 317                 copy_mark_to_undo();
 318         if (pick_mode) {
 319                 pick_color(x, y);
 320         } else
 321         if (fill_mode) {
 322                 if (button_down)
 323                         return TRUE;
 324                 fill(x, y, event->button != 1);
 325                 draw_image(0, 0, -1, -1);
 326         } else
 327         if (move_mode) {
 328                 if (button_down)
 329                         return TRUE;
 330                 button_down_x = x;
 331                 button_down_y = y;
 332         } else
 333         if (draw_mode) {
 334                 /* if not shift, draw a dot and not a line */
 335                 if (!shift_pressed || button_down_x == -1000) {
 336                         button_down_x = x;
 337                         button_down_y = y;
 338                 }
 339                 draw_line(x, y, button_num == 1);
 340         }
 341         button_down = 1;
 342         return TRUE;
 343 }
 344
 345 /* redraw event of image area */
 346 static gint img_expose_event (GtkWidget *widget, GdkEventExpose *event)
 347 {
 348         draw_image(event->area.x, event->area.y, event->area.width, event->area.height);
 349
 350         return FALSE;
 351 }
 352
 353 /*
 354  * timeline
 355  */
 356
 357 /* mouse move event inside timeline */
 358 static gint timeline_motion_notify_event( GtkWidget *widget,
 359                                  GdkEventMotion *event )
 360 {
 361         int x, y;
 362         GdkModifierType state;
 363
 364         if (event->is_hint)
 365                 gdk_window_get_pointer (event->window, &x, &y, &state);
 366         else
 367         {
 368                 x = event->x;
 369                 y = event->y;
 370                 state = event->state;
 371         }
 372
 373         timeline_point(x, y);
 374
 375         if ((state & GDK_BUTTON1_MASK)) {
 376                 timeline_clicked(x, y);
 377
 378         }
 379
 380         return TRUE;
 381 }
 382
 383 /* button press event inside timeline area */
 384 static gint timeline_press_event (GtkWidget *widget, GdkEventButton *event)
 385 {
 386         int x,y;
 387
 388         x = event->x;
 389         y = event->y;
 390         timeline_clicked(x, y);
 391
 392         return TRUE;
 393 }
 394
 395 /* redraw event of timeline area */
 396 static gint timeline_expose_event (GtkWidget *widget, GdkEventExpose *event)
 397 {
 398         draw_timeline(event->area.x, event->area.y, event->area.width, event->area.height);
 399
 400         return FALSE;
 401 }
 402
 403 /*
 404  * colorselection
 405  */
 406
 407 GtkWidget *colorseldlg = NULL;
 408 GtkColorSelection *colorsel;
 409 /* color selection's buttons have been pressed */
 410 void color_response(GtkDialog *dialog, gint response_id, gpointer user_data)
 411 {
 412         GdkColor ncolor;
 413
 414         switch (response_id) {
 415         case GTK_RESPONSE_CANCEL:
 416                 gtk_color_selection_get_previous_color(colorsel, &ncolor);
 417 new_color:
 418                 anything_modified = 1;
 419
 420                 mark_palette[mark_selected].r = ncolor.red / 256;
 421                 mark_palette[mark_selected].g = ncolor.green / 256;
 422                 mark_palette[mark_selected].b = ncolor.blue / 256;
 423                 update_color(mark_selected);
 424                 draw_image(0, 0, -1, -1);
 425                 break;
 426         case GTK_RESPONSE_OK:
 427                 gtk_color_selection_get_current_color(colorsel, &ncolor);
 428                 goto new_color;
 429         }
 430 }
 431
 432 /*
 433  * palette
 434  */
 435
 436 /* palette entry has been clicked */
 437 void palette_change(GtkTreeSelection *selection, gpointer data)
 438 {
 439         GtkTreeModel     *model;
 440         GtkTreeIter       iter;
 441
 442         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 443         {
 444                 gchar *name;
 445
 446                 gtk_tree_model_get (model, &iter, 0/*column*/, &name, -1);
 447                 mark_selected = atoi(name) - 1;
 448                 g_free(name);
 449
 450                 if (colorseldlg) {
 451                         GdkColor color;
 452
 453                         color.red = mark_palette[mark_selected].r * 256 + 128;
 454                         color.green = mark_palette[mark_selected].g * 256 + 128;
 455                         color.blue = mark_palette[mark_selected].b * 256 + 128;
 456
 457                         if (colorseldlg) {
 458                                 gtk_color_selection_set_previous_color (colorsel, &color);
 459                                 gtk_color_selection_set_current_color (colorsel, &color);
 460                         }
 461                 }
 462
 463                 /* set current color for bightness+contrast window */
 464                 bc_set_current();
 465
 466                 /* set current levels in window */
 467                 level_set_current();
 468
 469                 if (highlight || preview)
 470                         draw_image(0, 0, -1, -1);
 471         }
 472 }
 473
 474 /* name of palette entry has been entered */
 475 void palette_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, GtkTreeView *treeview)
 476 {
 477         anything_modified = 1;
 478
 479         /* copy string */
 480         strncpy(mark_palette[mark_selected].name, new_text, sizeof(mark_palette[mark_selected].name));
 481         mark_palette[mark_selected].name[sizeof(mark_palette[mark_selected].name)-1] = '\0';
 482
 483         /* store string */
 484         GtkTreeIter iter;
 485         GtkTreeModel *model;
 486
 487         model = gtk_tree_view_get_model (treeview);
 488         if (gtk_tree_model_get_iter_from_string (model, &iter, path))
 489                 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2/*column*/, mark_palette[mark_selected].name, -1);
 490
 491         if (preview)
 492                 draw_image(0, 0, -1, -1);
 493 }
 494
 495 /*
 496  * creation of main window
 497  */
 498
 499 int main(int argc, char *argv[])
 500 {
 501         GtkWidget *vbox, *tool_bar;
 502         GtkWidget *paned;
 503         GtkWidget *pal_scroll;
 504         GtkWidget *menu_bar;
 505         GtkTreeSelection *selection;
 506         GtkTreeViewColumn *palette_column;
 507         GtkCellRenderer *palette_renderer;
 508
 509         gtk_init(&argc, &argv);
 510
 511         main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 512         gtk_widget_set_size_request(GTK_WIDGET(main_window), 400, 200);
 513         gtk_window_set_default_size(GTK_WINDOW(main_window), 800, 500);
 514         gtk_window_set_title(GTK_WINDOW(main_window), CC_APP_TITLE " Version "
 515 #include "../version.h"
 516         );
 517         g_signal_connect(main_window, "delete-event", G_CALLBACK(destroy), NULL);
 518         g_signal_connect(main_window, "destroy", G_CALLBACK(destroy), NULL);
 519         g_signal_connect(main_window, "key-press-event", G_CALLBACK(on_key_press), NULL);
 520         g_signal_connect(main_window, "key-release-event", G_CALLBACK(on_key_release), NULL);
 521
 522
 523         gtk_container_set_border_width (GTK_CONTAINER (main_window), 2);
 524
 525         /* create vbox (complete window) */
 526         vbox = gtk_vbox_new(FALSE, 0);
 527         gtk_container_add(GTK_CONTAINER(main_window), vbox);
 528         gtk_widget_show(vbox);
 529
 530         /* add menu to vbox (top of vbox) */
 531         menu_bar = gtk_menu_bar_new();
 532         gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
 533         gtk_widget_show(menu_bar);
 534         create_menus(menu_bar);
 535
 536         /* add tool_bar to vbox (bottom part of palette box) */
 537         tool_bar = gtk_hbox_new(FALSE, 0);
 538         gtk_box_pack_start(GTK_BOX(vbox), tool_bar, FALSE, FALSE, 2);
 539         gtk_widget_show(tool_bar);
 540         create_toolbar(tool_bar);
 541
 542         /* add paned view to vbox (middle part of vbox) */
 543         paned = gtk_hpaned_new ();
 544         gtk_widget_show(paned);
 545         gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 2);
 546         gtk_paned_set_position(GTK_PANED (paned), 250);
 547
 548         /* add palette treeview to hbox (top part of palette box) */
 549         palette_treeview = gtk_tree_view_new();
 550         gtk_widget_set_size_request(palette_treeview, 250, 400);
 551         g_signal_connect(palette_treeview, "enter_notify_event", G_CALLBACK(enter_palette_area), NULL);
 552         g_signal_connect(palette_treeview, "leave_notify_event", G_CALLBACK(leave_palette_area), NULL);
 553         gtk_widget_set_events(palette_treeview, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
 554         gtk_widget_show(palette_treeview);
 555
 556         pal_scroll = gtk_scrolled_window_new(NULL, NULL);
 557         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pal_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 558         gtk_widget_show(pal_scroll);
 559         gtk_container_add(GTK_CONTAINER(pal_scroll), palette_treeview);
 560
 561         palette_renderer = gtk_cell_renderer_text_new();
 562         g_object_set(G_OBJECT(palette_renderer), "editable", FALSE, NULL);
 563         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "text", 0/*column*/, NULL);
 564         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 0/*column*/);
 565
 566         palette_renderer = gtk_cell_renderer_pixbuf_new();
 567         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "pixbuf", 1/*column*/, NULL);
 568         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 1/*column*/);
 569
 570         palette_renderer = gtk_cell_renderer_text_new();
 571         g_object_set(G_OBJECT(palette_renderer), "editable", TRUE, NULL);
 572         g_signal_connect(palette_renderer, "edited", (GCallback) palette_edited, palette_treeview);
 573         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "text", 2/*column*/, NULL);
 574         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 2/*column*/);
 575
 576         create_palette();
 577
 578         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(palette_treeview));
 579         g_signal_connect(selection, "changed", G_CALLBACK(palette_change), NULL);
 580         gtk_paned_pack1 (GTK_PANED (paned), pal_scroll, FALSE, TRUE);
 581
 582         /* add drawing area (right of hbox) */
 583         img_drawing_area = gtk_drawing_area_new ();
 584         gtk_signal_connect(GTK_OBJECT(img_drawing_area), "motion_notify_event", (GtkSignalFunc)motion_notify_event, NULL);
 585         gtk_signal_connect(GTK_OBJECT (img_drawing_area), "button_press_event", (GtkSignalFunc)button_press_event, NULL);
 586         gtk_signal_connect(GTK_OBJECT (img_drawing_area), "expose_event", (GtkSignalFunc)img_expose_event, NULL);
 587         g_signal_connect(img_drawing_area, "enter_notify_event", G_CALLBACK(enter_drawing_area), NULL);
 588         g_signal_connect(img_drawing_area, "leave_notify_event", G_CALLBACK(leave_drawing_area), NULL);
 589         gtk_widget_set_events(img_drawing_area, GDK_EXPOSURE_MASK
 590                 | GDK_ENTER_NOTIFY_MASK
 591                 | GDK_LEAVE_NOTIFY_MASK
 592                 | GDK_BUTTON_PRESS_MASK
 593                 | GDK_POINTER_MOTION_MASK
 594                 | GDK_POINTER_MOTION_HINT_MASK);
 595         gtk_widget_show(img_drawing_area);
 596
 597         img_scroll = gtk_scrolled_window_new(NULL, NULL);
 598         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(img_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 599         gtk_widget_show(img_scroll);
 600         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(img_scroll), img_drawing_area);
 601         gtk_paned_pack2 (GTK_PANED (paned), img_scroll, TRUE, TRUE);
 602
 603 #if 0
 604         /* add horizontal seperation to vbox */
 605         separator = gtk_hseparator_new();
 606         gtk_widget_show(separator);
 607         gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 3);
 608 #endif
 609
 610         /* add timeline (bottom of vbox) */
 611         timeline_drawing_area = gtk_drawing_area_new ();
 612         gtk_widget_set_size_request(timeline_drawing_area, 10, 10);
 613         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "motion_notify_event", (GtkSignalFunc)timeline_motion_notify_event, NULL);
 614         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "button_press_event", (GtkSignalFunc)timeline_press_event, NULL);
 615         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "expose_event", (GtkSignalFunc)timeline_expose_event, NULL);
 616         g_signal_connect(timeline_drawing_area, "enter_notify_event", G_CALLBACK(enter_timeline_area), NULL);
 617         g_signal_connect(timeline_drawing_area, "leave_notify_event", G_CALLBACK(leave_timeline_area), NULL);
 618         gtk_widget_set_events(timeline_drawing_area, GDK_EXPOSURE_MASK
 619                 | GDK_ENTER_NOTIFY_MASK
 620                 | GDK_LEAVE_NOTIFY_MASK
 621                 | GDK_BUTTON_PRESS_MASK
 622                 | GDK_POINTER_MOTION_MASK
 623                 | GDK_POINTER_MOTION_HINT_MASK);
 624         gtk_widget_show(timeline_drawing_area);
 625         timeline_scroll = gtk_scrolled_window_new(NULL, NULL);
 626         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(timeline_scroll), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
 627 //      gtk_widget_show(timeline_scroll);
 628         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(timeline_scroll), timeline_drawing_area);
 629         gtk_box_pack_start(GTK_BOX(vbox), timeline_scroll, FALSE, FALSE, 0);
 630
 631         create_timeline(NULL);
 632
 633         /* label */
 634         img_label = GTK_LABEL(gtk_label_new(NULL));
 635         gtk_widget_show(GTK_WIDGET(img_label));
 636         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(img_label), FALSE, FALSE, 0);
 637
 638         /* show window */
 639         gtk_widget_show(main_window);
 640
 641         if (argc > 1) {
 642                 create_timeline(argv[1]);
 643                 if (frame_list)
 644                         create_image(frame_list[timeline_selected].filename, 1);
 645         }
 646
 647         gtk_main();
 648
 649         // FIXME: destroy
 650
 651         return 0;
 652 }
 653