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; }