2 * notebook.c - this file is part of Geany, a fast and lightweight IDE
4 * Copyright 2006-2012 Enrico Tröger <enrico(dot)troeger(at)uvena(dot)de>
5 * Copyright 2006-2012 Nick Treleaven <nick(dot)treleaven(at)btinternet(dot)com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 * Notebook tab Drag 'n' Drop reordering and tab management.
32 #include "callbacks.h"
33 #include "documentprivate.h"
34 #include "geanyobject.h"
35 #include "keybindings.h"
41 #include "gtkcompat.h"
43 #include <gdk/gdkkeysyms.h>
46 #define GEANY_DND_NOTEBOOK_TAB_TYPE "geany_dnd_notebook_tab"
48 static const GtkTargetEntry drag_targets
[] =
50 {GEANY_DND_NOTEBOOK_TAB_TYPE
, GTK_TARGET_SAME_APP
| GTK_TARGET_SAME_WIDGET
, 0}
53 static GtkTargetEntry files_drop_targets
[] = {
55 { "UTF8_STRING", 0, 0 },
56 { "text/plain", 0, 0 },
57 { "text/uri-list", 0, 0 }
60 static const gsize MAX_MRU_DOCS
= 20;
61 static GQueue
*mru_docs
= NULL
;
62 static guint mru_pos
= 0;
64 static gboolean switch_in_progress
= FALSE
;
65 static GtkWidget
*switch_dialog
= NULL
;
66 static GtkWidget
*switch_dialog_label
= NULL
;
70 notebook_page_reordered_cb(GtkNotebook
*notebook
, GtkWidget
*child
, guint page_num
,
74 on_window_drag_data_received(GtkWidget
*widget
, GdkDragContext
*drag_context
,
75 gint x
, gint y
, GtkSelectionData
*data
, guint target_type
,
76 guint event_time
, gpointer user_data
);
79 notebook_tab_close_clicked_cb(GtkButton
*button
, gpointer user_data
);
81 static void setup_tab_dnd(void);
84 static void update_mru_docs_head(GeanyDocument
*doc
)
88 g_queue_remove(mru_docs
, doc
);
89 g_queue_push_head(mru_docs
, doc
);
91 if (g_queue_get_length(mru_docs
) > MAX_MRU_DOCS
)
92 g_queue_pop_tail(mru_docs
);
97 /* before the tab changes, add the current document to the MRU list */
98 static void on_notebook_switch_page(GtkNotebook
*notebook
,
99 gpointer page
, guint page_num
, gpointer user_data
)
103 new = document_get_from_page(page_num
);
105 /* insert the very first document (when adding the second document
106 * and switching to it) */
107 if (g_queue_get_length(mru_docs
) == 0 && gtk_notebook_get_n_pages(notebook
) == 2)
108 update_mru_docs_head(document_get_current());
110 if (!switch_in_progress
)
111 update_mru_docs_head(new);
115 static void on_document_close(GObject
*obj
, GeanyDocument
*doc
)
117 if (! main_status
.quitting
)
119 g_queue_remove(mru_docs
, doc
);
120 /* this prevents the pop up window from showing when there's a single
122 if (gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets
.notebook
)) == 2)
123 g_queue_clear(mru_docs
);
128 static GtkWidget
*ui_minimal_dialog_new(GtkWindow
*parent
, const gchar
*title
)
132 dialog
= gtk_window_new(GTK_WINDOW_POPUP
);
136 gtk_window_set_transient_for(GTK_WINDOW(dialog
), parent
);
137 gtk_window_set_destroy_with_parent(GTK_WINDOW(dialog
), TRUE
);
139 gtk_window_set_title(GTK_WINDOW(dialog
), title
);
140 gtk_window_set_type_hint(GTK_WINDOW(dialog
), GDK_WINDOW_TYPE_HINT_DIALOG
);
141 gtk_window_set_position(GTK_WINDOW(dialog
), GTK_WIN_POS_CENTER_ON_PARENT
);
143 gtk_widget_set_name(dialog
, "GeanyDialog");
148 static gboolean
is_modifier_key(guint keyval
)
171 static gboolean
on_key_release_event(GtkWidget
*widget
, GdkEventKey
*ev
, gpointer user_data
)
173 /* user may have rebound keybinding to a different modifier than Ctrl, so check all */
174 if (switch_in_progress
&& is_modifier_key(ev
->keyval
))
178 switch_in_progress
= FALSE
;
182 gtk_widget_destroy(switch_dialog
);
183 switch_dialog
= NULL
;
186 doc
= document_get_current();
187 update_mru_docs_head(doc
);
189 document_check_disk_status(doc
, TRUE
);
195 static GtkWidget
*create_switch_dialog(void)
197 GtkWidget
*dialog
, *widget
, *vbox
;
199 dialog
= ui_minimal_dialog_new(GTK_WINDOW(main_widgets
.window
), _("Switch to Document"));
200 gtk_window_set_decorated(GTK_WINDOW(dialog
), FALSE
);
201 gtk_window_set_default_size(GTK_WINDOW(dialog
), 200, -1);
203 vbox
= gtk_vbox_new(FALSE
, 6);
204 gtk_container_set_border_width(GTK_CONTAINER(vbox
), 12);
205 gtk_container_add(GTK_CONTAINER(dialog
), vbox
);
207 widget
= gtk_image_new_from_stock(GTK_STOCK_JUMP_TO
, GTK_ICON_SIZE_BUTTON
);
208 gtk_container_add(GTK_CONTAINER(vbox
), widget
);
210 widget
= gtk_label_new(NULL
);
211 gtk_label_set_justify(GTK_LABEL(widget
), GTK_JUSTIFY_CENTER
);
212 gtk_container_add(GTK_CONTAINER(vbox
), widget
);
213 switch_dialog_label
= widget
;
215 g_signal_connect(dialog
, "key-release-event", G_CALLBACK(on_key_release_event
), NULL
);
220 static void update_filename_label(void)
229 switch_dialog
= create_switch_dialog();
230 gtk_widget_show_all(switch_dialog
);
233 queue_length
= g_queue_get_length(mru_docs
);
234 for (i
= mru_pos
; (i
<= mru_pos
+ 3) && (doc
= g_queue_peek_nth(mru_docs
, i
% queue_length
)); i
++)
238 basename
= g_path_get_basename(DOC_FILENAME(doc
));
240 msg
= g_markup_printf_escaped ("<b>%s</b>", basename
);
241 else if (i
% queue_length
== mru_pos
) /* && i != mru_pos */
243 /* We have wrapped around and got to the starting document again */
249 SETPTR(basename
, g_markup_printf_escaped ("\n%s", basename
));
250 SETPTR(msg
, g_strconcat(msg
, basename
, NULL
));
254 gtk_label_set_markup(GTK_LABEL(switch_dialog_label
), msg
);
259 static gboolean
on_switch_timeout(G_GNUC_UNUSED gpointer data
)
261 if (!switch_in_progress
|| switch_dialog
)
266 update_filename_label();
271 void notebook_switch_tablastused(void)
273 GeanyDocument
*last_doc
;
274 gboolean switch_start
= !switch_in_progress
;
277 last_doc
= g_queue_peek_nth(mru_docs
, mru_pos
);
279 if (! DOC_VALID(last_doc
))
283 last_doc
= g_queue_peek_nth(mru_docs
, mru_pos
);
285 if (! DOC_VALID(last_doc
))
288 switch_in_progress
= TRUE
;
289 document_show_tab(last_doc
);
291 /* if there's a modifier key, we can switch back in MRU order each time unless
292 * the key is released */
294 g_timeout_add(600, on_switch_timeout
, NULL
);
296 update_filename_label();
300 gboolean
notebook_switch_in_progress(void)
302 return switch_in_progress
;
306 static gboolean
focus_sci(GtkWidget
*widget
, GdkEventButton
*event
, gpointer user_data
)
308 GeanyDocument
*doc
= document_get_current();
310 if (doc
!= NULL
&& event
->button
== 1)
311 gtk_widget_grab_focus(GTK_WIDGET(doc
->editor
->sci
));
317 static gboolean
gtk_notebook_show_arrows(GtkNotebook
*notebook
)
319 return gtk_notebook_get_scrollable(notebook
);
321 /* To get this working we would need to define at least the first two fields of
322 * GtkNotebookPage since it is a private field. The better way would be to
323 * subclass GtkNotebook.
324 struct _FakeGtkNotebookPage
327 GtkWidget *tab_label;
330 gboolean show_arrow
= FALSE
;
333 if (! notebook
->scrollable
)
336 children
= notebook
->children
;
339 struct _FakeGtkNotebookPage
*page
= children
->data
;
341 if (page
->tab_label
&& ! gtk_widget_get_child_visible(page
->tab_label
))
344 children
= children
->next
;
351 static gboolean
is_position_on_tab_bar(GtkNotebook
*notebook
, GdkEventButton
*event
)
356 GtkPositionType tab_pos
;
357 gint scroll_arrow_hlength
, scroll_arrow_vlength
;
360 page
= gtk_notebook_get_nth_page(notebook
, 0);
361 g_return_val_if_fail(page
!= NULL
, FALSE
);
363 tab
= gtk_notebook_get_tab_label(notebook
, page
);
364 g_return_val_if_fail(tab
!= NULL
, FALSE
);
366 tab_pos
= gtk_notebook_get_tab_pos(notebook
);
367 nb
= GTK_WIDGET(notebook
);
369 gtk_widget_style_get(GTK_WIDGET(notebook
), "scroll-arrow-hlength", &scroll_arrow_hlength
,
370 "scroll-arrow-vlength", &scroll_arrow_vlength
, NULL
);
372 if (! gdk_event_get_coords((GdkEvent
*) event
, &x
, &y
))
383 if (event
->y
>= 0 && event
->y
<= gtk_widget_get_allocated_height(tab
))
385 if (! gtk_notebook_show_arrows(notebook
) || (
386 x
> scroll_arrow_hlength
&&
387 x
< gtk_widget_get_allocated_width(nb
) - scroll_arrow_hlength
))
395 if (event
->x
>= 0 && event
->x
<= gtk_widget_get_allocated_width(tab
))
397 if (! gtk_notebook_show_arrows(notebook
) || (
398 y
> scroll_arrow_vlength
&&
399 y
< gtk_widget_get_allocated_height(nb
) - scroll_arrow_vlength
))
409 static void tab_bar_menu_activate_cb(GtkMenuItem
*menuitem
, gpointer data
)
411 GeanyDocument
*doc
= data
;
413 if (! DOC_VALID(doc
))
416 document_show_tab(doc
);
420 static void on_open_in_new_window_activate(GtkMenuItem
*menuitem
, gpointer user_data
)
423 GeanyDocument
*doc
= user_data
;
425 g_return_if_fail(doc
->is_valid
);
427 geany_path
= g_find_program_in_path("geany");
431 gchar
*doc_path
= utils_get_locale_from_utf8(doc
->file_name
);
432 gchar
*argv
[] = {geany_path
, "-i", doc_path
, NULL
};
435 if (!utils_spawn_async(NULL
, argv
, NULL
, 0, NULL
, NULL
, NULL
, &err
))
437 g_printerr("Unable to open new window: %s", err
->message
);
444 g_printerr("Unable to find 'geany'");
448 static void show_tab_bar_popup_menu(GdkEventButton
*event
, GtkWidget
*page
)
450 GtkWidget
*menu_item
;
451 static GtkWidget
*menu
= NULL
;
452 GeanyDocument
*doc
= NULL
;
456 menu
= gtk_menu_new();
458 /* clear the old menu items */
459 gtk_container_foreach(GTK_CONTAINER(menu
), (GtkCallback
) gtk_widget_destroy
, NULL
);
461 ui_menu_add_document_items(GTK_MENU(menu
), document_get_current(),
462 G_CALLBACK(tab_bar_menu_activate_cb
));
464 menu_item
= gtk_separator_menu_item_new();
465 gtk_widget_show(menu_item
);
466 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
470 page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(main_widgets
.notebook
), page
);
471 doc
= document_get_from_page(page_num
);
474 menu_item
= ui_image_menu_item_new(GTK_STOCK_OPEN
, "Open in New _Window");
475 gtk_widget_show(menu_item
);
476 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
477 g_signal_connect(menu_item
, "activate",
478 G_CALLBACK(on_open_in_new_window_activate
), doc
);
479 /* disable if not on disk */
480 if (doc
== NULL
|| !doc
->real_path
)
481 gtk_widget_set_sensitive(menu_item
, FALSE
);
483 menu_item
= gtk_separator_menu_item_new();
484 gtk_widget_show(menu_item
);
485 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
487 menu_item
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE
, NULL
);
488 gtk_widget_show(menu_item
);
489 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
490 g_signal_connect(menu_item
, "activate", G_CALLBACK(notebook_tab_close_clicked_cb
), page
);
491 gtk_widget_set_sensitive(GTK_WIDGET(menu_item
), (page
!= NULL
));
493 menu_item
= ui_image_menu_item_new(GTK_STOCK_CLOSE
, _("Close Ot_her Documents"));
494 gtk_widget_show(menu_item
);
495 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
496 g_signal_connect(menu_item
, "activate", G_CALLBACK(on_close_other_documents1_activate
), page
);
497 gtk_widget_set_sensitive(GTK_WIDGET(menu_item
), (page
!= NULL
));
499 menu_item
= ui_image_menu_item_new(GTK_STOCK_CLOSE
, _("C_lose All"));
500 gtk_widget_show(menu_item
);
501 gtk_container_add(GTK_CONTAINER(menu
), menu_item
);
502 g_signal_connect(menu_item
, "activate", G_CALLBACK(on_close_all1_activate
), NULL
);
504 gtk_menu_popup(GTK_MENU(menu
), NULL
, NULL
, NULL
, NULL
, event
->button
, event
->time
);
508 static gboolean
notebook_tab_bar_click_cb(GtkWidget
*widget
, GdkEventButton
*event
,
511 if (event
->type
== GDK_2BUTTON_PRESS
)
513 GtkNotebook
*notebook
= GTK_NOTEBOOK(widget
);
514 GtkWidget
*event_widget
= gtk_get_event_widget((GdkEvent
*) event
);
515 GtkWidget
*child
= gtk_notebook_get_nth_page(notebook
, gtk_notebook_get_current_page(notebook
));
517 /* ignore events from the content of the page (impl. stolen from GTK2 tab scrolling)
518 * TODO: we should also ignore notebook's action widgets, but that's more work and
519 * we don't have any of them yet anyway -- and GTK 2.16 don't have those actions. */
520 if (event_widget
== NULL
|| event_widget
== child
|| gtk_widget_is_ancestor(event_widget
, child
))
523 if (is_position_on_tab_bar(notebook
, event
))
525 document_new_file(NULL
, NULL
, NULL
);
529 /* right-click is also handled here if it happened on the notebook tab bar but not
530 * on a tab directly */
531 else if (event
->button
== 3)
533 show_tab_bar_popup_menu(event
, NULL
);
540 void notebook_init(void)
542 g_signal_connect_after(main_widgets
.notebook
, "button-press-event",
543 G_CALLBACK(notebook_tab_bar_click_cb
), NULL
);
545 g_signal_connect(main_widgets
.notebook
, "drag-data-received",
546 G_CALLBACK(on_window_drag_data_received
), NULL
);
548 mru_docs
= g_queue_new();
549 g_signal_connect(main_widgets
.notebook
, "switch-page",
550 G_CALLBACK(on_notebook_switch_page
), NULL
);
551 g_signal_connect(geany_object
, "document-close",
552 G_CALLBACK(on_document_close
), NULL
);
554 /* in case the switch dialog misses an event while drawing the dialog */
555 g_signal_connect(main_widgets
.window
, "key-release-event", G_CALLBACK(on_key_release_event
), NULL
);
561 void notebook_free(void)
563 g_queue_free(mru_docs
);
567 static void setup_tab_dnd(void)
569 GtkWidget
*notebook
= main_widgets
.notebook
;
571 g_signal_connect(notebook
, "page-reordered", G_CALLBACK(notebook_page_reordered_cb
), NULL
);
576 notebook_page_reordered_cb(GtkNotebook
*notebook
, GtkWidget
*child
, guint page_num
,
579 /* Not necessary to update open files treeview if it's sorted.
580 * Note: if enabled, it's best to move the item instead of recreating all items. */
581 /*sidebar_openfiles_update_all();*/
585 /* call this after the number of tabs in main_widgets.notebook changes. */
586 static void tab_count_changed(void)
588 switch (gtk_notebook_get_n_pages(GTK_NOTEBOOK(main_widgets
.notebook
)))
591 /* Enables DnD for dropping files into the empty notebook widget */
592 gtk_drag_dest_set(main_widgets
.notebook
, GTK_DEST_DEFAULT_ALL
,
593 files_drop_targets
, G_N_ELEMENTS(files_drop_targets
),
594 GDK_ACTION_COPY
| GDK_ACTION_MOVE
| GDK_ACTION_LINK
| GDK_ACTION_ASK
);
598 /* Disables DnD for dropping files into the notebook widget and enables the DnD for moving file
599 * tabs. Files can still be dropped into the notebook widget because it will be handled by the
600 * active Scintilla Widget (only dropping to the tab bar is not possible but it should be ok) */
601 gtk_drag_dest_set(main_widgets
.notebook
, GTK_DEST_DEFAULT_MOTION
| GTK_DEST_DEFAULT_DROP
,
602 drag_targets
, G_N_ELEMENTS(drag_targets
), GDK_ACTION_MOVE
);
608 static gboolean
notebook_tab_click(GtkWidget
*widget
, GdkEventButton
*event
, gpointer data
)
611 GeanyDocument
*doc
= (GeanyDocument
*) data
;
613 /* toggle additional widgets on double click */
614 if (event
->type
== GDK_2BUTTON_PRESS
)
616 if (interface_prefs
.notebook_double_click_hides_widgets
)
617 on_menu_toggle_all_additional_widgets1_activate(NULL
, NULL
);
619 return TRUE
; /* stop other handlers like notebook_tab_bar_click_cb() */
621 /* close tab on middle click */
622 if (event
->button
== 2)
625 return TRUE
; /* stop other handlers like notebook_tab_bar_click_cb() */
627 /* switch last used tab on ctrl-click */
628 state
= event
->state
& gtk_accelerator_get_default_mod_mask();
629 if (event
->button
== 1 && state
== GDK_CONTROL_MASK
)
631 keybindings_send_command(GEANY_KEY_GROUP_NOTEBOOK
,
632 GEANY_KEYS_NOTEBOOK_SWITCHTABLASTUSED
);
635 /* right-click is first handled here if it happened on a notebook tab */
636 if (event
->button
== 3)
638 show_tab_bar_popup_menu(event
, data
);
646 static void notebook_tab_close_button_style_set(GtkWidget
*btn
, GtkRcStyle
*prev_style
,
651 gtk_icon_size_lookup_for_settings(gtk_widget_get_settings(btn
), GTK_ICON_SIZE_MENU
, &w
, &h
);
652 gtk_widget_set_size_request(btn
, w
+ 2, h
+ 2);
656 /* Returns page number of notebook page, or -1 on error */
657 gint
notebook_new_tab(GeanyDocument
*this)
659 GtkWidget
*hbox
, *ebox
, *vbox
;
664 g_return_val_if_fail(this != NULL
, -1);
666 /* page is packed into a vbox so we can stack infobars above it */
667 vbox
= gtk_vbox_new(FALSE
, 0);
668 page
= GTK_WIDGET(this->editor
->sci
);
669 gtk_box_pack_start(GTK_BOX(vbox
), page
, TRUE
, TRUE
, 0);
670 gtk_widget_show(vbox
);
672 this->priv
->tab_label
= gtk_label_new(NULL
);
674 /* get button press events for the tab label and the space between it and
675 * the close button, if any */
676 ebox
= gtk_event_box_new();
677 gtk_widget_set_has_window(ebox
, FALSE
);
678 g_signal_connect(ebox
, "button-press-event", G_CALLBACK(notebook_tab_click
), this);
679 /* focus the current document after clicking on a tab */
680 g_signal_connect_after(ebox
, "button-release-event",
681 G_CALLBACK(focus_sci
), NULL
);
683 hbox
= gtk_hbox_new(FALSE
, 2);
684 gtk_box_pack_start(GTK_BOX(hbox
), this->priv
->tab_label
, FALSE
, FALSE
, 0);
685 gtk_container_add(GTK_CONTAINER(ebox
), hbox
);
687 if (file_prefs
.show_tab_cross
)
689 GtkWidget
*image
, *btn
, *align
;
691 btn
= gtk_button_new();
692 gtk_button_set_relief(GTK_BUTTON(btn
), GTK_RELIEF_NONE
);
693 gtk_button_set_focus_on_click(GTK_BUTTON(btn
), FALSE
);
694 gtk_widget_set_name(btn
, "geany-close-tab-button");
696 image
= gtk_image_new_from_stock(GTK_STOCK_CLOSE
, GTK_ICON_SIZE_MENU
);
697 gtk_container_add(GTK_CONTAINER(btn
), image
);
699 align
= gtk_alignment_new(1.0, 0.5, 0.0, 0.0);
700 gtk_container_add(GTK_CONTAINER(align
), btn
);
701 gtk_box_pack_start(GTK_BOX(hbox
), align
, TRUE
, TRUE
, 0);
703 g_signal_connect(btn
, "clicked", G_CALLBACK(notebook_tab_close_clicked_cb
), page
);
704 /* button overrides event box, so make middle click on button also close tab */
705 g_signal_connect(btn
, "button-press-event", G_CALLBACK(notebook_tab_click
), this);
706 /* handle style modification to keep button small as possible even when theme change */
707 g_signal_connect(btn
, "style-set", G_CALLBACK(notebook_tab_close_button_style_set
), NULL
);
710 gtk_widget_show_all(ebox
);
712 document_update_tab_label(this);
714 if (file_prefs
.tab_order_beside
)
715 cur_page
= gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets
.notebook
));
717 cur_page
= file_prefs
.tab_order_ltr
? -2 /* hack: -2 + 1 = -1, last page */ : 0;
718 if (file_prefs
.tab_order_ltr
)
719 tabnum
= gtk_notebook_insert_page_menu(GTK_NOTEBOOK(main_widgets
.notebook
), vbox
,
720 ebox
, NULL
, cur_page
+ 1);
722 tabnum
= gtk_notebook_insert_page_menu(GTK_NOTEBOOK(main_widgets
.notebook
), vbox
,
723 ebox
, NULL
, cur_page
);
728 gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(main_widgets
.notebook
), vbox
, TRUE
);
735 notebook_tab_close_clicked_cb(GtkButton
*button
, gpointer data
)
737 GeanyDocument
*doc
= (GeanyDocument
*) data
;
743 /* Always use this instead of gtk_notebook_remove_page(). */
744 void notebook_remove_page(gint page_num
)
746 gint page
= gtk_notebook_get_current_page(GTK_NOTEBOOK(main_widgets
.notebook
));
748 if (page_num
== page
)
750 if (file_prefs
.tab_order_ltr
)
752 else if (page
> 0) /* never go negative, it would select the last page */
755 if (file_prefs
.tab_close_switch_to_mru
)
757 GeanyDocument
*last_doc
;
759 last_doc
= g_queue_peek_nth(mru_docs
, 0);
760 if (DOC_VALID(last_doc
))
761 page
= document_get_notebook_page(last_doc
);
764 gtk_notebook_set_current_page(GTK_NOTEBOOK(main_widgets
.notebook
), page
);
767 /* now remove the page (so we don't temporarily switch to the previous page) */
768 gtk_notebook_remove_page(GTK_NOTEBOOK(main_widgets
.notebook
), page_num
);
775 on_window_drag_data_received(GtkWidget
*widget
, GdkDragContext
*drag_context
,
776 gint x
, gint y
, GtkSelectionData
*data
, guint target_type
,
777 guint event_time
, gpointer user_data
)
779 gboolean success
= FALSE
;
780 gint length
= gtk_selection_data_get_length(data
);
782 if (length
> 0 && gtk_selection_data_get_format(data
) == 8)
784 document_open_file_list((const gchar
*)gtk_selection_data_get_data(data
), length
);
788 gtk_drag_finish(drag_context
, success
, FALSE
, event_time
);