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 "image.h"
  12 #include "palette.h"
  13 #include "timeline.h"
  14 #include "colorize.h"
  15 #include "brightcontrast.h"
  16 #include "level.h"
  17 #include "fill.h"
  18 #ifdef WITH_OPENCV
  19 #include "flow.h"
  20 #endif
  21
  22 #define CC_APP_TITLE "Colorize GTK"
  23 GtkWidget *main_window;
  24 GtkWidget *img_scroll;
  25 GtkWidget *img_drawing_area = NULL;
  26 GtkWidget *timeline_drawing_area;
  27 GtkWidget *timeline_scroll;
  28 GtkWidget *palette_treeview = NULL;
  29 GtkLabel *img_label;
  30 GtkToggleButton *show_highlighted_button, *show_preview_button, *show_colorized_button;
  31 #ifdef WITH_OPENCV
  32 GtkToggleButton *show_flow_button;
  33 #endif
  34 int button_down = 0, button_down_x = -1000, button_down_y = -1000, shift_pressed = 0, button_num = 1;
  35 int brush_size;
  36 int highlight = 0, preview = 0, rendered = 0, move_mode = 0, fill_mode = 0, flowview = 0;
  37 int mouse_over_palette_area = 0, mouse_over_drawing_area = 0, mouse_over_timeline_area = 0;
  38 #define min(x,y) ((x < y) ? x : y)
  39 #define abs(x,y) ((x < y) ? y - x : x - y)
  40
  41 /* the labels are used to identify menu and button items */
  42 enum toggle_label {
  43         TOGGLE_LABEL_NONE = 0,
  44         TOGGLE_LABEL_HIGHLIGHT,
  45         TOGGLE_LABEL_PREVIEW,
  46         TOGGLE_LABEL_RENDERED,
  47         TOGGLE_LABEL_FLOWVIEW,
  48         TOGGLE_LABEL_ZOOMFIELDS,
  49 };
  50
  51 static void set_button_toggel_by_label(enum toggle_label label, gboolean active);
  52
  53 /* error requester */
  54 void printerror(const char *fmt, ...)
  55 {
  56         char buffer[4096];
  57         va_list args;
  58
  59         va_start(args,fmt);
  60         vsprintf(buffer,fmt,args);
  61         buffer[sizeof(buffer)-1]=0;
  62         va_end(args);
  63
  64         GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
  65                 GTK_DIALOG_DESTROY_WITH_PARENT,
  66                 GTK_MESSAGE_ERROR,
  67                 GTK_BUTTONS_CLOSE,
  68                 "%s", buffer);
  69         gtk_dialog_run (GTK_DIALOG (dialog));
  70         gtk_widget_destroy (dialog);
  71 }
  72
  73 static int already_destroyed = 0;
  74
  75 /* exit program and save current mask / palette */
  76 void main_destroy(void)
  77 {
  78         if (anything_modified) {
  79                 int ret;
  80                 GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
  81                         GTK_DIALOG_DESTROY_WITH_PARENT,
  82                         GTK_MESSAGE_ERROR,
  83                         GTK_BUTTONS_OK_CANCEL,
  84                         "Image has been changed, really quit?");
  85                 ret = gtk_dialog_run(GTK_DIALOG (dialog));
  86                 gtk_widget_destroy(dialog);
  87                 if (ret != GTK_RESPONSE_OK)
  88                         return;
  89         }
  90         already_destroyed = 1;
  91         gtk_main_quit();
  92 }
  93
  94
  95 static void destroy(GtkWidget *widget, gpointer data)
  96 {
  97         if (!already_destroyed)
  98                 main_destroy();
  99 }
 100
 101 /*
 102  * keypress
 103  */
 104
 105 static void undo_event(gpointer priv);
 106 static void redo_event(gpointer priv);
 107 static void copy_event(gpointer priv);
 108 static void paste_event(gpointer priv);
 109
 110 /* event handler for main window keys */
 111 static gboolean on_key_press(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 112 {
 113         int frame;
 114
 115 //      if (mouse_over_palette_area)
 116         if (!mouse_over_drawing_area && !mouse_over_timeline_area)
 117                 return FALSE;
 118
 119         switch (event->keyval) {
 120         case GDK_q:
 121         case GDK_w:
 122                 if (event->state & GDK_CONTROL_MASK) {
 123                         main_destroy();
 124                         return TRUE;
 125                 }
 126                 break;
 127         case GDK_Right:
 128                 frame = timeline_selected + 1;
 129                 if (event->state & GDK_SHIFT_MASK) {
 130                         while(frame < timeline_frames && frame_list[frame].marked == 0 && frame_list[frame].keyframe == 0)
 131                                 frame++;
 132                 }
 133                 if (frame < timeline_frames)
 134                         timeline_select_and_save(timeline_selected, frame);
 135                 return TRUE;
 136         case GDK_Left:
 137                 frame = timeline_selected - 1;
 138                 if (event->state & GDK_SHIFT_MASK) {
 139                         while(frame >= 0 && frame_list[frame].marked == 0 && frame_list[frame].keyframe == 0)
 140                                 frame--;
 141                 }
 142                 if (frame >= 0)
 143                         timeline_select_and_save(timeline_selected, frame);
 144                 return TRUE;
 145         case GDK_Home:
 146                 frame = 0;
 147                 timeline_select_and_save(timeline_selected, frame);
 148                 return TRUE;
 149         case GDK_End:
 150                 frame = timeline_frames - 1;
 151                 timeline_select_and_save(timeline_selected, frame);
 152                 return TRUE;
 153         case GDK_u:
 154         case GDK_z:
 155                 undo_event(NULL);
 156                 return TRUE;
 157         case GDK_r:
 158                 redo_event(NULL);
 159                 return TRUE;
 160         case GDK_c:
 161                 if (event->state & GDK_CONTROL_MASK) {
 162                         copy_event(NULL);
 163                         return TRUE;
 164                 }
 165                 break;
 166         case GDK_v:
 167                 if (event->state & GDK_CONTROL_MASK) {
 168                         paste_event(NULL);
 169                         return TRUE;
 170                 }
 171                 break;
 172         case GDK_k:
 173                 toggle_keyframe();
 174                 return TRUE;
 175         case GDK_Shift_L:
 176         case GDK_Shift_R:
 177                 shift_pressed = 1;
 178                 break;
 179 //      default:
 180 //              printf("press %x\n", event->keyval);
 181         }
 182
 183         return FALSE;
 184 }
 185
 186 /* event handler for main window keys */
 187 static gboolean on_key_release(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 188 {
 189         switch (event->keyval) {
 190         case GDK_Shift_L:
 191         case GDK_Shift_R:
 192                 shift_pressed = 0;
 193                 break;
 194 //      default:
 195 //              printf("release %x\n", event->keyval);
 196         }
 197
 198         return FALSE;
 199 }
 200
 201 /*
 202  * image area
 203  */
 204
 205 /* events if mouse is over palette area */
 206 static gboolean enter_palette_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 207 {
 208         mouse_over_palette_area = 1;
 209         return FALSE;
 210 }
 211 static gboolean leave_palette_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 212 {
 213         mouse_over_palette_area = 0;
 214         return FALSE;
 215 }
 216
 217 /* events if mouse is over image area */
 218 static gboolean enter_drawing_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 219 {
 220         mouse_over_drawing_area = 1;
 221         return FALSE;
 222 }
 223 static gboolean leave_drawing_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 224 {
 225         mouse_over_drawing_area = 0;
 226         return FALSE;
 227 }
 228
 229 /* events if mouse is over timeline area */
 230 static gboolean enter_timeline_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 231 {
 232         mouse_over_timeline_area = 1;
 233         return FALSE;
 234 }
 235 static gboolean leave_timeline_area(GtkWidget *widget, GdkEventKey *event, gpointer user_data)
 236 {
 237         mouse_over_timeline_area = 0;
 238         timeline_point(-1, -1);
 239         return FALSE;
 240 }
 241
 242 /* ugly non-bresenham.... */
 243 static void draw_line(int x, int y, int paint)
 244 {
 245         double step_x = 0, step_y = 0;
 246
 247         if (abs(x,button_down_x) > abs(y,button_down_y)) {
 248                 while(42) {
 249                         if (button_down_x < x) {
 250                                 step_x++;
 251                                 step_y += (double)(button_down_y - y) / (double)(button_down_x - x);
 252                         } else {
 253                                 step_x--;
 254                                 step_y -= (double)(button_down_y - y) / (double)(button_down_x - x);
 255                         }
 256                         paint_brush(button_down_x+step_x, button_down_y+step_y, brush_size, paint);
 257                         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);
 258                         if (x == button_down_x+step_x)
 259                                 break;
 260                 }
 261         } else {
 262                 while(42) {
 263                         if (y == button_down_y) /* no move at all */
 264                                 break;
 265                         if (button_down_y < y) {
 266                                 step_y++;
 267                                 step_x += (double)(button_down_x - x) / (double)(button_down_y - y);
 268                         } else {
 269                                 step_y--;
 270                                 step_x -= (double)(button_down_x - x) / (double)(button_down_y - y);
 271                         }
 272                         paint_brush(button_down_x+step_x, button_down_y+step_y, brush_size, paint);
 273                         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);
 274                         if (y == button_down_y+step_y)
 275                                 break;
 276                 }
 277         }
 278         paint_brush(x, y, brush_size, paint);
 279         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);
 280         button_down_x = x;
 281         button_down_y = y;
 282 }
 283
 284 /* notify movement of mouse inside image area */
 285 static gint motion_notify_event( GtkWidget *widget,
 286                                  GdkEventMotion *event )
 287 {
 288         int x, y;
 289         GdkModifierType state;
 290
 291         if (event->is_hint)
 292                 gdk_window_get_pointer (event->window, &x, &y, &state);
 293         else
 294         {
 295                 x = event->x;
 296                 y = event->y;
 297                 state = event->state;
 298         }
 299
 300         if ((state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK))) {
 301                 if (button_down) {
 302                         if (move_mode) {
 303                                 move_mark((x-button_down_x)*16/img_scale_x, (y-button_down_y)*16/img_scale_y);
 304                                 draw_image(0, 0, -1, -1);
 305                         } else {
 306                                 draw_line(x, y, button_num == 1);
 307                         }
 308                 }
 309         } else {
 310                 button_down = 0;
 311         }
 312
 313         return TRUE;
 314 }
 315
 316 /* button press event inside image area */
 317 static gint button_press_event (GtkWidget *widget, GdkEventButton *event)
 318 {
 319         int x,y;
 320
 321         x = event->x;
 322         y = event->y;
 323         button_num = event->button;
 324
 325         if (!button_down)
 326                 copy_mark_to_undo();
 327         if (fill_mode) {
 328                 fill(x, y, event->button != 1);
 329                 draw_image(0, 0, -1, -1);
 330         } else
 331         if (move_mode) {
 332                 if (button_down)
 333                         return TRUE;
 334                 button_down_x = x;
 335                 button_down_y = y;
 336         } else {
 337                 /* if not shift, draw a dot and not a line */
 338                 if (!shift_pressed || button_down_x == -1000) {
 339                         button_down_x = x;
 340                         button_down_y = y;
 341                 }
 342                 draw_line(x, y, button_num == 1);
 343         }
 344         button_down = 1;
 345         return TRUE;
 346 }
 347
 348 /* redraw event of image area */
 349 static gint img_expose_event (GtkWidget *widget, GdkEventExpose *event)
 350 {
 351         draw_image(event->area.x, event->area.y, event->area.width, event->area.height);
 352
 353         return FALSE;
 354 }
 355
 356 /*
 357  * timeline
 358  */
 359
 360 /* mouse move event inside timeline */
 361 static gint timeline_motion_notify_event( GtkWidget *widget,
 362                                  GdkEventMotion *event )
 363 {
 364         int x, y;
 365         GdkModifierType state;
 366
 367         if (event->is_hint)
 368                 gdk_window_get_pointer (event->window, &x, &y, &state);
 369         else
 370         {
 371                 x = event->x;
 372                 y = event->y;
 373                 state = event->state;
 374         }
 375
 376         timeline_point(x, y);
 377
 378         if ((state & GDK_BUTTON1_MASK)) {
 379                 timeline_clicked(x, y);
 380
 381         }
 382
 383         return TRUE;
 384 }
 385
 386 /* button press event inside timeline area */
 387 static gint timeline_press_event (GtkWidget *widget, GdkEventButton *event)
 388 {
 389         int x,y;
 390
 391         x = event->x;
 392         y = event->y;
 393         timeline_clicked(x, y);
 394
 395         return TRUE;
 396 }
 397
 398 /* redraw event of timeline area */
 399 static gint timeline_expose_event (GtkWidget *widget, GdkEventExpose *event)
 400 {
 401         draw_timeline(event->area.x, event->area.y, event->area.width, event->area.height);
 402
 403         return FALSE;
 404 }
 405
 406 /*
 407  * colorselection
 408  */
 409
 410 /* color selection's buttons have been pressed */
 411 GtkWidget *colorseldlg = NULL;
 412 GtkColorSelection *colorsel;
 413 static void color_response(GtkDialog *dialog, gint response_id, gpointer user_data)
 414 {
 415         if (response_id == GTK_RESPONSE_CANCEL) {
 416                 gtk_widget_destroy(colorseldlg);
 417                 colorseldlg = NULL;
 418         }
 419         if (response_id == GTK_RESPONSE_OK) {
 420                 GdkColor ncolor;
 421
 422                 anything_modified = 1;
 423
 424                 gtk_color_selection_get_current_color(colorsel, &ncolor);
 425                 gtk_color_selection_set_previous_color(colorsel, &ncolor);
 426                 mark_palette[mark_selected].r = ncolor.red / 256;
 427                 mark_palette[mark_selected].g = ncolor.green / 256;
 428                 mark_palette[mark_selected].b = ncolor.blue / 256;
 429                 update_color(mark_selected);
 430                 draw_image(0, 0, -1, -1);
 431         }
 432 }
 433
 434 /*
 435  * menus
 436  */
 437
 438 static void open_event(gpointer priv)
 439 {
 440         GtkWidget *dialog;
 441         char *filename = NULL;
 442
 443         if (anything_modified) {
 444                 int ret;
 445                 GtkWidget *dialog = gtk_message_dialog_new (GTK_WINDOW(main_window),
 446                         GTK_DIALOG_DESTROY_WITH_PARENT,
 447                         GTK_MESSAGE_ERROR,
 448                         GTK_BUTTONS_OK_CANCEL,
 449                         "Image has been changed, really open new image?");
 450                 ret = gtk_dialog_run(GTK_DIALOG (dialog));
 451                 gtk_widget_destroy(dialog);
 452                 if (ret != GTK_RESPONSE_OK)
 453                         return;
 454         }
 455
 456         dialog = gtk_file_chooser_dialog_new("Select first grey image",
 457                 GTK_WINDOW(main_window),
 458                 GTK_FILE_CHOOSER_ACTION_OPEN,
 459                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 460                 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 461                 NULL);
 462
 463         if (frame_list)
 464                 gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), frame_list[timeline_selected].filename);
 465         if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
 466                 filename = strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
 467         }
 468
 469         gtk_widget_destroy(dialog);
 470
 471         if (filename) {
 472 // do not save          timeline_select_and_save(timeline_selected, timeline_selected);
 473
 474                 create_timeline(filename);
 475                 if (frame_list)
 476                         create_image(frame_list[timeline_selected].filename);
 477                 free(filename);
 478         }
 479
 480 }
 481
 482 static void save_event(gpointer priv)
 483 {
 484         timeline_select_and_save(timeline_selected, timeline_selected);
 485 }
 486
 487 static void exit_event(gpointer priv)
 488 {
 489         main_destroy();
 490 }
 491
 492 static void color_changed(GtkWidget *widget, GtkColorSelection *colorsel)
 493 {
 494 }
 495
 496 static void undo_event(gpointer priv)
 497 {
 498         copy_undo_to_mark(0);
 499         draw_image(0, 0, -1, -1);
 500 }
 501
 502 static void redo_event(gpointer priv)
 503 {
 504         copy_undo_to_mark(1);
 505         draw_image(0, 0, -1, -1);
 506 }
 507
 508 static void copy_event(gpointer priv)
 509 {
 510         copy_color(mark_selected + 1);
 511 }
 512
 513 static void copy_all_event(gpointer priv)
 514 {
 515         copy_color(0);
 516 }
 517
 518 static void paste_event(gpointer priv)
 519 {
 520         copy_mark_to_undo();
 521         paste_color();
 522         draw_image(0, 0, -1, -1);
 523 }
 524
 525 static void color_destroy(GtkWidget *widget, gpointer data)
 526 {
 527         colorseldlg = NULL;
 528 }
 529
 530 static void palette_event(gpointer priv)
 531 {
 532         GdkColor color;
 533
 534         if (colorseldlg) {
 535                 gtk_widget_destroy(colorseldlg);
 536                 colorseldlg = NULL;
 537                 return;
 538         }
 539
 540         color.red = mark_palette[mark_selected].r * 256 + 128;
 541         color.green = mark_palette[mark_selected].g * 256 + 128;
 542         color.blue = mark_palette[mark_selected].b * 256 + 128;
 543
 544         colorseldlg = gtk_color_selection_dialog_new("Select Color");
 545         colorsel = GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (colorseldlg)->colorsel);
 546         gtk_color_selection_set_previous_color (colorsel, &color);
 547         gtk_color_selection_set_current_color (colorsel, &color);
 548         g_signal_connect(G_OBJECT(colorsel), "color_changed", G_CALLBACK(color_changed), (gpointer)colorsel);
 549         g_signal_connect(G_OBJECT(colorseldlg), "response", G_CALLBACK(color_response), NULL);
 550         g_signal_connect(G_OBJECT(colorseldlg), "destroy", G_CALLBACK(color_destroy), NULL);
 551
 552
 553         gtk_widget_show(colorseldlg);
 554 }
 555
 556 static void keyframe_event(gpointer priv)
 557 {
 558         toggle_keyframe();
 559 }
 560
 561 static void erase_event(gpointer priv)
 562 {
 563         copy_mark_to_undo();
 564         erase_mark(0);
 565         draw_image(0, 0, -1, -1);
 566 }
 567
 568 static void erase_color_event(gpointer priv)
 569 {
 570         copy_mark_to_undo();
 571         erase_mark(mark_selected + 1);
 572         draw_image(0, 0, -1, -1);
 573 }
 574
 575 static void zoom_in_event(gpointer priv)
 576 {
 577         if (img_scale_x < 64) {
 578                 int aspect = img_scale_y / img_scale_x;
 579                 img_scale_x += 4;
 580                 img_scale_y = img_scale_x * aspect;
 581                 create_or_reset_pixbuf(0);
 582         }
 583 }
 584
 585 static void zoom_out_event(gpointer priv)
 586 {
 587         if (img_scale_x > 4) {
 588                 int aspect = img_scale_y / img_scale_x;
 589                 img_scale_x -= 4;
 590                 img_scale_y = img_scale_x * aspect;
 591                 create_or_reset_pixbuf(0);
 592         }
 593 }
 594
 595 static void zoom_100_event(gpointer priv)
 596 {
 597         img_scale_x = 16;
 598         img_scale_y = 16;
 599         create_or_reset_pixbuf(0);
 600 }
 601
 602 static void zoom_field_event(gpointer priv)
 603 {
 604         if (gtk_check_menu_item_get_active((GtkCheckMenuItem *)priv))
 605                 img_scale_y = img_scale_x*2;
 606         else
 607                 img_scale_y = img_scale_x;
 608         create_or_reset_pixbuf(1);
 609 }
 610
 611 static void show_highlighted_event(gpointer priv)
 612 {
 613         highlight = gtk_check_menu_item_get_active((GtkCheckMenuItem *)priv);
 614         set_button_toggel_by_label(TOGGLE_LABEL_HIGHLIGHT, highlight);
 615 }
 616
 617 static void show_preview_event(gpointer priv)
 618 {
 619         preview = gtk_check_menu_item_get_active((GtkCheckMenuItem *)priv);
 620         set_button_toggel_by_label(TOGGLE_LABEL_PREVIEW, preview);
 621 }
 622
 623 static void colorize_event(gpointer priv)
 624 {
 625         if (rendered) {
 626                 printerror("Disable colorized view first.");
 627                 return;
 628         }
 629 #ifdef WITH_OPENCV
 630         if (flowview) {
 631                 printerror("Disable flow view first.");
 632                 return;
 633         }
 634 #endif
 635         if (img_mark_buffer)
 636                 colorize_image();
 637 }
 638
 639 static void show_colorized_event(gpointer priv)
 640 {
 641         if (timeline_frames > 1)
 642                 rendered = gtk_check_menu_item_get_active((GtkCheckMenuItem *)priv);
 643         else
 644                 rendered = 0;
 645         gtk_check_menu_item_set_active((GtkCheckMenuItem *)priv, rendered);
 646         set_button_toggel_by_label(TOGGLE_LABEL_RENDERED, rendered);
 647 }
 648
 649 #ifdef WITH_OPENCV
 650 static void show_flow_event(gpointer priv)
 651 {
 652         if (flow_enable && timeline_frames > 1)
 653                 flowview = gtk_check_menu_item_get_active((GtkCheckMenuItem *)priv);
 654         else
 655                 flowview = 0;
 656         gtk_check_menu_item_set_active((GtkCheckMenuItem *)priv, flowview);
 657         set_button_toggel_by_label(TOGGLE_LABEL_FLOWVIEW, flowview);
 658 }
 659 #endif
 660
 661 static void dummy_event(gpointer priv)
 662 {
 663 }
 664
 665 struct my_menu_item {
 666         enum toggle_label label;
 667         GtkWidget *widget;
 668         const char *text;
 669         void (*handler)(gpointer priv);
 670         gchar *stock;
 671 };
 672
 673 struct my_menu {
 674         const char *text;
 675         struct my_menu_item *items;
 676 };
 677
 678 struct my_menu_item file_menu_items[] = {
 679         { TOGGLE_LABEL_NONE, NULL, "Open", open_event, GTK_STOCK_OPEN },
 680         { TOGGLE_LABEL_NONE, NULL, "Save", save_event, GTK_STOCK_SAVE },
 681         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 682         { TOGGLE_LABEL_NONE, NULL, "Exit", exit_event, GTK_STOCK_QUIT },
 683         { TOGGLE_LABEL_NONE, NULL, NULL, NULL }
 684 };
 685
 686 struct my_menu_item edit_menu_items[] = {
 687         { TOGGLE_LABEL_NONE, NULL, "Undo", undo_event, GTK_STOCK_UNDO },
 688         { TOGGLE_LABEL_NONE, NULL, "Redo", redo_event, GTK_STOCK_REDO },
 689         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 690         { TOGGLE_LABEL_NONE, NULL, "Copy", copy_event, GTK_STOCK_COPY },
 691         { TOGGLE_LABEL_NONE, NULL, "Copy All", copy_all_event, NULL },
 692         { TOGGLE_LABEL_NONE, NULL, "Paste", paste_event, GTK_STOCK_PASTE },
 693         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 694         { TOGGLE_LABEL_NONE, NULL, "Palette", palette_event, NULL },
 695         { TOGGLE_LABEL_NONE, NULL, "Bright/Contrast", bc_event, NULL },
 696         { TOGGLE_LABEL_NONE, NULL, "Adjust Levels", level_event, NULL },
 697 #ifdef WITH_OPENCV
 698         { TOGGLE_LABEL_NONE, NULL, "Optical Flow", flow_event, NULL },
 699 #endif
 700         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 701         { TOGGLE_LABEL_NONE, NULL, "Keyframe", keyframe_event, NULL },
 702         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 703         { TOGGLE_LABEL_NONE, NULL, "Clear", erase_event, GTK_STOCK_CLEAR },
 704         { TOGGLE_LABEL_NONE, NULL, "Clear Color", erase_color_event, NULL },
 705         { TOGGLE_LABEL_NONE, NULL, NULL, NULL }
 706 };
 707
 708 struct my_menu_item view_menu_items[] = {
 709         { TOGGLE_LABEL_NONE, NULL, "Zoom In", zoom_in_event, GTK_STOCK_ZOOM_IN },
 710         { TOGGLE_LABEL_NONE, NULL, "Zoom Out", zoom_out_event, GTK_STOCK_ZOOM_OUT },
 711         { TOGGLE_LABEL_NONE, NULL, "Zoom 100", zoom_100_event, GTK_STOCK_ZOOM_100 },
 712         { TOGGLE_LABEL_ZOOMFIELDS, NULL, "Zoom Field", zoom_field_event, NULL },
 713         { TOGGLE_LABEL_NONE, NULL, "", dummy_event, NULL },
 714         { TOGGLE_LABEL_HIGHLIGHT, NULL, "Highlight color", show_highlighted_event, NULL },
 715         { TOGGLE_LABEL_PREVIEW, NULL, "Preview color", show_preview_event, NULL },
 716         { TOGGLE_LABEL_RENDERED, NULL, "Show colorized", show_colorized_event, NULL },
 717 #ifdef WITH_OPENCV
 718         { TOGGLE_LABEL_FLOWVIEW, NULL, "Show flow", show_flow_event, NULL },
 719 #endif
 720         { TOGGLE_LABEL_NONE, NULL, NULL, NULL }
 721 };
 722
 723 struct my_menu_item render_menu_items[] = {
 724         { TOGGLE_LABEL_NONE, NULL, "Colorize Image", colorize_event, NULL },
 725         { TOGGLE_LABEL_NONE, NULL, NULL, NULL }
 726 };
 727
 728 struct my_menu menus[] = {
 729         { "_File", file_menu_items },
 730         { "_Edit", edit_menu_items },
 731         { "_View", view_menu_items },
 732         { "_Render", render_menu_items },
 733         { NULL, NULL }
 734 };
 735
 736 /* create menu bar */
 737 static void create_menus(GtkWidget *menu_bar)
 738 {
 739         GtkWidget *root_menu;
 740         GtkWidget *menu;
 741         GtkWidget *menu_item;
 742         struct my_menu_item *items;
 743         int i, j;
 744
 745         /* create vbox and add menu_bar */
 746         for (i = 0; menus[i].text; i++) {
 747                 /* create menu with items */
 748                 items = menus[i].items;
 749                 menu = gtk_menu_new();
 750                 for (j = 0; items[j].text; j++) {
 751                         if (!items[j].text[0])
 752                                 menu_item = gtk_separator_menu_item_new();
 753                         else if (items[j].stock)
 754                                 menu_item = gtk_image_menu_item_new_from_stock(items[j].stock, NULL);
 755                         else if (items[j].label != TOGGLE_LABEL_NONE)
 756                                 menu_item = gtk_check_menu_item_new_with_label(items[j].text);
 757                         else
 758                                 menu_item = gtk_menu_item_new_with_label(items[j].text);
 759                         items[j].widget = menu_item;
 760                         gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
 761                         g_signal_connect_swapped(menu_item, "activate", G_CALLBACK(items[j].handler), menu_item);
 762                         gtk_widget_show(menu_item);
 763                 }
 764                 /* create root menu and add to menu_bar */
 765                 root_menu = gtk_menu_item_new_with_mnemonic(menus[i].text);
 766                 gtk_widget_show(root_menu);
 767                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(root_menu), menu);
 768                 gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), root_menu);
 769         }
 770
 771 }
 772
 773 static void set_menu_toggel_by_label(enum toggle_label label, gboolean active)
 774 {
 775         struct my_menu_item *items;
 776         int i, j;
 777
 778         for (i = 0; menus[i].text; i++) {
 779                 items = menus[i].items;
 780                 for (j = 0; items[j].text; j++) {
 781                         if (items[j].label == label)
 782                                 gtk_check_menu_item_set_active((GtkCheckMenuItem *)items[j].widget, active);
 783                 }
 784         }
 785 }
 786
 787 /*
 788  * palette
 789  */
 790
 791 /* palette entry has been clicked */
 792 void palette_change(GtkTreeSelection *selection, gpointer data)
 793 {
 794         GtkTreeModel     *model;
 795         GtkTreeIter       iter;
 796
 797         if (gtk_tree_selection_get_selected(selection, &model, &iter))
 798         {
 799                 gchar *name;
 800
 801                 gtk_tree_model_get (model, &iter, 0/*column*/, &name, -1);
 802                 mark_selected = atoi(name) - 1;
 803                 g_free(name);
 804
 805                 if (colorseldlg) {
 806                         GdkColor color;
 807
 808                         color.red = mark_palette[mark_selected].r * 256 + 128;
 809                         color.green = mark_palette[mark_selected].g * 256 + 128;
 810                         color.blue = mark_palette[mark_selected].b * 256 + 128;
 811
 812                         if (colorseldlg)
 813                                 gtk_color_selection_set_current_color (colorsel, &color);
 814                 }
 815
 816                 /* set current color for bightness+contrast window */
 817                 bc_set_current();
 818
 819                 /* set current levels in window */
 820                 level_set_current();
 821
 822                 if (highlight || preview)
 823                         draw_image(0, 0, -1, -1);
 824         }
 825 }
 826
 827 /* name of palette entry has been entered */
 828 void palette_edited(GtkCellRendererText *renderer, gchar *path, gchar *new_text, GtkTreeView *treeview)
 829 {
 830         anything_modified = 1;
 831
 832         /* copy string */
 833         strncpy(mark_palette[mark_selected].name, new_text, sizeof(mark_palette[mark_selected].name));
 834         mark_palette[mark_selected].name[sizeof(mark_palette[mark_selected].name)-1] = '\0';
 835
 836         /* store string */
 837         GtkTreeIter iter;
 838         GtkTreeModel *model;
 839
 840         model = gtk_tree_view_get_model (treeview);
 841         if (gtk_tree_model_get_iter_from_string (model, &iter, path))
 842                 gtk_list_store_set (GTK_LIST_STORE (model), &iter, 2/*column*/, mark_palette[mark_selected].name, -1);
 843
 844         if (preview)
 845                 draw_image(0, 0, -1, -1);
 846 }
 847
 848 /*
 849  * tool bar
 850  */
 851
 852 extern const guint8 img_size_1[];
 853 extern const guint8 img_size_3[];
 854 extern const guint8 img_size_5[];
 855 extern const guint8 img_size_9[];
 856 extern const guint8 img_size_11[];
 857 extern const guint8 img_size_19[];
 858 extern const guint8 img_fill[];
 859 extern const guint8 img_move[];
 860
 861 struct paint_buttons {
 862         const guint8 *data;
 863         GtkToggleButton *button;
 864         int toggle_state;
 865         int size;
 866         int move;
 867         int fill;
 868         const char *tooltip;
 869 } paint_buttons[] = {
 870         { img_size_1, NULL, FALSE, 1, 0, 0, "Set pen size to 1" },
 871         { img_size_3, NULL, TRUE, 2, 0, 0, "Set pen size to 3" },
 872         { img_size_5, NULL, FALSE, 3, 0, 0, "Set pen size to 5" },
 873         { img_size_9, NULL, FALSE, 5, 0, 0, "Set pen size to 9" },
 874         { img_size_11, NULL, FALSE, 6, 0, 0, "Set pen size to 11" },
 875         { img_size_19, NULL, FALSE, 10, 0, 0, "Set pen size to 19" },
 876         { img_fill, NULL, FALSE, 0, 0, 1, "FILL marked area" },
 877         { img_move, NULL, FALSE, 0, 1, 0, "Move marked pixles" },
 878         { NULL, NULL, 0, 0, 0, 0, NULL },
 879 };
 880
 881 void paint_button_toggled(GtkToggleButton *togglebutton, gpointer index)
 882 {
 883         int i;
 884
 885         if (paint_buttons[(long)index].toggle_state == gtk_toggle_button_get_active(togglebutton)) {
 886                 return;
 887         }
 888
 889         for (i = 0; paint_buttons[i].button; i++) {
 890                 if ((long)index == i) {
 891                         paint_buttons[i].toggle_state = TRUE;
 892                         gtk_toggle_button_set_active(paint_buttons[i].button, TRUE);
 893                         brush_size = paint_buttons[i].size;
 894                         move_mode = paint_buttons[i].move;
 895                         fill_mode = paint_buttons[i].fill;
 896                 } else {
 897                         paint_buttons[i].toggle_state = FALSE;
 898                         gtk_toggle_button_set_active(paint_buttons[i].button, FALSE);
 899                 }
 900         }
 901
 902 }
 903
 904 void zoomin_button_clicked(GtkButton *button, gpointer index)
 905 {
 906         zoom_in_event(NULL);
 907 }
 908
 909 void zoomout_button_clicked(GtkButton *button, gpointer index)
 910 {
 911         zoom_out_event(NULL);
 912 }
 913
 914 void highlight_button_toggled(GtkButton *button, gpointer index)
 915 {
 916         highlight = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
 917         set_menu_toggel_by_label(TOGGLE_LABEL_HIGHLIGHT, highlight);
 918         draw_image(0, 0, -1, -1);
 919 }
 920
 921 void preview_button_toggled(GtkButton *button, gpointer index)
 922 {
 923         preview = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
 924         set_menu_toggel_by_label(TOGGLE_LABEL_PREVIEW, preview);
 925         draw_image(0, 0, -1, -1);
 926 }
 927
 928 void palette_button_clicked(GtkButton *button, gpointer index)
 929 {
 930         palette_event(NULL);
 931 }
 932
 933 void bc_button_clicked(GtkButton *button, gpointer index)
 934 {
 935         bc_event(NULL);
 936 }
 937
 938 void colorize_button_clicked(GtkButton *button, gpointer index)
 939 {
 940         colorize_event(NULL);
 941 }
 942
 943 void view_colorized_button_toggled(GtkButton *button, gpointer index)
 944 {
 945         if (timeline_frames > 1)
 946                 rendered = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
 947         else
 948                 rendered = 0;
 949         gtk_toggle_button_set_active(show_colorized_button, rendered);
 950         set_menu_toggel_by_label(TOGGLE_LABEL_RENDERED, rendered);
 951         timeline_select_and_save(timeline_selected, timeline_selected);
 952 }
 953
 954 #ifdef WITH_OPENCV
 955 void view_flow_button_toggled(GtkButton *button, gpointer index)
 956 {
 957         if (flow_enable && timeline_frames > 1)
 958                 flowview = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
 959         else
 960                 flowview = 0;
 961         gtk_toggle_button_set_active(show_flow_button, flowview);
 962         set_menu_toggel_by_label(TOGGLE_LABEL_FLOWVIEW, flowview);
 963         timeline_select_and_save(timeline_selected, timeline_selected);
 964 }
 965 #endif
 966
 967 extern const guint8 img_zoomin[];
 968 extern const guint8 img_zoomout[];
 969 extern const guint8 img_pal[];
 970 extern const guint8 img_bc[];
 971 extern const guint8 img_highlight[];
 972 extern const guint8 img_preview[];
 973 extern const guint8 img_eye[];
 974 extern const guint8 img_col[];
 975 extern const guint8 img_flow[];
 976
 977 struct tool_buttons {
 978         enum toggle_label label;
 979         GtkWidget *widget;
 980         const guint8 *data;
 981         int toggle;
 982         void (*handler)(GtkButton *togglebutton, gpointer priv);
 983         GtkToggleButton **button;
 984         const char *tooltip;
 985 } tool_buttons[] = {
 986         { TOGGLE_LABEL_NONE, NULL, img_zoomin, 0, zoomin_button_clicked, NULL, "Zoom in" },
 987         { TOGGLE_LABEL_NONE, NULL, img_zoomout, 0, zoomout_button_clicked, NULL, "Zoom out" },
 988         { TOGGLE_LABEL_NONE, NULL, img_pal, 0, palette_button_clicked, NULL, "Palette dialog" },
 989         { TOGGLE_LABEL_NONE, NULL, img_bc, 0, bc_button_clicked, NULL, "Brightness+Contrast dialog" },
 990         { TOGGLE_LABEL_HIGHLIGHT, NULL, img_highlight, 1, highlight_button_toggled, &show_highlighted_button, "Highlight selected mark color" },
 991         { TOGGLE_LABEL_PREVIEW, NULL, img_preview, 1, preview_button_toggled, &show_preview_button, "Show preview of selected mark color" },
 992         { TOGGLE_LABEL_RENDERED, NULL, img_eye, 1, view_colorized_button_toggled, &show_colorized_button, "Show result of a rendered sequence" },
 993 #ifdef WITH_OPENCV
 994         { TOGGLE_LABEL_FLOWVIEW, NULL, img_flow, 1, view_flow_button_toggled, &show_flow_button, "Show optical flow" },
 995 #endif
 996         { TOGGLE_LABEL_NONE, NULL, img_col, 0, colorize_button_clicked, NULL, "Colorize current image" },
 997         { TOGGLE_LABEL_NONE, NULL, NULL, 0, NULL, NULL, NULL },
 998 };
 999
1000 static void set_button_toggel_by_label(enum toggle_label label, gboolean active)
1001 {
1002         int i;
1003
1004         for (i = 0; tool_buttons[i].data; i++) {
1005                 if (tool_buttons[i].label == label)
1006                         gtk_toggle_button_set_active((GtkToggleButton *)tool_buttons[i].widget, active);
1007         }
1008 }
1009
1010 /*
1011  * creation of main window
1012  */
1013
1014 int main(int argc, char *argv[])
1015 {
1016         GtkWidget *vbox, *tool_box;
1017         GtkWidget *paned;
1018         GtkWidget *pal_scroll;
1019         GtkWidget *menu_bar;
1020         GtkWidget *separator;
1021         GtkTreeSelection *selection;
1022         GtkTreeViewColumn *palette_column;
1023         GtkCellRenderer *palette_renderer;
1024         GtkToggleButton *button;
1025         GtkWidget *image;
1026         GdkPixbuf *pixbuf;
1027         GtkTooltips *tooltips;
1028
1029         int i;
1030
1031         gtk_init(&argc, &argv);
1032
1033         main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1034         gtk_widget_set_size_request(GTK_WIDGET(main_window), 400, 200);
1035         gtk_window_set_default_size(GTK_WINDOW(main_window), 800, 500);
1036         gtk_window_set_title(GTK_WINDOW(main_window), CC_APP_TITLE " Version "
1037 #include "../version.h"
1038         );
1039         g_signal_connect(main_window, "delete-event", G_CALLBACK(destroy), NULL);
1040         g_signal_connect(main_window, "destroy", G_CALLBACK(destroy), NULL);
1041         g_signal_connect(main_window, "key-press-event", G_CALLBACK(on_key_press), NULL);
1042         g_signal_connect(main_window, "key-release-event", G_CALLBACK(on_key_release), NULL);
1043
1044
1045         gtk_container_set_border_width (GTK_CONTAINER (main_window), 2);
1046
1047         /* create vbox (complete window) */
1048         vbox = gtk_vbox_new(FALSE, 0);
1049         gtk_container_add(GTK_CONTAINER(main_window), vbox);
1050         gtk_widget_show(vbox);
1051
1052         /* add menu to vbox (top of vbox) */
1053         menu_bar = gtk_menu_bar_new();
1054         gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
1055         gtk_widget_show(menu_bar);
1056         create_menus(menu_bar);
1057
1058         /* add tool_box to vbox (bottom part of palette box) */
1059         tool_box = gtk_hbox_new(FALSE, 0);
1060         gtk_box_pack_start(GTK_BOX(vbox), tool_box, FALSE, FALSE, 2);
1061         gtk_widget_show(tool_box);
1062
1063         for (i = 0; paint_buttons[i].data; i++) {
1064                 pixbuf = gdk_pixbuf_new_from_inline(-1, paint_buttons[i].data, FALSE, NULL);
1065                 image = gtk_image_new_from_pixbuf(pixbuf);
1066                 gtk_widget_show(GTK_WIDGET(image));
1067                 paint_buttons[i].button = button = (GtkToggleButton *) gtk_toggle_button_new();
1068                 if (paint_buttons[i].toggle_state) {
1069                         gtk_toggle_button_set_active(button, TRUE);
1070                         brush_size = paint_buttons[i].size;
1071                 }
1072                 g_signal_connect(button, "toggled", G_CALLBACK(paint_button_toggled), (void *)((long)i));
1073                 tooltips = gtk_tooltips_new();
1074                 gtk_tooltips_set_tip(tooltips, GTK_WIDGET(button), paint_buttons[i].tooltip, NULL);
1075                 gtk_container_add (GTK_CONTAINER (button), image);
1076                 gtk_widget_show(GTK_WIDGET(button));
1077                 gtk_box_pack_start(GTK_BOX(tool_box), GTK_WIDGET(button), FALSE, FALSE, 2);
1078         }
1079
1080         for (i = 0; tool_buttons[i].data; i++) {
1081                 if (i == 0 || i == 2) {
1082                         /* add vertical seperation to hbox */
1083                         separator = gtk_vseparator_new();
1084                         gtk_widget_show(separator);
1085                         gtk_box_pack_start(GTK_BOX(tool_box), separator, FALSE, FALSE, 3);
1086                 }
1087                 pixbuf = gdk_pixbuf_new_from_inline(-1, tool_buttons[i].data, FALSE, NULL);
1088                 image = gtk_image_new_from_pixbuf(pixbuf);
1089                 gtk_widget_show(GTK_WIDGET(image));
1090                 if (tool_buttons[i].toggle) {
1091                         button = (GtkToggleButton *) gtk_toggle_button_new();
1092                         g_signal_connect(button, "toggled", G_CALLBACK(tool_buttons[i].handler), NULL);
1093                 } else {
1094                         button = (GtkToggleButton *) gtk_button_new();
1095                         g_signal_connect(button, "clicked", G_CALLBACK(tool_buttons[i].handler), NULL);
1096                 }
1097                 tool_buttons[i].widget = (GtkWidget *)button;
1098                 tooltips = gtk_tooltips_new();
1099                 gtk_tooltips_set_tip(tooltips, GTK_WIDGET(button), tool_buttons[i].tooltip, NULL);
1100                 if (tool_buttons[i].button)
1101                         *(tool_buttons[i].button) = button;
1102                 gtk_container_add (GTK_CONTAINER (button), image);
1103                 gtk_widget_show(GTK_WIDGET(button));
1104                 gtk_box_pack_start(GTK_BOX(tool_box), GTK_WIDGET(button), FALSE, FALSE, 2);
1105         }
1106
1107         /* add paned view to vbox (middle part of vbox) */
1108         paned = gtk_hpaned_new ();
1109         gtk_widget_show(paned);
1110         gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 2);
1111         gtk_paned_set_position(GTK_PANED (paned), 250);
1112
1113         /* add palette treeview to hbox (top part of palette box) */
1114         palette_treeview = gtk_tree_view_new();
1115         gtk_widget_set_size_request(palette_treeview, 250, 400);
1116         g_signal_connect(palette_treeview, "enter_notify_event", G_CALLBACK(enter_palette_area), NULL);
1117         g_signal_connect(palette_treeview, "leave_notify_event", G_CALLBACK(leave_palette_area), NULL);
1118         gtk_widget_set_events(palette_treeview, GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK);
1119         gtk_widget_show(palette_treeview);
1120
1121         pal_scroll = gtk_scrolled_window_new(NULL, NULL);
1122         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pal_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
1123         gtk_widget_show(pal_scroll);
1124         gtk_container_add(GTK_CONTAINER(pal_scroll), palette_treeview);
1125
1126         palette_renderer = gtk_cell_renderer_text_new();
1127         g_object_set(G_OBJECT(palette_renderer), "editable", FALSE, NULL);
1128         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "text", 0/*column*/, NULL);
1129         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 0/*column*/);
1130
1131         palette_renderer = gtk_cell_renderer_pixbuf_new();
1132         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "pixbuf", 1/*column*/, NULL);
1133         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 1/*column*/);
1134
1135         palette_renderer = gtk_cell_renderer_text_new();
1136         g_object_set(G_OBJECT(palette_renderer), "editable", TRUE, NULL);
1137         g_signal_connect(palette_renderer, "edited", (GCallback) palette_edited, palette_treeview);
1138         palette_column = gtk_tree_view_column_new_with_attributes("", palette_renderer, "text", 2/*column*/, NULL);
1139         gtk_tree_view_insert_column(GTK_TREE_VIEW(palette_treeview), GTK_TREE_VIEW_COLUMN(palette_column), 2/*column*/);
1140
1141         create_palette();
1142
1143         selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(palette_treeview));
1144         g_signal_connect(selection, "changed", G_CALLBACK(palette_change), NULL);
1145         gtk_paned_pack1 (GTK_PANED (paned), pal_scroll, FALSE, TRUE);
1146
1147         /* add drawing area (right of hbox) */
1148         img_drawing_area = gtk_drawing_area_new ();
1149         gtk_signal_connect(GTK_OBJECT(img_drawing_area), "motion_notify_event", (GtkSignalFunc)motion_notify_event, NULL);
1150         gtk_signal_connect(GTK_OBJECT (img_drawing_area), "button_press_event", (GtkSignalFunc)button_press_event, NULL);
1151         gtk_signal_connect(GTK_OBJECT (img_drawing_area), "expose_event", (GtkSignalFunc)img_expose_event, NULL);
1152         g_signal_connect(img_drawing_area, "enter_notify_event", G_CALLBACK(enter_drawing_area), NULL);
1153         g_signal_connect(img_drawing_area, "leave_notify_event", G_CALLBACK(leave_drawing_area), NULL);
1154         gtk_widget_set_events(img_drawing_area, GDK_EXPOSURE_MASK
1155                 | GDK_ENTER_NOTIFY_MASK
1156                 | GDK_LEAVE_NOTIFY_MASK
1157                 | GDK_BUTTON_PRESS_MASK
1158                 | GDK_POINTER_MOTION_MASK
1159                 | GDK_POINTER_MOTION_HINT_MASK);
1160         gtk_widget_show(img_drawing_area);
1161
1162         img_scroll = gtk_scrolled_window_new(NULL, NULL);
1163         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(img_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1164         gtk_widget_show(img_scroll);
1165         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(img_scroll), img_drawing_area);
1166         gtk_paned_pack2 (GTK_PANED (paned), img_scroll, TRUE, TRUE);
1167
1168 #if 0
1169         /* add horizontal seperation to vbox */
1170         separator = gtk_hseparator_new();
1171         gtk_widget_show(separator);
1172         gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 3);
1173 #endif
1174
1175         /* add timeline (bottom of vbox) */
1176         timeline_drawing_area = gtk_drawing_area_new ();
1177         gtk_widget_set_size_request(timeline_drawing_area, 10, 10);
1178         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "motion_notify_event", (GtkSignalFunc)timeline_motion_notify_event, NULL);
1179         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "button_press_event", (GtkSignalFunc)timeline_press_event, NULL);
1180         gtk_signal_connect(GTK_OBJECT(timeline_drawing_area), "expose_event", (GtkSignalFunc)timeline_expose_event, NULL);
1181         g_signal_connect(timeline_drawing_area, "enter_notify_event", G_CALLBACK(enter_timeline_area), NULL);
1182         g_signal_connect(timeline_drawing_area, "leave_notify_event", G_CALLBACK(leave_timeline_area), NULL);
1183         gtk_widget_set_events(timeline_drawing_area, GDK_EXPOSURE_MASK
1184                 | GDK_ENTER_NOTIFY_MASK
1185                 | GDK_LEAVE_NOTIFY_MASK
1186                 | GDK_BUTTON_PRESS_MASK
1187                 | GDK_POINTER_MOTION_MASK
1188                 | GDK_POINTER_MOTION_HINT_MASK);
1189         gtk_widget_show(timeline_drawing_area);
1190         timeline_scroll = gtk_scrolled_window_new(NULL, NULL);
1191         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(timeline_scroll), GTK_POLICY_ALWAYS, GTK_POLICY_NEVER);
1192 //      gtk_widget_show(timeline_scroll);
1193         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(timeline_scroll), timeline_drawing_area);
1194         gtk_box_pack_start(GTK_BOX(vbox), timeline_scroll, FALSE, FALSE, 0);
1195
1196         create_timeline(NULL);
1197
1198         /* label */
1199         img_label = GTK_LABEL(gtk_label_new(NULL));
1200         gtk_widget_show(GTK_WIDGET(img_label));
1201         gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(img_label), FALSE, FALSE, 0);
1202
1203         /* show window */
1204         gtk_widget_show(main_window);
1205
1206         if (argc > 1) {
1207                 create_timeline(argv[1]);
1208                 if (frame_list)
1209                         create_image(frame_list[timeline_selected].filename);
1210         }
1211
1212         gtk_main();
1213
1214         // FIXME: destroy
1215
1216         return 0;
1217 }
1218