static void setup_dnd_targets(gmpv_handle *ctx)
{
PlaylistWidget *playlist;
GtkTargetEntry target_entry[3];
playlist = PLAYLIST_WIDGET(ctx->gui->playlist);
target_entry[0].target = "text/uri-list";
target_entry[0].flags = 0;
target_entry[0].info = 0;
target_entry[1].target = "text/plain";
target_entry[1].flags = 0;
target_entry[1].info = 1;
target_entry[2].target = "STRING";
target_entry[2].flags = 0;
target_entry[2].info = 1;
gtk_drag_dest_set( GTK_WIDGET(ctx->gui->vid_area),
GTK_DEST_DEFAULT_ALL,
target_entry,
3,
GDK_ACTION_LINK );
gtk_drag_dest_set( GTK_WIDGET(playlist),
GTK_DEST_DEFAULT_ALL,
target_entry,
3,
GDK_ACTION_COPY );
gtk_drag_dest_add_uri_targets(GTK_WIDGET(ctx->gui->vid_area));
gtk_drag_dest_add_uri_targets(GTK_WIDGET(playlist));
}
/*
* Configure the GtkIconView: background color, visual columns, drag-and-drop,
* and icon activation.
*/
static void
set_up_icon_view(GtkWidget *icons, struct state *d)
{
/* Background color */
GdkRGBA transparent = {0, 0, 0, 0};
override_background_color(icons, &transparent);
/* Columns */
gtk_icon_view_set_text_column(d->icon_view, FILE_NAME);
gtk_icon_view_set_pixbuf_column(d->icon_view, FILE_ICON);
/* Drag */
gtk_drag_source_set(icons, GDK_BUTTON1_MASK,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_text_targets(icons);
gtk_drag_source_add_uri_targets(icons);
g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d);
g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d);
g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d);
/* Drop */
gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_text_targets(icons);
gtk_drag_dest_add_uri_targets(icons);
g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d);
g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d);
g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d);
/* Activations */
g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d);
g_signal_connect(icons, "button-press-event", G_CALLBACK(on_desktop_icon_button_press_event), d);
}
static void
ddb_tabstrip_realize (GtkWidget *widget) {
DdbTabStrip *darea = DDB_TABSTRIP (widget);
GdkWindowAttr attributes;
gint attributes_mask;
if (!gtk_widget_get_has_window (widget))
{
GTK_WIDGET_CLASS (ddb_tabstrip_parent_class)->realize (widget);
}
else
{
gtk_widget_set_realized (widget, TRUE);
attributes.window_type = GDK_WINDOW_CHILD;
GtkAllocation a;
gtk_widget_get_allocation (widget, &a);
attributes.x = a.x;
attributes.y = a.y;
attributes.width = a.width;
attributes.height = a.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
#if !GTK_CHECK_VERSION(3,0,0)
attributes.colormap = gtk_widget_get_colormap (widget);
#endif
attributes.event_mask = gtk_widget_get_events (widget);
attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
#if !GTK_CHECK_VERSION(3,0,0)
attributes_mask |= GDK_WA_COLORMAP;
#endif
GdkWindow *window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
gtk_widget_set_window(widget, window);
gdk_window_set_user_data (gtk_widget_get_window(widget), darea);
#if !GTK_CHECK_VERSION(3,0,0)
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
#else
gtk_style_context_set_background (gtk_widget_get_style_context (widget), window);
#endif
}
ddb_tabstrip_send_configure (DDB_TABSTRIP (widget));
GtkTargetEntry entry = {
.target = TARGET_PLAYITEMS,
.flags = GTK_TARGET_SAME_APP,
.info = TARGET_SAMEWIDGET
};
gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, &entry, 1, GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_uri_targets (widget);
gtk_drag_dest_set_track_motion (widget, TRUE);
}
void FskGtkDragDropWindowRegister(FskWindow fskWindow, FskDragDropTargetProc dropTargetProc)
{
FskGtkWindow gtkWin = (FskGtkWindow)fskWindow->gtkWin;
gtkWin->dropTargetProc = dropTargetProc;
gDropTargetProc = dropTargetProc;
gdk_threads_enter();
gtk_drag_dest_set(GTK_WIDGET(gtkWin->vbox), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_text_targets(GTK_WIDGET(gtkWin->vbox));
gtk_drag_dest_add_uri_targets(GTK_WIDGET(gtkWin->vbox));
g_signal_connect(G_OBJECT(gtkWin->vbox), "drag-data-received", G_CALLBACK(on_drag_data_received), gtkWin);
gdk_threads_leave();
return;
}
int
clip_GTK_DRAGDESTADDURITARGETS(ClipMachine * cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
CHECKCWID(cwid, GTK_IS_WIDGET);
gtk_drag_dest_add_uri_targets(GTK_WIDGET(cwid->widget));
return 0;
err:
return 1;
}
static void
awn_window_init( AwnWindow *window )
{
gtk_widget_add_events (GTK_WIDGET (window),GDK_ALL_EVENTS_MASK);
gtk_drag_dest_set (GTK_WIDGET (window),
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types,
GDK_ACTION_MOVE | GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (GTK_WIDGET (window));
awn_x_set_strut (GTK_WINDOW(window));
}
void set_drop_target_widget(GtkWidget *w)
{
gtk_drag_dest_set(w,
GTK_DEST_DEFAULT_ALL,
NULL, /* set targets to NULL */
0,
GDK_ACTION_COPY | GDK_ACTION_MOVE /* must be copy AND move or it won't
work with all WMs / Filemanagers */
);
gtk_drag_dest_add_text_targets(w); /* add text targets */
gtk_drag_dest_add_uri_targets(w); /* add uri targets, to eg include nautilus list view drops */
g_signal_connect (G_OBJECT(w), "drag-data-received", G_CALLBACK(drag_data_received_handler), NULL);
g_signal_connect (G_OBJECT(w), "drag-drop", G_CALLBACK(drag_drop_handler), NULL);
}
static void
panel_run_dialog_setup_entry (PanelRunDialog *dialog,
GtkBuilder *gui)
{
GdkScreen *screen;
int width_request;
GtkWidget *entry;
dialog->combobox = PANEL_GTK_BUILDER_GET (gui, "comboboxentry");
entry = gtk_bin_get_child (GTK_BIN (dialog->combobox));
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_combo_box_set_model (GTK_COMBO_BOX (dialog->combobox),
_panel_run_get_recent_programs_list (dialog));
gtk_combo_box_set_entry_text_column
(GTK_COMBO_BOX (dialog->combobox), 0);
screen = gtk_window_get_screen (GTK_WINDOW (dialog->run_dialog));
/* 1/4 the width of the first monitor should be a good value */
width_request = panel_multiscreen_width (screen, 0) / 4;
g_object_set (G_OBJECT (dialog->combobox),
"width_request", width_request,
NULL);
g_signal_connect (entry, "key-press-event",
G_CALLBACK (entry_event), dialog);
dialog->changed_id = g_signal_connect (dialog->combobox, "changed",
G_CALLBACK (combobox_changed),
dialog);
gtk_drag_dest_unset (dialog->combobox);
gtk_drag_dest_set (dialog->combobox,
GTK_DEST_DEFAULT_MOTION|GTK_DEST_DEFAULT_HIGHLIGHT,
NULL, 0,
GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (dialog->combobox);
g_signal_connect (dialog->combobox, "drag_data_received",
G_CALLBACK (entry_drag_data_received), dialog);
}
static void
cc_background_panel_init (CcBackgroundPanel *self)
{
CcBackgroundPanelPrivate *priv;
gchar *objects[] = { "style-liststore",
"sources-liststore", "background-panel", "sizegroup", NULL };
GError *err = NULL;
GtkWidget *widget;
GtkListStore *store;
GtkStyleContext *context;
priv = self->priv = BACKGROUND_PANEL_PRIVATE (self);
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_file (priv->builder,
DATADIR"/background.ui",
objects, &err);
if (err)
{
g_warning ("Could not load ui: %s", err->message);
g_error_free (err);
return;
}
/* See shell_notify_cb for details */
g_signal_connect (WID ("scrolledwindow1"), "realize",
G_CALLBACK (scrolled_realize_cb), self);
priv->settings = g_settings_new (WP_PATH_ID);
g_settings_delay (priv->settings);
store = (GtkListStore*) gtk_builder_get_object (priv->builder,
"sources-liststore");
priv->wallpapers_source = bg_wallpapers_source_new ();
gtk_list_store_insert_with_values (store, NULL, G_MAXINT,
COL_SOURCE_NAME, _("Wallpapers"),
COL_SOURCE_TYPE, SOURCE_WALLPAPERS,
COL_SOURCE, priv->wallpapers_source,
-1);
priv->pictures_source = bg_pictures_source_new ();
gtk_list_store_insert_with_values (store, NULL, G_MAXINT,
COL_SOURCE_NAME, _("Pictures Folder"),
COL_SOURCE_TYPE, SOURCE_PICTURES,
COL_SOURCE, priv->pictures_source,
-1);
priv->colors_source = bg_colors_source_new ();
gtk_list_store_insert_with_values (store, NULL, G_MAXINT,
COL_SOURCE_NAME, _("Colors & Gradients"),
COL_SOURCE_TYPE, SOURCE_COLORS,
COL_SOURCE, priv->colors_source,
-1);
#ifdef HAVE_LIBSOCIALWEB
priv->flickr_source = bg_flickr_source_new ();
gtk_list_store_insert_with_values (store, NULL, G_MAXINT,
COL_SOURCE_NAME, _("Flickr"),
COL_SOURCE_TYPE, SOURCE_FLICKR,
COL_SOURCE, priv->flickr_source,
-1);
#endif
/* add the top level widget */
widget = WID ("background-panel");
gtk_container_add (GTK_CONTAINER (self), widget);
gtk_widget_show_all (GTK_WIDGET (self));
/* connect to source change signal */
widget = WID ("sources-combobox");
g_signal_connect (widget, "changed", G_CALLBACK (source_changed_cb), priv);
/* select first item */
gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
/* connect to the background iconview change signal */
widget = WID ("backgrounds-iconview");
g_signal_connect (widget, "selection-changed",
G_CALLBACK (backgrounds_changed_cb),
self);
/* Join treeview and buttons */
widget = WID ("scrolledwindow1");
context = gtk_widget_get_style_context (widget);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
widget = WID ("toolbar1");
context = gtk_widget_get_style_context (widget);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
g_signal_connect (WID ("add_button"), "clicked",
G_CALLBACK (add_button_clicked), self);
g_signal_connect (WID ("remove_button"), "clicked",
G_CALLBACK (remove_button_clicked), self);
/* Add drag and drop support for bg images */
widget = WID ("scrolledwindow1");
gtk_drag_dest_set (widget, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (widget);
g_signal_connect (widget, "drag-data-received",
G_CALLBACK (cc_background_panel_drag_uris), self);
/* setup preview area */
gtk_label_set_ellipsize (GTK_LABEL (WID ("background-label")), PANGO_ELLIPSIZE_END);
widget = WID ("preview-area");
g_signal_connect (widget, "draw", G_CALLBACK (preview_draw_cb),
self);
priv->display_base = gdk_pixbuf_new_from_file (DATADIR "/display-base.png",
NULL);
priv->display_overlay = gdk_pixbuf_new_from_file (DATADIR
"/display-overlay.png",
NULL);
g_signal_connect (WID ("style-combobox"), "changed",
G_CALLBACK (style_changed_cb), self);
g_signal_connect (WID ("style-pcolor"), "color-set",
G_CALLBACK (color_changed_cb), self);
g_signal_connect (WID ("style-scolor"), "color-set",
G_CALLBACK (color_changed_cb), self);
g_signal_connect (WID ("swap-color-button"), "clicked",
G_CALLBACK (swap_colors_clicked), self);
priv->copy_cancellable = g_cancellable_new ();
priv->thumb_factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
load_current_bg (self);
update_preview (priv, NULL);
/* Setup the edit box with our current settings */
source_update_edit_box (priv, TRUE);
}
I7PrefsWidgets *
create_prefs_window(GSettings *prefs, GtkBuilder *builder)
{
I7PrefsWidgets *self = g_slice_new0(I7PrefsWidgets);
self->window = GTK_WIDGET(load_object(builder, "prefs_dialog"));
self->prefs_notebook = GTK_WIDGET(load_object(builder, "prefs_notebook"));
self->schemes_view = GTK_TREE_VIEW(load_object(builder, "schemes_view"));
self->style_remove = GTK_WIDGET(load_object(builder, "style_remove"));
self->tab_example = GTK_SOURCE_VIEW(load_object(builder, "tab_example"));
self->source_example = GTK_SOURCE_VIEW(load_object(builder, "source_example"));
self->extensions_view = GTK_TREE_VIEW(load_object(builder, "extensions_view"));
self->extensions_add = GTK_WIDGET(load_object(builder, "extensions_add"));
self->extensions_remove = GTK_WIDGET(load_object(builder, "extensions_remove"));
self->auto_number = GTK_WIDGET(load_object(builder, "auto_number"));
self->clean_index_files = GTK_WIDGET(load_object(builder, "clean_index_files"));
self->schemes_list = GTK_LIST_STORE(load_object(builder, "schemes_list"));
/* Bind widgets to GSettings */
#define BIND(key, obj, property) \
g_settings_bind(prefs, key, load_object(builder, obj), property, \
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_NO_SENSITIVITY)
#define BIND_COMBO_BOX(key, obj, enum_values) \
g_settings_bind_with_mapping(prefs, key, \
load_object(builder, obj), "active", \
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_NO_SENSITIVITY, \
(GSettingsBindGetMapping)settings_enum_get_mapping, \
(GSettingsBindSetMapping)settings_enum_set_mapping, \
enum_values, NULL)
BIND(PREFS_AUTHOR_NAME, "author_name", "text");
BIND(PREFS_CUSTOM_FONT, "custom_font", "font-name");
BIND(PREFS_SYNTAX_HIGHLIGHTING, "enable_highlighting", "active");
BIND(PREFS_AUTO_INDENT, "auto_indent", "active");
BIND(PREFS_INDENT_WRAPPED, "indent_wrapped", "active");
BIND(PREFS_INTELLIGENCE, "follow_symbols", "active");
BIND(PREFS_INTELLIGENCE, "auto_number", "sensitive");
BIND(PREFS_AUTO_NUMBER, "auto_number", "active");
BIND(PREFS_CLEAN_BUILD_FILES, "clean_build_files", "active");
BIND(PREFS_CLEAN_BUILD_FILES, "clean_index_files", "sensitive");
BIND(PREFS_CLEAN_INDEX_FILES, "clean_index_files", "active");
BIND(PREFS_SHOW_DEBUG_LOG, "show_debug_tabs", "active");
BIND_COMBO_BOX(PREFS_FONT_SET, "font_set", font_set_enum);
BIND_COMBO_BOX(PREFS_FONT_SIZE, "font_size", font_size_enum);
BIND_COMBO_BOX(PREFS_INTERPRETER, "glulx_combo", interpreter_enum);
#undef BIND
#undef BIND_COMBO_BOX
g_settings_bind(prefs, PREFS_TAB_WIDTH,
gtk_range_get_adjustment(GTK_RANGE(load_object(builder, "tab_ruler"))), "value", G_SETTINGS_BIND_DEFAULT);
/* Only select one extension at a time */
GtkTreeSelection *select = gtk_tree_view_get_selection(self->extensions_view);
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
/* Connect the drag'n'drop stuff */
gtk_drag_dest_set(GTK_WIDGET(self->extensions_view),
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT,
NULL, 0, GDK_ACTION_COPY);
/* For some reason GTK_DEST_DEFAULT_DROP causes two copies of every file to
be sent to the widget when dropped, so we omit that. Also,
GTK_DEST_DEFAULT_HIGHLIGHT seems to be broken. Including it anyway. */
gtk_drag_dest_add_uri_targets(GTK_WIDGET(self->extensions_view));
/* Do the style scheme list */
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(self->schemes_list), 0, GTK_SORT_ASCENDING);
select = gtk_tree_view_get_selection(self->schemes_view);
gtk_tree_selection_set_mode(select, GTK_SELECTION_BROWSE);
select_style_scheme(self->schemes_view, g_settings_get_string(prefs, PREFS_STYLE_SCHEME));
return self;
}
gint
main (gint argc, gchar * argv[])
{
GstElement *pipeline;
GstElement *uload, *filter, *sink;
GstElement *sourcebin;
GstBus *bus;
GError *error = NULL;
GtkWidget *window;
GtkWidget *screen;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *play, *pause, *null, *ready;
gchar **source_desc_array = NULL;
gchar *source_desc = NULL;
GOptionContext *context;
GOptionEntry options[] = {
{"source-bin", 's', 0, G_OPTION_ARG_STRING_ARRAY, &source_desc_array,
"Use a custom source bin description (gst-launch style)", NULL}
,
{"method", 'm', 0, G_OPTION_ARG_INT, &method,
"1 for gstdifferencematte, 2 for gloverlay", "M"}
,
{"delay", 'd', 0, G_OPTION_ARG_INT, &delay,
"Wait N seconds before to send the image to gstreamer (useful with differencematte)",
"N"}
,
{NULL}
};
g_thread_init (NULL);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gst_init_get_option_group ());
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("Inizialization error: %s\n", GST_STR_NULL (error->message));
return -1;
}
g_option_context_free (context);
if (source_desc_array != NULL) {
source_desc = g_strjoinv (" ", source_desc_array);
g_strfreev (source_desc_array);
}
if (source_desc == NULL) {
source_desc =
g_strdup
("videotestsrc ! video/x-raw-rgb, width=352, height=288 ! identity");
}
sourcebin =
gst_parse_bin_from_description (g_strdup (source_desc), TRUE, &error);
g_free (source_desc);
if (error) {
g_print ("Error while parsing source bin description: %s\n",
GST_STR_NULL (error->message));
return -1;
}
g_set_application_name ("gst-gl-effects test app");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (window), 3);
pipeline = gst_pipeline_new ("pipeline");
uload = gst_element_factory_make ("glupload", "glu");
if (method == 2) {
filter = gst_element_factory_make ("gloverlay", "flt");
} else {
filter = gst_element_factory_make ("gldifferencematte", "flt");
}
sink = gst_element_factory_make ("glimagesink", "glsink");
gst_bin_add_many (GST_BIN (pipeline), sourcebin, uload, filter, sink, NULL);
if (!gst_element_link_many (sourcebin, uload, filter, sink, NULL)) {
g_print ("Failed to link one or more elements!\n");
return -1;
}
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (destroy_cb), pipeline);
g_signal_connect (G_OBJECT (window), "destroy-event",
G_CALLBACK (destroy_cb), pipeline);
screen = gtk_drawing_area_new ();
gtk_widget_set_size_request (screen, 640, 480); // 500 x 376
vbox = gtk_vbox_new (FALSE, 2);
gtk_box_pack_start (GTK_BOX (vbox), screen, TRUE, TRUE, 0);
hbox = gtk_hbox_new (FALSE, 0);
play = gtk_button_new_with_label ("PLAY");
g_signal_connect (G_OBJECT (play), "clicked", G_CALLBACK (play_cb), pipeline);
pause = gtk_button_new_with_label ("PAUSE");
g_signal_connect (G_OBJECT (pause), "clicked",
G_CALLBACK (pause_cb), pipeline);
null = gtk_button_new_with_label ("NULL");
g_signal_connect (G_OBJECT (null), "clicked", G_CALLBACK (null_cb), pipeline);
ready = gtk_button_new_with_label ("READY");
g_signal_connect (G_OBJECT (ready), "clicked",
G_CALLBACK (ready_cb), pipeline);
gtk_box_pack_start (GTK_BOX (hbox), null, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), ready, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), play, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), pause, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
gst_bus_set_sync_handler (bus, (GstBusSyncHandler) create_window, screen);
gst_bus_add_signal_watch (bus);
g_signal_connect (bus, "message::error", G_CALLBACK (message_cb), pipeline);
g_signal_connect (bus, "message::warning", G_CALLBACK (message_cb), pipeline);
g_signal_connect (bus, "message::eos", G_CALLBACK (message_cb), pipeline);
gst_object_unref (bus);
g_signal_connect (screen, "expose-event", G_CALLBACK (expose_cb), sink);
g_signal_connect (screen, "realize", G_CALLBACK (realize_cb), pipeline);
gtk_drag_dest_set (screen, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (screen);
g_signal_connect (screen, "drag-data-received",
G_CALLBACK (on_drag_data_received), filter);
gtk_widget_show_all (GTK_WIDGET (window));
gtk_main ();
return 0;
}
static VALUE
rg_m_dest_add_uri_targets(VALUE self, VALUE widget)
{
gtk_drag_dest_add_uri_targets(RVAL2WIDGET(widget));
return self;
}
MainWindow::MainWindow(GladeSearchpath * gladeSearchPath, Control * control) :
GladeGui(gladeSearchPath, "main.glade", "mainWindow") {
XOJ_INIT_TYPE(MainWindow);
this->control = control;
this->toolbarIntialized = false;
this->toolbarGroup = NULL;
this->selectedToolbar = NULL;
this->toolbarWidgets = new GtkWidget*[TOOLBAR_DEFINITIONS_LEN];
for (int i = 0; i < TOOLBAR_DEFINITIONS_LEN; i++) {
GtkWidget * w = get(TOOLBAR_DEFINITIONS[i].guiName);
g_object_ref(w);
this->toolbarWidgets[i] = w;
}
this->maximized = false;
this->toolbarMenuData = NULL;
this->toolbarMenuitems = NULL;
GtkWidget * tableXournal = get("tableXournal");
this->xournal = new XournalView(tableXournal, control);
ScrollbarHideType type = control->getSettings()->getScrollbarHideType();
if (type == SCROLLBAR_HIDE_NONE || type == SCROLLBAR_HIDE_VERTICAL) {
Layout * layout = gtk_xournal_get_layout(this->xournal->getWidget());
gtk_table_attach(GTK_TABLE(tableXournal), layout->getScrollbarHorizontal(), 1, 2, 1, 2, (GtkAttachOptions)(
GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
}
setSidebarVisible(control->getSettings()->isSidebarVisible());
// Window handler
g_signal_connect(this->window, "delete-event", (GCallback) & deleteEventCallback, this->control);
g_signal_connect(this->window, "window_state_event", G_CALLBACK(&windowStateEventCallback), this);
g_signal_connect(get("buttonCloseSidebar"), "clicked", G_CALLBACK(buttonCloseSidebarClicked), this);
this->toolbar = new ToolMenuHandler(this->control, this->control->getZoomControl(), this,
this->control->getToolHandler(), GTK_WINDOW(getWindow()));
char * file = gladeSearchPath->findFile(NULL, "toolbar.ini");
ToolbarModel * tbModel = this->toolbar->getModel();
if (!tbModel->parse(file, true)) {
GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(this->window), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, _("Could not parse general toolbar.ini file: %s\nNo Toolbars will be available"), file);
gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(getWindow()));
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_hide(dlg);
gtk_widget_destroy(dlg);
}
g_free(file);
file = g_build_filename(g_get_home_dir(), G_DIR_SEPARATOR_S, CONFIG_DIR, G_DIR_SEPARATOR_S, TOOLBAR_CONFIG, NULL);
if (g_file_test(file, G_FILE_TEST_EXISTS)) {
if (!tbModel->parse(file, false)) {
GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(this->window), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, _("Could not parse custom toolbar.ini file: %s\nToolbars will not be available"), file);
gtk_window_set_transient_for(GTK_WINDOW(dlg), GTK_WINDOW(this->control->getWindow()->getWindow()));
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_hide(dlg);
gtk_widget_destroy(dlg);
}
}
g_free(file);
initToolbarAndMenu();
GtkWidget * menuViewSidebarVisible = get("menuViewSidebarVisible");
g_signal_connect(menuViewSidebarVisible, "toggled", (GCallback) viewShowSidebar, this);
updateScrollbarSidebarPosition();
gtk_window_set_default_size(GTK_WINDOW(this->window), control->getSettings()->getMainWndWidth(),
control->getSettings()->getMainWndHeight());
if (control->getSettings()->isMainWndMaximized()) {
gtk_window_maximize(GTK_WINDOW(this->window));
} else {
gtk_window_unmaximize(GTK_WINDOW(this->window));
}
getSpinPageNo()->addListener(this->control->getScrollHandler());
// Drag and Drop
g_signal_connect(this->window, "drag-data-received", G_CALLBACK(dragDataRecived), this);
gtk_drag_dest_set(this->window, GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets(this->window);
gtk_drag_dest_add_image_targets(this->window);
gtk_drag_dest_add_text_targets(this->window);
}
GtkWidget *
task_item_new (WnckWindow *window)
{
GtkWidget *item = NULL;
TaskItem *task;
TaskItemPrivate *priv;
WnckScreen *screen;
g_return_val_if_fail (WNCK_IS_WINDOW (window), item);
item = g_object_new (TASK_TYPE_ITEM,
"has-tooltip", TRUE,
"visible-window", FALSE,
"above-child", TRUE,
NULL);
gtk_widget_add_events (item, GDK_ALL_EVENTS_MASK);
gtk_container_set_border_width (GTK_CONTAINER (item), 0);
task = TASK_ITEM (item);
priv = task->priv;
priv->window = window;
screen = wnck_window_get_screen (window);
priv->screen = screen;
gtk_drag_dest_set (item,
GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
drop_types, n_drop_types,
GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets (item);
gtk_drag_dest_add_text_targets (item);
g_signal_connect (item, "drag-motion",
G_CALLBACK (on_drag_motion), NULL);
g_signal_connect (item, "drag-leave",
G_CALLBACK (on_drag_leave), NULL);
g_signal_connect (screen, "viewports-changed",
G_CALLBACK (on_screen_active_viewport_changed), item);
g_signal_connect (screen, "active-window-changed",
G_CALLBACK (on_screen_active_window_changed), item);
g_signal_connect (screen, "active-workspace-changed",
G_CALLBACK (on_screen_active_workspace_changed), item);
g_signal_connect (screen, "window-closed",
G_CALLBACK (on_screen_window_closed), item);
g_signal_connect (window, "workspace-changed",
G_CALLBACK (on_window_workspace_changed), item);
g_signal_connect (window, "state-changed",
G_CALLBACK (on_window_state_changed), item);
g_signal_connect (window, "icon-changed",
G_CALLBACK (on_window_icon_changed), item);
g_signal_connect (item, "button-release-event",
G_CALLBACK (on_task_item_button_released), item);
g_signal_connect (item, "button-press-event",
G_CALLBACK (on_button_pressed), item);
g_signal_connect (item, "size-allocate",
G_CALLBACK (on_size_allocate), item);
g_signal_connect (item, "query-tooltip",
G_CALLBACK (on_query_tooltip), item);
g_signal_connect (item, "enter-notify-event",
G_CALLBACK (on_enter_notify), item);
g_signal_connect (item, "leave-notify-event",
G_CALLBACK (on_leave_notify), item);
g_signal_connect (item, "drag-motion",
G_CALLBACK (on_drag_motion), item);
g_signal_connect (item, "drag-leave",
G_CALLBACK (on_drag_leave), item);
task_item_set_visibility (task);
task_item_setup_atk (task);
return item;
}
int main(int argc, char ** argv)
{
GtkWidget * vbox;
GtkWidget * hpaned;
GtkWidget * sc_win, * sc_buffer;
GtkWidget * menu_bar;
GtkWidget * file_menu, * file_item;
GtkWidget * generate_menu, * generate_item;
GtkWidget * settings_menu, * settings_item;
GtkWidget * zoom_box, * zoom_button;
int i;
//init general
colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t));
oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t));
memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *));
memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *));
memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *));
mdata[current_buffer] = (unsigned char *)malloc(128 * 128);
load_colors_plain(colors, "colors");
load_colors_plain(oldcolors, "oldcolors");
newcolors = colors;
//save_colors(colors, "colors.bin");
//load_colors(colors, "colors.bin");
srand(time(NULL));
config = config_new();
//init gtk
gtk_init(&argc, &argv);
//window
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER);
g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL);
//vbox
#ifdef GTK2
vbox = gtk_vbox_new(FALSE, 0);
#else
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER (window), vbox);
gtk_widget_show(vbox);
//////menu_bar
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0);
gtk_widget_show(menu_bar);
////////file_menu
file_menu = gtk_menu_new();
//////////file_menu items
construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN);
construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE);
construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE);
construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT);
construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL);
construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM);
construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE);
/* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */
construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM);
construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN);
construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT);
/////////file_item
file_item = gtk_menu_item_new_with_label("File");
gtk_widget_show(file_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item);
////////generate_menu
generate_menu = gtk_menu_new();
//////////generate_menu items
construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT);
construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA);
construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE);
construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE);
construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD);
/////////generate_item
generate_item = gtk_menu_item_new_with_label("Generate");
gtk_widget_show(generate_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item);
////////settings_menu
settings_menu = gtk_menu_new();
////////settings_item
settings_item = gtk_menu_item_new_with_label("Settings");
gtk_widget_show(settings_item);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu);
gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item);
//////////FSD_checkbox
FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox);
gtk_widget_show(FSD_checkbox);
//////////YUV_checkbox
YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox);
gtk_widget_show(YUV_checkbox);
//////////old_colors_checkbox
old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors");
gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox);
gtk_widget_show(old_colors_checkbox);
g_signal_connect_swapped(old_colors_checkbox, "toggled",
G_CALLBACK(old_colors_checkbox_toggle), 0);
//drop_down_menu
init_drop_down_menu();
//hpaned
#ifdef GTK2
hpaned = gtk_hpaned_new();
#else
hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
#endif
gtk_widget_set_size_request (hpaned, 220, -1);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show(hpaned);
////sc_buffer
sc_buffer = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_buffer, 128 + 32, 512);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512);
#endif
gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE);
gtk_widget_show(sc_buffer);
//////list_vbox
#ifdef GTK2
list_vbox = gtk_vbox_new(FALSE, 0);
#else
list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#endif
#ifdef GTK2
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox);
#else
gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox);
#endif
gtk_widget_show(list_vbox);
////sc_win
sc_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
#ifdef GTK2
gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4);
gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70);
#else
gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4);
#endif
gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE);
gtk_widget_show(sc_win);
//////image
dimage = gdk_pixbuf_new_from_file("start.png", NULL);
image = gtk_image_new();
gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage);
#ifdef GTK2
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image);
#else
gtk_container_add(GTK_CONTAINER(sc_win), image);
#endif
gtk_widget_show(image);
////zoom_box
#ifdef GTK2
zoom_box = gtk_hbox_new(FALSE, 0);
#else
zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0);
gtk_widget_show(zoom_box);
//////zoom_button (+)
zoom_button = gtk_button_new_with_label("+");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp");
gtk_widget_show(zoom_button);
//////zoom_button (|)
zoom_button = gtk_button_new_with_label("|");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome");
gtk_widget_show(zoom_button);
//////zoom_button (-)
zoom_button = gtk_button_new_with_label("-");
gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2);
g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm");
gtk_widget_show(zoom_button);
//icon
gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico"));
//Drag and drop
gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY);
gtk_drag_dest_add_uri_targets(window);
g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL);
g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL);
g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL);
g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL);
//display window
gtk_widget_show (window);
gtk_main();
//clean up
free(colors);
for(i = 0; i < BUFFER_COUNT; i++)
free(mdata[i]);
config_free(config);
return 0;
}
/*
* Set up the window: build the interface, connect the signals, insert the
* file icons.
*/
static GtkWidget *
prepare_window(char *dir, struct geometry *geometry, struct state *d)
{
GtkBuilder *builder;
GtkWidget *icons, *window, *directory_close, *file_open;
GtkWidget *directory_up, *directory_open, *help_about;
GtkListStore *model;
builder = gtk_builder_new_from_file(INTERFACE_PATH);
window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
icons = GTK_WIDGET(gtk_builder_get_object(builder, "icons"));
directory_up = GTK_WIDGET(gtk_builder_get_object(builder, "directory-up-menu-item"));
directory_open = GTK_WIDGET(gtk_builder_get_object(builder, "directory-open-menu-item"));
directory_close = GTK_WIDGET(gtk_builder_get_object(builder, "directory-close-menu-item"));
file_open = GTK_WIDGET(gtk_builder_get_object(builder, "file-open-menu-item"));
help_about = GTK_WIDGET(gtk_builder_get_object(builder, "help-about-menu-item"));
d->icon_view = GTK_ICON_VIEW(icons);
g_object_unref(builder);
gtk_window_set_default_size(GTK_WINDOW(window), geometry->w,
geometry->h);
gtk_window_move(GTK_WINDOW(window), geometry->x, geometry->y);
gtk_window_set_title(GTK_WINDOW(window), dir);
model = gtk_list_store_new(MODEL_CNT,
G_TYPE_STRING, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT);
if (populate(model, dir) == -1)
err(66, "failed to populate icon model from %s", dir);
watch_dir(model, dir);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(icons), 0);
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(icons), 1);
gtk_icon_view_set_model(GTK_ICON_VIEW(icons), GTK_TREE_MODEL(model));
g_object_unref(model);
gtk_widget_set_sensitive(directory_up, strlen(d->dir) > 1);
/* Drag */
gtk_drag_source_set(icons, GDK_BUTTON1_MASK,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_source_add_text_targets(icons);
gtk_drag_source_add_uri_targets(icons);
g_signal_connect(icons, "drag-begin", G_CALLBACK(on_icons_drag_begin), d);
g_signal_connect(icons, "drag-data-get", G_CALLBACK(on_icons_drag_data_get), d);
g_signal_connect(icons, "drag-end", G_CALLBACK(on_icons_drag_end), d);
/* Drop */
gtk_drag_dest_set(icons, GTK_DEST_DEFAULT_ALL,
dnd_targets, TARGET_COUNT,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_add_text_targets(icons);
gtk_drag_dest_add_uri_targets(icons);
g_signal_connect(icons, "drag-motion", G_CALLBACK(on_icons_drag_motion), d);
g_signal_connect(icons, "drag-leave", G_CALLBACK(on_icons_data_leave), d);
g_signal_connect(icons, "drag-data-received", G_CALLBACK(on_icons_drag_data_received), d);
/* Activations */
g_signal_connect(icons, "item-activated", G_CALLBACK(on_icons_item_activated), d);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "configure-event", G_CALLBACK(on_window_configure_event), dir);
g_signal_connect(directory_up, "activate", G_CALLBACK(on_directory_up_menu_item_activate), d);
g_signal_connect(directory_open, "activate", G_CALLBACK(on_directory_open_menu_item_activate), d);
g_signal_connect(directory_close, "activate", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(file_open, "activate", G_CALLBACK(on_file_open_menu_item_activate), d);
g_signal_connect(help_about, "activate", G_CALLBACK(on_help_about_menu_item_activate), NULL);
g_signal_connect(icons, "button-press-event", G_CALLBACK(on_icons_button_press_event), d);
return window;
}
void pCanvas::setDroppable(bool droppable) {
gtk_drag_dest_set(gtkWidget, GTK_DEST_DEFAULT_ALL, nullptr, 0, GDK_ACTION_COPY);
if(droppable) gtk_drag_dest_add_uri_targets(gtkWidget);
}
int dnd___::proc__(std::deque<Glib::ustring>* p,char*buf,long siz,char**addr_ret,void*shangji,void*ce) {
if((*p)[0]==name__()){
if(siz==-1)return 1;
if(p->size()<3){
d_(sh_,err_show_buzu_,p);
return 1;
}
Gtk::Widget* w;
sh_->builder_->get_widget((*p)[2], w);
if(!w){
d_(sh_,err_show_wufa_,2,p,2);
return 1;
}
GtkWidget* w1=w->gobj();
if((*p)[1]=="移除"){
del__(w1);
return 1;
}
if((*p)[1]=="目标"){
if(p->size()<6){
d_(sh_,err_show_buzu_,p);
return 1;
}
int gdd=0,gda=0;
dnd_cb___* cb=new dnd_cb___('d',w1,sh_,d_);
for(size_t i=3;i<p->size();i++){
const Glib::ustring& p1=(*p)[i];
if(p1=="代码"){
if(++i>=p->size()){
d_(sh_,err_show_buzu_,p);
delete cb;
return 1;
}
cb->code_=(*p)[i];
continue;
}
if(p1=="复制"){
gda|=GDK_ACTION_COPY;
continue;
}
if(p1=="移动"){
gda|=GDK_ACTION_MOVE;
continue;
}
if(p1=="链接"){
gda|=GDK_ACTION_LINK;
continue;
}
if(p1=="高亮"){
gdd|=GTK_DEST_DEFAULT_HIGHLIGHT|GTK_DEST_DEFAULT_MOTION;
continue;
}
if(p1=="按钮"){
gdd|=GTK_DEST_DEFAULT_DROP|GTK_DEST_DEFAULT_MOTION;
continue;
}
delete cb;
d_(sh_,err_show_buzhichi_,2,p,i);
return 1;
}
gtk_drag_dest_set (w1, (GtkDestDefaults)gdd, 0, 0, (GdkDragAction)gda);
gtk_drag_dest_add_uri_targets(w1);
cb->sid_=g_signal_connect (w1, "drag-data-received",G_CALLBACK(drag_data_received__), cb);
cb_.push_back(cb);
return 1;
}
d_(sh_,err_show_buzhichi_,2,p,1);
return 1;
}
return 0;
}
