src/ui-toolbar.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <gtk/gtk.h>
   4 #include <glib/gi18n.h>
   5 #include "ui-menu.h"
   6 #include "ui-toolbar.h"
   7 #include "config.h"
   8 #include "comic-new-dialog.h"
   9 #include "comic-saveas-dialog.h"
  10 #include "comic-open-dialog.h"
  11 #include "tbo-window.h"
  12 #include "comic.h"
  13 #include "custom-stock.h"
  14 #include "ui-drawing.h"
  15
  16 #include "frame-tool.h"
  17 #include "selector-tool.h"
  18 #include "doodle-tool.h"
  19 #include "text-tool.h"
  20 #include "piximage.h"
  21
  22 static int SELECTED_TOOL = NONE;
  23 static GtkActionGroup *ACTION_GROUP = NULL;
  24
  25 static ToolStruct TOOLS[] =
  26 {
  27     {FRAME,
  28      frame_tool_on_select,
  29      frame_tool_on_unselect,
  30      frame_tool_on_move,
  31      frame_tool_on_click,
  32      frame_tool_on_release,
  33      frame_tool_on_key,
  34      frame_tool_drawing},
  35
  36     {SELECTOR,
  37      selector_tool_on_select,
  38      selector_tool_on_unselect,
  39      selector_tool_on_move,
  40      selector_tool_on_click,
  41      selector_tool_on_release,
  42      selector_tool_on_key,
  43      selector_tool_drawing},
  44
  45     {DOODLE,
  46      doodle_tool_on_select,
  47      doodle_tool_on_unselect,
  48      doodle_tool_on_move,
  49      doodle_tool_on_click,
  50      doodle_tool_on_release,
  51      doodle_tool_on_key,
  52      doodle_tool_drawing},
  53
  54     {TEXT,
  55      text_tool_on_select,
  56      text_tool_on_unselect,
  57      text_tool_on_move,
  58      text_tool_on_click,
  59      text_tool_on_release,
  60      text_tool_on_key,
  61      text_tool_drawing},
  62 };
  63
  64 typedef struct
  65 {
  66     enum Tool tool;
  67     char *action;
  68
  69 } tool_and_action;
  70
  71 void unselect (enum Tool tool, TboWindow *tbo);
  72 gboolean select_tool (GtkAction *action, TboWindow *tbo);
  73 void update_toolbar (TboWindow *tbo);
  74
  75 enum Tool
  76 get_selected_tool ()
  77 {
  78     return SELECTED_TOOL;
  79 }
  80
  81
  82 void
  83 set_current_tab_page (TboWindow *tbo, gboolean setit)
  84 {
  85     int nth;
  86
  87     nth = tbo_comic_page_index (tbo->comic);
  88     if (setit)
  89         gtk_notebook_set_current_page (GTK_NOTEBOOK (tbo->notebook), nth);
  90     tbo->dw_scroll = gtk_notebook_get_nth_page (GTK_NOTEBOOK (tbo->notebook), nth);
  91     tbo->drawing = gtk_bin_get_child (GTK_BIN (tbo->dw_scroll));
  92     set_frame_view (NULL);
  93     set_selected_tool (NONE, tbo);
  94 }
  95
  96 gboolean
  97 notebook_switch_page_cb (GtkNotebook     *notebook,
  98                          GtkNotebookPage *page,
  99                          guint            page_num,
 100                          TboWindow        *tbo)
 101 {
 102     tbo_comic_set_current_page_nth (tbo->comic, page_num);
 103     set_current_tab_page (tbo, FALSE);
 104     update_toolbar (tbo);
 105     tbo_window_update_status (tbo, 0, 0);
 106     return FALSE;
 107 }
 108
 109 void
 110 set_selected_tool (enum Tool tool, TboWindow *tbo)
 111 {
 112     unselect (SELECTED_TOOL, tbo);
 113     SELECTED_TOOL = tool;
 114
 115     tool_signal (tool, TOOL_SELECT, tbo);
 116     update_toolbar (tbo);
 117 }
 118
 119 void
 120 update_toolbar (TboWindow *tbo)
 121 {
 122     GtkAction *prev;
 123     GtkAction *next;
 124     GtkAction *delete;
 125
 126     GtkAction *doodle;
 127     GtkAction *text;
 128     GtkAction *new_frame;
 129     GtkAction *pix;
 130
 131     if (!ACTION_GROUP)
 132         return;
 133
 134     // Page next, prev and delete button sensitive
 135     prev = gtk_action_group_get_action (ACTION_GROUP, "PrevPage");
 136     next = gtk_action_group_get_action (ACTION_GROUP, "NextPage");
 137     delete = gtk_action_group_get_action (ACTION_GROUP, "DelPage");
 138
 139     if (tbo_comic_page_first (tbo->comic))
 140         gtk_action_set_sensitive (prev, FALSE);
 141     else
 142         gtk_action_set_sensitive (prev, TRUE);
 143
 144     if (tbo_comic_page_last (tbo->comic))
 145         gtk_action_set_sensitive (next, FALSE);
 146     else
 147         gtk_action_set_sensitive (next, TRUE);
 148     if (tbo_comic_len (tbo->comic) > 1)
 149         gtk_action_set_sensitive (delete, TRUE);
 150     else
 151         gtk_action_set_sensitive (delete, FALSE);
 152
 153     // Frame view disabled in page view
 154     doodle = gtk_action_group_get_action (ACTION_GROUP, "Doodle");
 155     text = gtk_action_group_get_action (ACTION_GROUP, "Text");
 156     new_frame = gtk_action_group_get_action (ACTION_GROUP, "NewFrame");
 157     pix = gtk_action_group_get_action (ACTION_GROUP, "Pix");
 158
 159     if (get_frame_view() == NULL)
 160     {
 161         gtk_action_set_sensitive (doodle, FALSE);
 162         gtk_action_set_sensitive (text, FALSE);
 163         gtk_action_set_sensitive (pix, FALSE);
 164         gtk_action_set_sensitive (new_frame, TRUE);
 165     }
 166     else
 167     {
 168         gtk_action_set_sensitive (doodle, TRUE);
 169         gtk_action_set_sensitive (text, TRUE);
 170         gtk_action_set_sensitive (pix, TRUE);
 171         gtk_action_set_sensitive (new_frame, FALSE);
 172     }
 173 }
 174
 175 gboolean
 176 toolbar_handler (GtkWidget *widget, gpointer data)
 177 {
 178     return FALSE;
 179 }
 180
 181 gboolean
 182 add_new_page (GtkAction *action, TboWindow *tbo)
 183 {
 184     Page *page = tbo_comic_new_page (tbo->comic);
 185     int nth = tbo_comic_page_nth (tbo->comic, page);
 186     gtk_notebook_insert_page (GTK_NOTEBOOK (tbo->notebook),
 187                               create_darea (tbo),
 188                               NULL,
 189                               nth);
 190     tbo_window_update_status (tbo, 0, 0);
 191     update_toolbar (tbo);
 192     return FALSE;
 193 }
 194
 195 gboolean
 196 del_current_page (GtkAction *action, TboWindow *tbo)
 197 {
 198     int nth = tbo_comic_page_index (tbo->comic);
 199     tbo_comic_del_current_page (tbo->comic);
 200     set_current_tab_page (tbo, TRUE);
 201     gtk_notebook_remove_page (GTK_NOTEBOOK (tbo->notebook), nth);
 202     tbo_window_update_status (tbo, 0, 0);
 203     update_toolbar (tbo);
 204     return FALSE;
 205 }
 206
 207 gboolean
 208 next_page (GtkAction *action, TboWindow *tbo)
 209 {
 210     tbo_comic_next_page (tbo->comic);
 211     set_current_tab_page (tbo, TRUE);
 212     update_toolbar (tbo);
 213     tbo_window_update_status (tbo, 0, 0);
 214
 215     return FALSE;
 216 }
 217
 218 gboolean
 219 prev_page (GtkAction *action, TboWindow *tbo)
 220 {
 221     tbo_comic_prev_page (tbo->comic);
 222     set_current_tab_page (tbo, TRUE);
 223     update_toolbar (tbo);
 224     tbo_window_update_status (tbo, 0, 0);
 225
 226     return FALSE;
 227 }
 228
 229 gboolean
 230 zoom_100 (GtkAction *action, TboWindow *tbo)
 231 {
 232     tbo_drawing_zoom_100 (tbo);
 233     return FALSE;
 234 }
 235
 236 gboolean
 237 zoom_in (GtkAction *action, TboWindow *tbo)
 238 {
 239     tbo_drawing_zoom_in (tbo);
 240     return FALSE;
 241 }
 242
 243 gboolean
 244 zoom_out (GtkAction *action, TboWindow *tbo)
 245 {
 246     tbo_drawing_zoom_out (tbo);
 247     return FALSE;
 248 }
 249
 250 gboolean
 251 add_pix (GtkAction *action, TboWindow *tbo)
 252 {
 253     GtkWidget *dialog;
 254     GtkFileFilter *filter;
 255
 256     dialog = gtk_file_chooser_dialog_new (_("Add an Image"),
 257                      GTK_WINDOW (tbo->window),
 258                      GTK_FILE_CHOOSER_ACTION_OPEN,
 259                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 260                      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
 261                      NULL);
 262
 263     filter = gtk_file_filter_new ();
 264     gtk_file_filter_set_name (filter, _("png"));
 265     gtk_file_filter_add_pattern (filter, "*.png");
 266     gtk_file_filter_add_pattern (filter, "*.PNG");
 267     gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 268     filter = gtk_file_filter_new ();
 269     gtk_file_filter_set_name (filter, _("All files"));
 270     gtk_file_filter_add_pattern (filter, "*");
 271     gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
 272
 273     if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
 274     {
 275         char *filename;
 276         filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
 277         PIXImage *piximage = tbo_piximage_new_with_params (0, 0, 0, 0, filename);
 278         tbo_frame_add_obj (get_frame_view(), piximage);
 279         update_drawing (tbo);
 280         g_free (filename);
 281     }
 282
 283     gtk_widget_destroy (dialog);
 284     return FALSE;
 285 }
 286
 287 static const GtkActionEntry tbo_tools_entries [] = {
 288     { "NewFileTool", GTK_STOCK_NEW, N_("_New"), "<control>N",
 289       N_("New Comic"),
 290       G_CALLBACK (tbo_comic_new_dialog) },
 291
 292     { "OpenFileTool", GTK_STOCK_OPEN, N_("_Open"), "<control>O",
 293       N_("Open comic"),
 294       G_CALLBACK (tbo_comic_open_dialog) },
 295
 296     { "SaveFileTool", GTK_STOCK_SAVE, N_("_Save"), "<control>S",
 297       N_("Save current document"),
 298       G_CALLBACK (tbo_comic_save_dialog) },
 299
 300     // Page tools
 301     { "NewPage", GTK_STOCK_ADD, N_("New Page"), "<control>P",
 302       N_("New page"),
 303       G_CALLBACK (add_new_page) },
 304
 305     { "DelPage", GTK_STOCK_DELETE, N_("Delete Page"), "",
 306       N_("Delete current page"),
 307       G_CALLBACK (del_current_page) },
 308
 309     { "PrevPage", GTK_STOCK_GO_BACK, N_("Prev Page"), "",
 310       N_("Prev page"),
 311       G_CALLBACK (prev_page) },
 312
 313     { "NextPage", GTK_STOCK_GO_FORWARD, N_("Next Page"), "",
 314       N_("Next page"),
 315       G_CALLBACK (next_page) },
 316
 317     // Zoom tools
 318     { "Zoomin", GTK_STOCK_ZOOM_IN, N_("Zoom in"), "",
 319       N_("Zoom in"),
 320       G_CALLBACK (zoom_in) },
 321     { "Zoom100", GTK_STOCK_ZOOM_100, N_("Zoom 1:1"), "",
 322       N_("Zoom 1:1"),
 323       G_CALLBACK (zoom_100) },
 324     { "Zoomout", GTK_STOCK_ZOOM_OUT, N_("Zoom out"), "",
 325       N_("Zoom out"),
 326       G_CALLBACK (zoom_out) },
 327
 328     // Png image tool
 329     { "Pix", TBO_STOCK_PIX, N_("Image"), "",
 330       N_("Image"),
 331       G_CALLBACK (add_pix) },
 332 };
 333
 334 static const GtkToggleActionEntry tbo_tools_toogle_entries [] = {
 335     // Page view tools
 336     { "NewFrame", TBO_STOCK_FRAME, N_("New _Frame"), "<control>F",
 337       N_("New Frame"),
 338       G_CALLBACK (select_tool), FALSE },
 339
 340     { "Selector", TBO_STOCK_SELECTOR, N_("Selector"), "",
 341       N_("Selector"),
 342       G_CALLBACK (select_tool), FALSE },
 343
 344     // Frame view tools
 345     { "Doodle", TBO_STOCK_DOODLE, N_("Doodle"), "",
 346       N_("Doodle"),
 347       G_CALLBACK (select_tool), FALSE },
 348     { "Text", TBO_STOCK_TEXT, N_("Text"), "",
 349       N_("Text"),
 350       G_CALLBACK (select_tool), FALSE },
 351 };
 352
 353 static const tool_and_action tools_actions [] = {
 354     {FRAME, "NewFrame"},
 355     {SELECTOR, "Selector"},
 356     {DOODLE, "Doodle"},
 357     {TEXT, "Text"},
 358 };
 359
 360 void
 361 set_selected_tool_and_action (enum Tool tool, TboWindow *tbo)
 362 {
 363     GtkToggleAction *action;
 364     enum Tool action_tool;
 365     gchar *name;
 366
 367     int i;
 368     GtkToggleActionEntry entry;
 369
 370     for (i=0; i<G_N_ELEMENTS (tools_actions); i++)
 371     {
 372         if (tool == tools_actions[i].tool)
 373         {
 374             name = (gchar *) tools_actions[i].action;
 375             break;
 376         }
 377     }
 378
 379     action = (GtkToggleAction *) gtk_action_group_get_action (ACTION_GROUP, name);
 380     if (gtk_action_is_sensitive (GTK_ACTION (action)))
 381         gtk_toggle_action_set_active (action, TRUE);
 382 }
 383
 384 void
 385 unselect (enum Tool tool, TboWindow *tbo)
 386 {
 387     int i;
 388     GtkToggleAction *action;
 389
 390     for (i=0; i<G_N_ELEMENTS (tools_actions); i++)
 391     {
 392         if (tools_actions[i].tool == tool)
 393         {
 394             action = (GtkToggleAction *) gtk_action_group_get_action (ACTION_GROUP,
 395                     tools_actions[i].action);
 396
 397             gtk_toggle_action_set_active (action, FALSE);
 398             break;
 399         }
 400     }
 401     tool_signal (tool, TOOL_UNSELECT, tbo);
 402 }
 403
 404 gboolean
 405 select_tool (GtkAction *action, TboWindow *tbo)
 406 {
 407     GtkToggleAction *toggle_action;
 408     int i;
 409     const gchar *name;
 410     enum Tool tool;
 411
 412     toggle_action = (GtkToggleAction *) action;
 413     name = gtk_action_get_name (action);
 414
 415
 416     for (i=0; i<G_N_ELEMENTS (tools_actions); i++)
 417     {
 418         if (strcmp (tools_actions[i].action, name) == 0)
 419         {
 420             tool = tools_actions[i].tool;
 421             break;
 422         }
 423     }
 424
 425     if (gtk_toggle_action_get_active (toggle_action))
 426         set_selected_tool (tool, tbo);
 427     else
 428         set_selected_tool (NONE, tbo);
 429     tbo_window_update_status (tbo, 0, 0);
 430     return FALSE;
 431 }
 432
 433 GtkWidget *generate_toolbar (TboWindow *window){
 434     GtkWidget *toolbar;
 435     GtkUIManager *manager;
 436     GError *error = NULL;
 437
 438     manager = gtk_ui_manager_new ();
 439     gtk_ui_manager_add_ui_from_file (manager, DATA_DIR "/ui/tbo-toolbar-ui.xml", &error);
 440     if (error != NULL)
 441     {
 442         g_warning ("Could not merge tbo-toolbar-ui.xml: %s", error->message);
 443         g_error_free (error);
 444     }
 445
 446     ACTION_GROUP = gtk_action_group_new ("ToolsActions");
 447     gtk_action_group_set_translation_domain (ACTION_GROUP, NULL);
 448     gtk_action_group_add_actions (ACTION_GROUP, tbo_tools_entries,
 449                         G_N_ELEMENTS (tbo_tools_entries), window);
 450     gtk_action_group_add_toggle_actions (ACTION_GROUP, tbo_tools_toogle_entries,
 451                         G_N_ELEMENTS (tbo_tools_toogle_entries), window);
 452
 453     gtk_ui_manager_insert_action_group (manager, ACTION_GROUP, 0);
 454
 455     toolbar = gtk_ui_manager_get_widget (manager, "/toolbar");
 456
 457     update_toolbar (window);
 458
 459     return toolbar;
 460 }
 461
 462 void
 463 tool_signal (enum Tool tool, enum ToolSignal signal, gpointer data)
 464 {
 465     int i;
 466     ToolStruct *toolstruct = NULL;
 467     void **pdata;
 468
 469     for (i=0; i<G_N_ELEMENTS (TOOLS); i++)
 470     {
 471         if (tool == TOOLS[i].tool)
 472         {
 473             toolstruct = &TOOLS[i];
 474             break;
 475         }
 476     }
 477
 478     if (toolstruct)
 479     {
 480         switch (signal)
 481         {
 482             case TOOL_SELECT:
 483                 toolstruct->tool_on_select(data);
 484                 break;
 485             case TOOL_UNSELECT:
 486                 toolstruct->tool_on_unselect(data);
 487                 break;
 488             case TOOL_MOVE:
 489                 pdata = data;
 490                 toolstruct->tool_on_move (pdata[0], pdata[1], pdata[2]);
 491                 break;
 492             case TOOL_CLICK:
 493                 pdata = data;
 494                 toolstruct->tool_on_click (pdata[0], pdata[1], pdata[2]);
 495                 break;
 496             case TOOL_RELEASE:
 497                 pdata = data;
 498                 toolstruct->tool_on_release (pdata[0], pdata[1], pdata[2]);
 499                 break;
 500             case TOOL_KEY:
 501                 pdata = data;
 502                 toolstruct->tool_on_key (pdata[0], pdata[1], pdata[2]);
 503                 break;
 504             case TOOL_DRAWING:
 505                 toolstruct->tool_drawing (data);
 506                 break;
 507             default:
 508                 break;
 509         }
 510     }
 511 }