int main( int argc, char *argv[] ) { GtkWidget *window; GtkWidget *drawing_area; GtkWidget *vbox; GtkWidget *v1box; GtkWidget *hbox; GtkWidget *button; gtk_init (&argc, &argv); printf("Helo\n"); int i,j; for(i=0;i<1000;i++) { for(j=0;j<1000;j++) { pixels[i][j]=0; visited[i][j]=0; } } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_title(GTK_WINDOW(window), "pencil_project"); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); g_signal_connect (GTK_WINDOW(window), "destroy", G_CALLBACK (quit), NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); v1box = newVerticalbox ( FALSE, 0, TRUE, TRUE, 0 ); gtk_box_pack_start (GTK_BOX (hbox), v1box, FALSE, FALSE, 0); gtk_widget_show (v1box); /* Create the drawing area */ drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (drawing_area), breadth, height);//breadth,height global variables in buttons.h //cr = gdk_cairo_create(drawing_area->window); gtk_box_pack_start (GTK_BOX (hbox), drawing_area, TRUE, TRUE, 0); gtk_widget_show (drawing_area); g_signal_connect (drawing_area, "expose_event", G_CALLBACK (expose_event),NULL); /* g_signal_connect (drawing_area, "configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (drawing_area, "motion_notify_event", G_CALLBACK (motion_notify_event), NULL);//made them null as it don't have significance. handler_id = g_signal_connect (drawing_area, "button_press_event", G_CALLBACK (button_press_event), NULL); gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK |GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK |GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); button = horizontal_box ( FALSE, 0, TRUE, TRUE, 0, TRUE ); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); button = horizontal_box ( FALSE, 0, TRUE, TRUE, 0, FALSE ); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Fill"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect_swapped (button, "clicked", G_CALLBACK (button_press_event_fill), drawing_area); gtk_widget_show_all (window); gtk_main (); return 0; }
static gboolean la_handler_service_handle_register (LAHandler *interface, GDBusMethodInvocation *invocation, const gchar *unit, NSMShutdownType shutdown_mode, guint timeout, LAHandlerService *service) { ShutdownConsumer *consumer; ShutdownClient *client; GError *error = NULL; const gchar *existing_bus_name; const gchar *existing_object_path; gchar *bus_name; gchar *object_path; g_return_val_if_fail (IS_LA_HANDLER (interface), FALSE); g_return_val_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation), FALSE); g_return_val_if_fail (unit != NULL && *unit != '\0', FALSE); g_return_val_if_fail (LA_HANDLER_IS_SERVICE (service), FALSE); if (shutdown_mode != NSM_SHUTDOWN_TYPE_NORMAL && shutdown_mode != NSM_SHUTDOWN_TYPE_FAST && shutdown_mode != (NSM_SHUTDOWN_TYPE_NORMAL | NSM_SHUTDOWN_TYPE_FAST)) { /* the shutdown mode is invalid */ DLT_LOG (la_handler_context, DLT_LOG_ERROR, DLT_STRING ("Failed to register legacy application: " "invalid shutdown mode"), DLT_INT (shutdown_mode)); la_handler_complete_register (interface, invocation); return TRUE; } /* find out if we have a shutdown client for this unit already */ client = g_hash_table_lookup (service->units_to_clients, unit); if (client != NULL) { /* there already is a shutdown client for the unit, so simply * re-register its client with the new shutdown mode and timeout */ /* extract information from the client */ existing_bus_name = shutdown_client_get_bus_name (client); existing_object_path = shutdown_client_get_object_path (client); /* temporarily store a reference to the legacy app handler service object * in the invocation object */ g_object_set_data_full (G_OBJECT (invocation), "la-handler-service", g_object_ref (service), (GDestroyNotify) g_object_unref); /* re-register the shutdown consumer with the NSM Consumer */ nsm_consumer_call_register_shutdown_client (service->nsm_consumer, existing_bus_name, existing_object_path, shutdown_mode, timeout, NULL, la_handler_service_handle_register_finish, invocation); } else { /* create a new shutdown client and consumer for the unit */ bus_name = "org.genivi.NodeStartupController1"; object_path = g_strdup_printf ("%s/%u", service->prefix, service->index); client = shutdown_client_new (bus_name, object_path, shutdown_mode, timeout); consumer = shutdown_consumer_skeleton_new (); shutdown_client_set_consumer (client, consumer); /* remember the legacy app handler service object in shutdown client */ g_object_set_data_full (G_OBJECT (client), "la-handler-service", g_object_ref (service), (GDestroyNotify) g_object_unref); /* implement the LifecycleRequest method of the shutdown consumer */ g_signal_connect (consumer, "handle-lifecycle-request", G_CALLBACK (la_handler_service_handle_consumer_lifecycle_request), client); /* associate the shutdown client with the unit name */ g_hash_table_insert (service->units_to_clients, g_strdup (unit), g_object_ref (client)); g_hash_table_insert (service->clients_to_units, g_object_ref (client), g_strdup (unit)); /* export the shutdown consumer on the bus */ g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (consumer), service->connection, object_path, &error); if (error != NULL) { DLT_LOG (la_handler_context, DLT_LOG_ERROR, DLT_STRING ("Failed to export shutdown consumer on the bus:"), DLT_STRING (error->message)); g_error_free (error); } /* temporarily store a reference to the legacy app handler service object * in the invocation object */ g_object_set_data_full (G_OBJECT (invocation), "la-handler-service", g_object_ref (service), (GDestroyNotify) g_object_unref); /* register the shutdown consumer with the NSM Consumer */ nsm_consumer_call_register_shutdown_client (service->nsm_consumer, bus_name, object_path, shutdown_mode, timeout, NULL, la_handler_service_handle_register_finish, invocation); /* free strings and release the shutdown consumer */ g_free (object_path); g_object_unref (consumer); /* increment the counter for our shutdown consumer object paths */ service->index++; } return TRUE; }
int main (int argc, char *argv[]) { GOptionContext *context; GSocketClient *client; GSocketConnection *connection; GSocketAddress *address; GCancellable *cancellable; GOutputStream *out; GError *error = NULL; char buffer[1000]; context = g_option_context_new (" <hostname>[:port] - send data to tcp host"); g_option_context_add_main_entries (context, cmd_entries, NULL); if (!g_option_context_parse (context, &argc, &argv, &error)) { g_printerr ("%s: %s\n", argv[0], error->message); return 1; } if (argc != 2) { g_printerr ("%s: %s\n", argv[0], "Need to specify hostname"); return 1; } if (async) loop = g_main_loop_new (NULL, FALSE); if (cancel_timeout) { GThread *thread; cancellable = g_cancellable_new (); thread = g_thread_new ("cancel", cancel_thread, cancellable); g_thread_unref (thread); } else { cancellable = NULL; } client = g_socket_client_new (); if (io_timeout) g_socket_client_set_timeout (client, io_timeout); if (verbose) g_signal_connect (client, "event", G_CALLBACK (socket_client_event), NULL); if (async) { GAsyncResult *res; g_socket_client_connect_to_host_async (client, argv[1], 7777, cancellable, async_cb, &res); g_main_loop_run (loop); connection = g_socket_client_connect_to_host_finish (client, res, &error); g_object_unref (res); } else { connection = g_socket_client_connect_to_host (client, argv[1], 7777, cancellable, &error); } if (connection == NULL) { g_printerr ("%s can't connect: %s\n", argv[0], error->message); return 1; } g_object_unref (client); address = g_socket_connection_get_remote_address (connection, &error); if (!address) { g_printerr ("Error getting remote address: %s\n", error->message); return 1; } g_print ("Connected to address: %s\n", socket_address_to_string (address)); g_object_unref (address); if (graceful) g_tcp_connection_set_graceful_disconnect (G_TCP_CONNECTION (connection), TRUE); out = g_io_stream_get_output_stream (G_IO_STREAM (connection)); while (fgets(buffer, sizeof (buffer), stdin) != NULL) { /* FIXME if (async) */ if (!g_output_stream_write_all (out, buffer, strlen (buffer), NULL, cancellable, &error)) { g_warning ("send error: %s\n", error->message); g_error_free (error); error = NULL; } } g_print ("closing stream\n"); if (async) { GAsyncResult *res; g_io_stream_close_async (G_IO_STREAM (connection), 0, cancellable, async_cb, &res); g_main_loop_run (loop); if (!g_io_stream_close_finish (G_IO_STREAM (connection), res, &error)) { g_object_unref (res); g_warning ("close error: %s\n", error->message); return 1; } g_object_unref (res); } else { if (!g_io_stream_close (G_IO_STREAM (connection), cancellable, &error)) { g_warning ("close error: %s\n", error->message); return 1; } } g_object_unref (connection); return 0; }
static void xfapplet_applet_activated (MateComponent_Unknown object, CORBA_Environment *ev, gpointer data) { GtkWidget *bw, *child = NULL; CORBA_Object control; CORBA_Environment corba_ev; MateComponentControlFrame *frame; MateComponentUIComponent *uic; MateComponent_PropertyBag prop_bag; XfAppletPlugin *xap = (XfAppletPlugin*) data; gchar *error; if (MATECOMPONENT_EX (ev) || object == CORBA_OBJECT_NIL) { error = matecomponent_exception_get_text (ev); CORBA_exception_free (ev); g_warning ("Failed to load applet '%s' (can't get CORBA object): %s\n", xap->iid, error); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); g_free (error); return; } control = CORBA_Object_duplicate (object, NULL); bw = matecomponent_widget_new_control_from_objref (object, CORBA_OBJECT_NIL); matecomponent_object_release_unref (object, NULL); if (!bw) { g_warning ("Failed to load applet '%s' (can't get matecomponent widget)\n", xap->iid); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); return; } frame = matecomponent_widget_get_control_frame (MATECOMPONENT_WIDGET (bw)); if (!frame) { g_warning ("Failed to load applet '%s' (can't get control frame)\n", xap->iid); gtk_object_sink (GTK_OBJECT (bw)); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); return; } CORBA_exception_init (&corba_ev); prop_bag = matecomponent_control_frame_get_control_property_bag (frame, &corba_ev); if (prop_bag == NULL || MATECOMPONENT_EX (&corba_ev)) { error = matecomponent_exception_get_text (&corba_ev); CORBA_exception_free (&corba_ev); g_warning ("Failed to load applet '%s' (can't get property bag): %s\n", xap->iid, error); gtk_object_sink (GTK_OBJECT (bw)); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); g_free (error); return; } uic = matecomponent_control_frame_get_popup_component (frame, &corba_ev); if (uic == NULL || MATECOMPONENT_EX (&corba_ev)) { error = matecomponent_exception_get_text (&corba_ev); CORBA_exception_free (&corba_ev); g_warning ("Failed to load applet '%s' (can't get popup component): %s\n", xap->iid, error); gtk_object_sink (GTK_OBJECT (bw)); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); g_free (error); return; } matecomponent_ui_component_freeze (uic, CORBA_OBJECT_NIL); xfce_textdomain ("xfce4-panel", LIBXFCE4PANEL_LOCALE_DIR, "UTF-8"); matecomponent_ui_util_set_ui (uic, PKGDATADIR "/ui", "XFCE_Panel_Popup.xml", "xfce4-xfapplet-plugin", &corba_ev); if (MATECOMPONENT_EX (&corba_ev)) { error = matecomponent_exception_get_text (&corba_ev); CORBA_exception_free (&corba_ev); g_warning ("Failed to load applet '%s' (can't set ui): %s\n", xap->iid, error); gtk_object_sink (GTK_OBJECT (bw)); xfapplet_applet_load_failed (xap); xfapplet_cleanup_current (xap); g_free (error); return; } xfce_textdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR, "UTF-8"); xfapplet_setup_menu_items (xap->plugin, uic); matecomponent_ui_component_thaw (uic, CORBA_OBJECT_NIL); gtk_widget_show (bw); if (xap->configured) xfapplet_unload_applet (xap); xap->object = control; xap->uic = uic; xap->prop_bag = prop_bag; MateCORBA_small_listen_for_broken (object, G_CALLBACK (xfapplet_connection_broken), xap); child = xfapplet_get_plugin_child (xap->plugin); if (child) gtk_widget_destroy (child); gtk_container_add (GTK_CONTAINER(xap->plugin), bw); xap->configured = TRUE; if (!xfapplet_save_configuration (xap)) g_warning ("Failed to save XfApplet configuration.\n"); }
static void cinnamon_control_center_init (CinnamonControlCenter *self) { GError *err = NULL; CinnamonControlCenterPrivate *priv; GdkScreen *screen; GtkWidget *widget; priv = self->priv = CONTROL_CENTER_PRIVATE (self); priv->monitor_num = -1; self->priv->small_screen = SMALL_SCREEN_UNSET; /* load the user interface */ priv->builder = gtk_builder_new (); if (!gtk_builder_add_from_file (priv->builder, UIDIR "/shell.ui", &err)) { g_critical ("Could not build interface: %s", err->message); g_error_free (err); return; } /* connect various signals */ priv->window = W (priv->builder, "main-window"); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE); screen = gtk_widget_get_screen (priv->window); g_signal_connect (screen, "monitors-changed", G_CALLBACK (monitors_changed_cb), self); g_signal_connect (priv->window, "configure-event", G_CALLBACK (main_window_configure_cb), self); g_signal_connect (priv->window, "notify::application", G_CALLBACK (application_set_cb), self); g_signal_connect_swapped (priv->window, "delete-event", G_CALLBACK (g_object_unref), self); g_signal_connect_after (priv->window, "key_press_event", G_CALLBACK (window_key_press_event), self); priv->notebook = W (priv->builder, "notebook"); /* Main scrolled window */ priv->scrolled_window = W (priv->builder, "scrolledwindow1"); if (!g_strcmp0(g_getenv("XDG_CURRENT_DESKTOP"), "Unity")) gtk_widget_set_size_request (priv->scrolled_window, UNITY_FIXED_WIDTH, -1); else gtk_widget_set_size_request (priv->scrolled_window, FIXED_WIDTH, -1); priv->main_vbox = W (priv->builder, "main-vbox"); g_signal_connect (priv->notebook, "notify::page", G_CALLBACK (notebook_page_notify_cb), priv); priv->nav_bar = cc_shell_nav_bar_new (); widget = W (priv->builder, "hbox1"); gtk_box_pack_start (GTK_BOX (widget), priv->nav_bar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (widget), priv->nav_bar, 0); gtk_widget_show (priv->nav_bar); g_signal_connect (priv->nav_bar, "home-clicked", G_CALLBACK (home_button_clicked_cb), self); /* keep a list of custom widgets to unload on panel change */ priv->custom_widgets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); /* load the available settings panels */ setup_model (self); /* load the panels that are implemented as plugins */ load_panel_plugins (self); /* setup search functionality */ setup_search (self); setup_lock (self); /* store default window title and name */ priv->default_window_title = g_strdup (gtk_window_get_title (GTK_WINDOW (priv->window))); priv->default_window_icon = g_strdup (gtk_window_get_icon_name (GTK_WINDOW (priv->window))); notebook_page_notify_cb (GTK_NOTEBOOK (priv->notebook), NULL, priv); }
static void bt_settings_dialog_init_ui (const BtSettingsDialog * self) { GtkWidget *box, *scrolled_window, *pages; GtkCellRenderer *renderer; GtkListStore *store; GtkTreeIter tree_iter; gtk_widget_set_name (GTK_WIDGET (self), "buzztrax settings"); //gtk_widget_set_size_request(GTK_WIDGET(self),800,600); gtk_window_set_title (GTK_WINDOW (self), _("buzztrax settings")); // add dialog commision widgets (okay, cancel) gtk_dialog_add_buttons (GTK_DIALOG (self), _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (self), GTK_RESPONSE_ACCEPT); // add widgets to the dialog content area box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (box), 6); // add a list on the right and a notebook without tabs on the left scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); self->priv->settings_list = GTK_TREE_VIEW (gtk_tree_view_new ()); gtk_tree_view_set_headers_visible (self->priv->settings_list, FALSE); renderer = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1, NULL, renderer, "icon-name", COL_ICON_NAME, NULL); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1); gtk_tree_view_insert_column_with_attributes (self->priv->settings_list, -1, NULL, renderer, "text", COL_LABEL, NULL); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (self-> priv->settings_list), GTK_SELECTION_BROWSE); gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (self->priv->settings_list)); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (scrolled_window), FALSE, FALSE, 0); g_signal_connect (self->priv->settings_list, "realize", G_CALLBACK (on_settings_list_realize), (gpointer) scrolled_window); g_signal_connect (self->priv->settings_list, "cursor-changed", G_CALLBACK (on_settings_list_cursor_changed), (gpointer) self); store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_LONG, G_TYPE_STRING); //-- append entries for settings pages gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Audio Devices"), COL_ID, BT_SETTINGS_PAGE_AUDIO_DEVICES, COL_ICON_NAME, "audio-card", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Directories"), COL_ID, BT_SETTINGS_PAGE_DIRECTORIES, COL_ICON_NAME, "folder", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Interaction Controller"), COL_ID, BT_SETTINGS_PAGE_INTERACTION_CONTROLLER, COL_ICON_NAME, "input-gaming", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Playback Controller"), COL_ID, BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER, COL_ICON_NAME, "media-playback-start", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("Shortcuts"), COL_ID, BT_SETTINGS_PAGE_SHORTCUTS, COL_ICON_NAME, "input-keyboard", -1); gtk_list_store_append (store, &tree_iter); gtk_list_store_set (store, &tree_iter, COL_LABEL, _("User interface"), COL_ID, BT_SETTINGS_PAGE_UI, COL_ICON_NAME, "preferences-desktop-theme", -1); gtk_tree_view_set_model (self->priv->settings_list, GTK_TREE_MODEL (store)); g_object_unref (store); // drop with treeview // add notebook pages = gtk_notebook_new (); self->priv->settings_pages = GTK_NOTEBOOK (pages); gtk_widget_set_name (pages, "settings pages"); gtk_notebook_set_show_tabs (self->priv->settings_pages, FALSE); gtk_notebook_set_show_border (self->priv->settings_pages, FALSE); gtk_container_add (GTK_CONTAINER (box), pages); // add audio device page self->priv->audiodevices_page = bt_settings_page_audiodevices_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->audiodevices_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_AUDIO_DEVICES), gtk_label_new (_("Audio Devices"))); // add directories page self->priv->directories_page = bt_settings_page_directories_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->directories_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_DIRECTORIES), gtk_label_new (_("Directories"))); // add interaction controller page self->priv->interaction_controller_page = bt_settings_page_interaction_controller_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->interaction_controller_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_INTERACTION_CONTROLLER), gtk_label_new (_("Interaction Controller"))); // add playback controller page self->priv->playback_controller_page = bt_settings_page_playback_controller_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->playback_controller_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_PLAYBACK_CONTROLLER), gtk_label_new (_("Playback Controller"))); // add shortcuts pags self->priv->shortcuts_page = bt_settings_page_shortcuts_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->shortcuts_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_SHORTCUTS), gtk_label_new (_("Shortcuts"))); // add ui page self->priv->ui_page = bt_settings_page_ui_new (pages); gtk_container_add (GTK_CONTAINER (self->priv->settings_pages), GTK_WIDGET (self->priv->ui_page)); gtk_notebook_set_tab_label (GTK_NOTEBOOK (self->priv->settings_pages), gtk_notebook_get_nth_page (GTK_NOTEBOOK (self->priv->settings_pages), BT_SETTINGS_PAGE_UI), gtk_label_new (_("User Interface"))); /* TODO(ensonic): more settings * - misc * - initial song bpm (from, to) * - cpu monitor (view menu?) */ gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), box, TRUE, TRUE, 0); }
int main (int argc, char *argv[]) { ClutterActor *stage, *actor; ClutterColor rcol = { 0xff, 0, 0, 0xff}, bcol = { 0, 0, 0xff, 0xff }, gcol = { 0, 0xff, 0, 0xff }, ccol = { 0, 0xff, 0xff, 0xff }, ycol = { 0xff, 0xff, 0, 0xff }; clutter_init (&argc, &argv); g_print ("Red box: aquire grab on press, releases it on next button release\n"); g_print ("Blue box: aquire grab on press, destroys the blue box actor on release\n"); g_print ("Yellow box: aquire grab on press, releases grab on next press on yellow box\n"); g_print ("Green box: toggle per actor motion events.\n\n"); g_print ("Cyan box: toggle grab (from cyan box) for keyboard events.\n\n"); stage = clutter_stage_get_default (); g_signal_connect (stage, "event", G_CALLBACK (debug_event_cb), "stage"); g_signal_connect (stage, "fullscreen", G_CALLBACK (stage_state_cb), "fullscreen"); g_signal_connect (stage, "unfullscreen", G_CALLBACK (stage_state_cb), "unfullscreen"); g_signal_connect (stage, "activate", G_CALLBACK (stage_state_cb), "activate"); g_signal_connect (stage, "deactivate", G_CALLBACK (stage_state_cb), "deactivate"); actor = clutter_rectangle_new_with_color (&rcol); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 100, 100); clutter_actor_set_reactive (actor, TRUE); clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL); g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "red box"); g_signal_connect (actor, "button-press-event", G_CALLBACK (grab_pointer_cb), NULL); g_signal_connect (actor, "button-release-event", G_CALLBACK (red_release_cb), NULL); actor = clutter_rectangle_new_with_color (&ycol); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 100, 300); clutter_actor_set_reactive (actor, TRUE); clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL); g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "yellow box"); g_signal_connect (actor, "button-press-event", G_CALLBACK (toggle_grab_pointer_cb), NULL); actor = clutter_rectangle_new_with_color (&bcol); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 300, 100); clutter_actor_set_reactive (actor, TRUE); clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL); g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "blue box"); g_signal_connect (actor, "button-press-event", G_CALLBACK (grab_pointer_cb), NULL); g_signal_connect (actor, "button-release-event", G_CALLBACK (blue_release_cb), NULL); actor = clutter_rectangle_new_with_color (&gcol); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 300, 300); clutter_actor_set_reactive (actor, TRUE); clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL); g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "green box"); g_signal_connect (actor, "button-press-event", G_CALLBACK (green_press_cb), NULL); actor = clutter_rectangle_new_with_color (&ccol); clutter_actor_set_size (actor, 100, 100); clutter_actor_set_position (actor, 500, 100); clutter_actor_set_reactive (actor, TRUE); clutter_container_add (CLUTTER_CONTAINER (stage), actor, NULL); g_signal_connect (actor, "event", G_CALLBACK (debug_event_cb), "cyan box"); g_signal_connect (actor, "button-press-event", G_CALLBACK (cyan_press_cb), NULL); clutter_actor_show_all (CLUTTER_ACTOR (stage)); clutter_main(); return 0; }
int main (int argc, char **argv) { gint ret; GMainLoop *loop; PolkitAgentListener *listener; GError *error; gtk_init (&argc, &argv); loop = NULL; authority = NULL; listener = NULL; session = NULL; ret = 1; bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); #if HAVE_BIND_TEXTDOMAIN_CODESET bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); #endif textdomain (GETTEXT_PACKAGE); loop = g_main_loop_new (NULL, FALSE); error = NULL; authority = polkit_authority_get_sync (NULL /* GCancellable* */, &error); if (authority == NULL) { g_warning ("Error getting authority: %s", error->message); g_error_free (error); goto out; } g_signal_connect (authority, "changed", G_CALLBACK (on_authority_changed), NULL); listener = polkit_mate_listener_new (); error = NULL; session = polkit_unix_session_new_for_process_sync (getpid (), NULL, &error); if (error != NULL) { g_warning ("Unable to determine the session we are in: %s", error->message); g_error_free (error); goto out; } error = NULL; if (!polkit_agent_listener_register (listener, POLKIT_AGENT_REGISTER_FLAGS_NONE, session, "/org/mate/PolicyKit1/AuthenticationAgent", NULL, &error)) { g_printerr ("Cannot register authentication agent: %s\n", error->message); g_error_free (error); goto out; } update_temporary_authorization_icon (authority); g_main_loop_run (loop); ret = 0; out: if (authority != NULL) g_object_unref (authority); if (session != NULL) g_object_unref (session); if (listener != NULL) g_object_unref (listener); if (loop != NULL) g_main_loop_unref (loop); return ret; }
static void update_temporary_authorization_icon_real (void) { #if 0 GList *l; g_debug ("have %d tmp authorizations", g_list_length (current_temporary_authorizations)); for (l = current_temporary_authorizations; l != NULL; l = l->next) { PolkitTemporaryAuthorization *authz = POLKIT_TEMPORARY_AUTHORIZATION (l->data); g_debug ("have tmp authz for action %s (subject %s) with id %s (obtained %d, expires %d)", polkit_temporary_authorization_get_action_id (authz), polkit_subject_to_string (polkit_temporary_authorization_get_subject (authz)), polkit_temporary_authorization_get_id (authz), (gint) polkit_temporary_authorization_get_time_obtained (authz), (gint) polkit_temporary_authorization_get_time_expires (authz)); } #endif /* TODO: * * - we could do something fancy like displaying a window with the tmp authz * when the icon is clicked... * * - we could do some work using polkit_subject_exists() to ignore tmp authz * for subjects that no longer exists.. this is because temporary authorizations * are only valid for the subject that trigger the authentication dialog. * * Maybe the authority could do this, would probably involve some polling, but * it seems cleaner to do this server side. */ if (current_temporary_authorizations != NULL) { /* show icon */ if (status_icon == NULL) { status_icon = gtk_status_icon_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION); gtk_status_icon_set_tooltip_text (status_icon, _("Click the icon to drop all elevated privileges")); g_signal_connect (status_icon, "activate", G_CALLBACK (on_status_icon_activate), NULL); g_signal_connect (status_icon, "popup-menu", G_CALLBACK (on_status_icon_popup_menu), NULL); } } else { /* hide icon */ if (status_icon != NULL) { gtk_status_icon_set_visible (status_icon, FALSE); g_object_unref (status_icon); status_icon = NULL; } } }
static gboolean cg_combo_flags_popup_idle (gpointer data) { CgComboFlags *combo; CgComboFlagsPrivate *priv; GtkTreeSelection* selection; GtkWidget *toplevel; GtkWidget *scrolled; GdkWindow *window; GdkDeviceManager* device_manager; gint height, width, x, y; combo = CG_COMBO_FLAGS (data); priv = CG_COMBO_FLAGS_PRIVATE (combo); g_assert (priv->window == NULL); priv->window = gtk_window_new (GTK_WINDOW_POPUP); g_object_ref (G_OBJECT (priv->window)); gtk_window_set_resizable (GTK_WINDOW (priv->window), FALSE); g_signal_connect (G_OBJECT (priv->window), "key_press_event", G_CALLBACK (cg_combo_flags_window_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->window), "button_press_event", G_CALLBACK (cg_combo_flags_window_button_press_cb), combo); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (priv->window), scrolled); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_widget_show (scrolled); priv->treeview = gtk_tree_view_new_with_model (priv->model); gtk_widget_show (priv->treeview); gtk_container_add (GTK_CONTAINER (scrolled), priv->treeview); g_signal_connect (G_OBJECT (priv->treeview), "key_press_event", G_CALLBACK (cg_combo_flags_treeview_key_press_cb), combo); g_signal_connect (G_OBJECT (priv->treeview), "button_press_event", G_CALLBACK (cg_combo_flags_treeview_button_press_cb), combo); priv->column = gtk_tree_view_column_new (); g_object_ref (G_OBJECT (priv->column)); cg_combo_flags_sync_cells (combo, GTK_CELL_LAYOUT (priv->column)); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), priv->column); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_hover_selection (GTK_TREE_VIEW (priv->treeview), TRUE); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (combo)); if (GTK_IS_WINDOW (toplevel)) { gtk_window_group_add_window (gtk_window_get_group ( GTK_WINDOW (toplevel)), GTK_WINDOW (priv->window)); gtk_window_set_transient_for (GTK_WINDOW (priv->window), GTK_WINDOW (toplevel)); } gtk_window_set_screen (GTK_WINDOW (priv->window), gtk_widget_get_screen (GTK_WIDGET (combo))); cg_combo_flags_get_position (combo, &x, &y, &width, &height); gtk_widget_set_size_request (priv->window, width, height); gtk_window_move (GTK_WINDOW(priv->window), x, y); gtk_widget_show (priv->window); gtk_widget_grab_focus (priv->window); if (!gtk_widget_has_focus (priv->treeview)) gtk_widget_grab_focus (priv->treeview); window = gtk_widget_get_window (priv->window); device_manager = gdk_display_get_device_manager (gdk_window_get_display (window)); priv->pointer_device = gdk_device_manager_get_client_pointer (device_manager); priv->keyboard_device = gdk_device_get_associated_device (priv->pointer_device); gtk_grab_add (priv->window); gdk_device_grab (priv->pointer_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, GDK_CURRENT_TIME); gdk_device_grab (priv->keyboard_device, window, GDK_OWNERSHIP_NONE, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, GDK_CURRENT_TIME); return FALSE; }
int main(int argc, char *argv[]) { gtk_init(&argc, &argv); if ( ! parse_commandline(argc, argv) ) return(EXIT_FAILURE); sterm::common::set_debugging(opt_debug); if ( opt_config_file != NULL ) config_file = opt_config_file; configuration = new sterm::config(config_file); gtk_window_set_default_icon_name("utilities-terminal"); main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "STerm"); gtk_container_set_border_width(GTK_CONTAINER(main_window), 0); terminal = new sterm::terminal(configuration); std::string child_command; if ( opt_command != NULL ) child_command = opt_command; terminal->attach_to_container(GTK_CONTAINER(main_window)); terminal->spawn_child(child_command); terminal->connect_callback("child-exited", G_CALLBACK(main_exit_with_status_cb), NULL); terminal->connect_callback("bell", G_CALLBACK(main_bell_cb), NULL); terminal->link_property_to_terminal("window-title", G_OBJECT(main_window), "title"); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_exit_cb), &main_window); functions = new sterm::function_handler(configuration, terminal); gtk_widget_show_all(main_window); gtk_main(); if ( terminal != NULL ) { delete(terminal); terminal = NULL; } if ( functions != NULL ) { delete(functions); functions = NULL; } if ( configuration != NULL ) { delete(configuration); configuration = NULL; } if ( main_window != NULL ) { gtk_widget_destroy(main_window); main_window = NULL; } return ret; }
static void calendar_sources_load_esource_list (CalendarSourceData *source_data) { GSList *clients = NULL; GSList *groups, *l; gboolean emit_signal = FALSE; g_return_if_fail (source_data->esource_list != NULL); debug_dump_selected_sources (source_data->selected_sources); dprintf ("Source groups:\n"); groups = e_source_list_peek_groups (source_data->esource_list); for (l = groups; l; l = l->next) { GSList *esources, *s; dprintf (" %s\n", e_source_group_peek_uid (l->data)); dprintf (" sources:\n"); esources = e_source_group_peek_sources (l->data); for (s = esources; s; s = s->next) { ESource *esource = E_SOURCE (s->data); ECal *client; dprintf (" type = '%s' uid = '%s', name = '%s', relative uri = '%s': \n", source_data->source_type == E_CAL_SOURCE_TYPE_EVENT ? "appointment" : "task", e_source_peek_uid (esource), e_source_peek_name (esource), e_source_peek_relative_uri (esource)); if (is_source_selected (esource, source_data->selected_sources) && (client = get_ecal_from_source (esource, source_data->source_type, source_data->clients))) { clients = g_slist_prepend (clients, client); } } } dprintf ("\n"); if (source_data->loaded && !compare_ecal_lists (source_data->clients, clients)) emit_signal = TRUE; for (l = source_data->clients; l; l = l->next) { g_signal_handlers_disconnect_by_func (G_OBJECT (l->data), G_CALLBACK (backend_died_cb), source_data); g_object_unref (l->data); } g_slist_free (source_data->clients); source_data->clients = g_slist_reverse (clients); /* connect to backend_died after we disconnected the previous signal * handlers. If we do it before, we'll lose some handlers (for clients that * were already there before) */ for (l = source_data->clients; l; l = l->next) { g_signal_connect (G_OBJECT (l->data), "backend_died", G_CALLBACK (backend_died_cb), source_data); } if (emit_signal) { dprintf ("Emitting %s-sources-changed signal\n", source_data->source_type == E_CAL_SOURCE_TYPE_EVENT ? "appointment" : "task"); g_signal_emit (source_data->sources, source_data->changed_signal, 0); } debug_dump_ecal_list (source_data->clients); }
void dt_styles_create_from_style (const char *name, const char *newname, const char *description, GList *filter) { sqlite3_stmt *stmt; int id=0; int oldid=0; oldid = dt_styles_get_id_by_name(name); if(oldid == 0) return; /* create the style header */ if (!dt_styles_create_style_header(newname, description)) return; if ((id=dt_styles_get_id_by_name(newname)) != 0) { if (filter) { GList *list=filter; char tmp[64]; char include[2048]= {0}; g_strlcat(include,"num in (", 2048); do { if(list!=g_list_first(list)) g_strlcat(include,",", 2048); sprintf(tmp,"%ld",(long int)list->data); g_strlcat(include,tmp, 2048); } while ((list=g_list_next(list))); g_strlcat(include,")", 2048); char query[4096]= {0}; sprintf(query,"insert into style_items (styleid,num,module,operation,op_params,enabled,blendop_params,blendop_version) select ?1, num,module,operation,op_params,enabled,blendop_params,blendop_version from style_items where styleid=?2 and %s",include); DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL); } else DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "insert into style_items (styleid,num,module,operation,op_params,enabled,blendop_params,blendop_version) select ?1, num,module,operation,op_params,enabled,blendop_params,blendop_version from style_items where style_id=?2", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id); DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, oldid); sqlite3_step (stmt); sqlite3_finalize (stmt); /* backup style to disk */ char stylesdir[1024]; dt_loc_get_user_config_dir(stylesdir, 1024); g_strlcat(stylesdir,"/styles",1024); g_mkdir_with_parents(stylesdir,00755); dt_styles_save_to_file(newname,stylesdir,FALSE); char tmp_accel[1024]; gchar* tmp_name = g_strdup(newname); // freed by _destro_style_shortcut_callback snprintf(tmp_accel,1024,"styles/Apply %s",newname); dt_accel_register_global( tmp_accel, 0, 0); GClosure *closure; closure = g_cclosure_new( G_CALLBACK(_apply_style_shortcut_callback), tmp_name, _destroy_style_shortcut_callback); dt_accel_connect_global(tmp_accel, closure); dt_control_log(_("style named '%s' successfully created"),newname); } }
void dt_styles_update (const char *name, const char *newname, const char *newdescription, GList *filter) { sqlite3_stmt *stmt; int id=0; gchar *desc = NULL; id = dt_styles_get_id_by_name(name); if(id == 0) return; desc = dt_styles_get_description (name); if ((g_strcmp0(name, newname)) || (g_strcmp0(desc, newdescription))) { DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "update styles set name=?1, description=?2 where rowid=?3", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, newname, strlen (newname), SQLITE_STATIC); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, newdescription, strlen (newdescription), SQLITE_STATIC); DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, id); sqlite3_step(stmt); sqlite3_finalize(stmt); } if (filter) { GList *list=filter; char tmp[64]; char include[2048] = {0}; g_strlcat(include,"num not in (", 2048); do { if(list!=g_list_first(list)) g_strlcat(include, ",", 2048); sprintf(tmp, "%ld", (long int)list->data); g_strlcat(include, tmp, 2048); } while ((list=g_list_next(list))); g_strlcat(include,")", 2048); char query[4096]= {0}; sprintf(query,"delete from style_items where styleid=?1 and %s", include); DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), query, -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_INT(stmt, 1, id); sqlite3_step(stmt); sqlite3_finalize(stmt); } /* backup style to disk */ char stylesdir[1024]; dt_loc_get_user_config_dir(stylesdir, 1024); g_strlcat(stylesdir,"/styles",1024); g_mkdir_with_parents(stylesdir,00755); dt_styles_save_to_file(newname,stylesdir,TRUE); /* delete old accelerator and create a new one */ //TODO: sould better use dt_accel_rename_global() to keep the old accel_key untouched, but it seems to be buggy if (g_strcmp0(name, newname)) { char tmp_accel[1024]; snprintf(tmp_accel, 1024, "styles/Apply %s", name); dt_accel_deregister_global(tmp_accel); gchar* tmp_name = g_strdup(newname); // freed by _destro_style_shortcut_callback snprintf(tmp_accel, 1024, "styles/Apply %s", newname); dt_accel_register_global( tmp_accel, 0, 0); GClosure *closure; closure = g_cclosure_new( G_CALLBACK(_apply_style_shortcut_callback), tmp_name, _destroy_style_shortcut_callback); dt_accel_connect_global(tmp_accel, closure); } g_free(desc); }
void settings_window_create (void) { if(win_set_main != NULL) { gtk_widget_hide(win_set_main); gtk_widget_show(win_set_main); return; } GtkWidget *vbox_set_m, *hbox_set_m, *but_set_close, *but_set_save, *but_set_reset; GtkWidget *nb_set_m, *lab_e, *vbox_nb_up, *vbox_nb_um, *vbox_nb_uq; GtkWidget *hbox_um_s, *grid_uq, *grid_up, *grid_um; win_set_main = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win_set_main), "Pomf it! - Settings"); g_signal_connect(win_set_main, "destroy", G_CALLBACK(settings_window_destroy), NULL); gtk_container_set_border_width(GTK_CONTAINER(win_set_main), 10); gtk_window_resize(GTK_WINDOW(win_set_main), 320, 200); gtk_window_set_position(GTK_WINDOW(win_set_main), GTK_WIN_POS_CENTER); vbox_set_m = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0); gtk_container_add(GTK_CONTAINER(win_set_main), vbox_set_m); nb_set_m = gtk_notebook_new(); gtk_container_add(GTK_CONTAINER(vbox_set_m),nb_set_m); vbox_nb_up = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0); gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_up); lab_e = gtk_label_new("Uploader"); g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL); gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m), gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 0),lab_e); vbox_nb_um = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0); gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_um); lab_e = gtk_label_new("Manager"); g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL); gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m), gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 1),lab_e); vbox_nb_uq = gtk_box_new(GTK_ORIENTATION_VERTICAL , 0); gtk_container_add(GTK_CONTAINER(nb_set_m), vbox_nb_uq); lab_e = gtk_label_new("Queue"); g_object_set(G_OBJECT(lab_e), "can-focus", FALSE, NULL); gtk_notebook_set_tab_label(GTK_NOTEBOOK(nb_set_m), gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb_set_m), 2),lab_e); grid_up = gtk_grid_new (); gtk_box_pack_start(GTK_BOX(vbox_nb_up), grid_up , FALSE, FALSE, 0); lab_e = gtk_label_new("Profiles: "); gtk_grid_attach (GTK_GRID (grid_up),lab_e, 0, 0, 2, 1); com_upm_pl = gtk_combo_box_text_new(); gtk_grid_attach (GTK_GRID (grid_up),com_upm_pl, 2, 0, 2, 1); profiles_combo_fill(); hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_grid_attach (GTK_GRID (grid_up),hbox_um_s, 4, 0, 4, 1); GtkWidget *but_up_act = gtk_button_new_with_label("Activate"); g_signal_connect(but_up_act,"clicked",G_CALLBACK(profiles_profile_activate), NULL); gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_act),TRUE,TRUE,0); GtkWidget *but_up_edit = gtk_button_new_with_label("Edit"); g_signal_connect(but_up_edit,"clicked",G_CALLBACK(profiles_profile_edit), NULL); gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_edit),TRUE,TRUE,0); hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_grid_attach (GTK_GRID (grid_up),hbox_um_s, 8, 0, 4, 1); GtkWidget *but_up_add = gtk_button_new_with_label("Add New"); g_signal_connect(but_up_add,"clicked",G_CALLBACK(profiles_window_create), NULL); gtk_box_pack_end(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_add),TRUE,FALSE,0); GtkWidget *but_up_del = gtk_button_new_with_label("Delete"); g_signal_connect(but_up_del,"clicked",G_CALLBACK(profiles_profile_delete), NULL); gtk_box_pack_start(GTK_BOX(hbox_um_s),GTK_WIDGET(but_up_del),TRUE,FALSE,0); lab_e = gtk_label_new("Active Profile:"); gtk_grid_attach (GTK_GRID (grid_up),lab_e, 0, 1, 2, 1); lab_profile = gtk_label_new("none"); gtk_grid_attach (GTK_GRID (grid_up),lab_profile, 2, 1, 2, 1); lab_e = gtk_label_new("Keep SS:"); gtk_grid_attach (GTK_GRID (grid_up),lab_e, 4, 1, 2, 1); sw_up_kss = gtk_switch_new(); gtk_grid_attach (GTK_GRID (grid_up),sw_up_kss, 6, 1, 2, 1); grid_um = gtk_grid_new (); gtk_box_pack_start(GTK_BOX(vbox_nb_um), grid_um , FALSE, FALSE, 0); lab_e = gtk_label_new("Picture Preview:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 0, 2, 1); sw_um_pp = gtk_switch_new(); gtk_grid_attach (GTK_GRID (grid_um),sw_um_pp, 2, 0, 2, 1); lab_e = gtk_label_new("Window Size:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 0, 2, 1); hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_grid_attach (GTK_GRID (grid_um),hbox_um_s, 6, 0, 4, 1); entry_um_win_w = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_win_w); gtk_entry_set_width_chars(GTK_ENTRY(entry_um_win_w),5); lab_e = gtk_label_new("X"); gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e); entry_um_win_h = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_win_h); gtk_entry_set_width_chars(GTK_ENTRY(entry_um_win_h),5); lab_e = gtk_label_new("Animate Preview:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 1, 2, 1); sw_um_ap = gtk_switch_new(); gtk_grid_attach (GTK_GRID (grid_um),sw_um_ap, 2, 1, 2, 1); lab_e = gtk_label_new("Preview Size:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 1, 2, 1); hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_grid_attach (GTK_GRID (grid_um),hbox_um_s, 6, 1, 4, 1); entry_um_pw_w = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_pw_w); gtk_entry_set_width_chars(GTK_ENTRY(entry_um_pw_w),5); lab_e = gtk_label_new("X"); gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e); entry_um_pw_h = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_um_pw_h); gtk_entry_set_width_chars(GTK_ENTRY(entry_um_pw_h),5); lab_e = gtk_label_new("Window Position:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 2, 2, 1); com_um_wp = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Default"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Center"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_wp), NULL, "Mouse"); gtk_grid_attach (GTK_GRID (grid_um),com_um_wp, 6, 2, 2, 1); lab_e = gtk_label_new("Enable Double Click:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 0, 3, 2, 1); sw_um_dc = gtk_switch_new(); gtk_grid_attach (GTK_GRID (grid_um),sw_um_dc, 2, 3, 2, 1); lab_e = gtk_label_new("Action:"); gtk_grid_attach (GTK_GRID (grid_um),lab_e, 4, 3, 2, 1); com_um_dca = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open File"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open Link"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Open Folder"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_um_dca), NULL, "Copy URL"); gtk_grid_attach (GTK_GRID (grid_um),com_um_dca, 6, 3, 2, 1); grid_uq = gtk_grid_new (); gtk_box_pack_start(GTK_BOX(vbox_nb_uq), grid_uq , FALSE, FALSE, 0); lab_e = gtk_label_new("Window Position:"); gtk_grid_attach (GTK_GRID (grid_uq),lab_e, 0, 0, 2, 1); com_uq_wp = gtk_combo_box_text_new(); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Default"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Center"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(com_uq_wp), NULL, "Mouse"); gtk_grid_attach (GTK_GRID (grid_uq),com_uq_wp, 2, 0, 2, 1); lab_e = gtk_label_new("Window Size:"); gtk_grid_attach (GTK_GRID (grid_uq),lab_e, 4, 0, 2, 1); hbox_um_s = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_grid_attach (GTK_GRID (grid_uq),hbox_um_s, 6, 0, 4, 1); entry_uq_win_w = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_uq_win_w); gtk_entry_set_width_chars(GTK_ENTRY(entry_uq_win_w),5); lab_e = gtk_label_new("X"); gtk_container_add(GTK_CONTAINER(hbox_um_s), lab_e); entry_uq_win_h = gtk_entry_new(); gtk_container_add(GTK_CONTAINER(hbox_um_s), entry_uq_win_h); gtk_entry_set_width_chars(GTK_ENTRY(entry_uq_win_h),5); hbox_set_m = gtk_box_new(GTK_ORIENTATION_HORIZONTAL , 0); gtk_box_pack_end(GTK_BOX(vbox_set_m), hbox_set_m, FALSE, FALSE, 0); but_set_reset = gtk_button_new_with_label("Reset Settings"); g_signal_connect(but_set_reset,"clicked",G_CALLBACK(settings_conf_default), NULL); gtk_container_add(GTK_CONTAINER(hbox_set_m), but_set_reset); but_set_close = gtk_button_new_with_label(" Close "); g_signal_connect(but_set_close,"clicked",G_CALLBACK(settings_window_destroy), NULL); gtk_box_pack_end(GTK_BOX(hbox_set_m),GTK_WIDGET(but_set_close),FALSE,FALSE,0); but_set_save = gtk_button_new_with_label("Save & Close"); g_signal_connect(but_set_save,"clicked",G_CALLBACK(settings_conf_save), NULL); gtk_box_pack_end(GTK_BOX(hbox_set_m),GTK_WIDGET(but_set_save),FALSE,FALSE,0); settings_window_create_set_actives(); gtk_widget_show_all(win_set_main); }
void gimp_batch_run (Gimp *gimp, const gchar *batch_interpreter, const gchar **batch_commands) { gulong exit_id; if (! batch_commands || ! batch_commands[0]) return; exit_id = g_signal_connect_after (gimp, "exit", G_CALLBACK (gimp_batch_exit_after_callback), NULL); if (! batch_interpreter) { batch_interpreter = g_getenv ("GIMP_BATCH_INTERPRETER"); if (! batch_interpreter) { batch_interpreter = BATCH_DEFAULT_EVAL_PROC; if (gimp->be_verbose) g_printerr (_("No batch interpreter specified, using the default " "'%s'.\n"), batch_interpreter); } } /* script-fu text console, hardcoded for backward compatibility */ if (strcmp (batch_interpreter, "plug-in-script-fu-eval") == 0 && strcmp (batch_commands[0], "-") == 0) { const gchar *proc_name = "plug-in-script-fu-text-console"; GimpProcedure *procedure = gimp_pdb_lookup_procedure (gimp->pdb, proc_name); if (procedure) gimp_batch_run_cmd (gimp, proc_name, procedure, GIMP_RUN_NONINTERACTIVE, NULL); else g_message (_("The batch interpreter '%s' is not available. " "Batch mode disabled."), proc_name); } else { GimpProcedure *eval_proc = gimp_pdb_lookup_procedure (gimp->pdb, batch_interpreter); if (eval_proc) { gint i; for (i = 0; batch_commands[i]; i++) gimp_batch_run_cmd (gimp, batch_interpreter, eval_proc, GIMP_RUN_NONINTERACTIVE, batch_commands[i]); } else { g_message (_("The batch interpreter '%s' is not available. " "Batch mode disabled."), batch_interpreter); } } g_signal_handler_disconnect (gimp, exit_id); }
void gnibbles_preferences_cb (GtkWidget * widget, gpointer data) { GtkWidget *notebook; GtkWidget *label; GtkWidget *frame; GtkWidget *button; GtkWidget *levelspinner; GtkWidget *vbox, *vbox2; GtkObject *adjustment; GtkWidget *label2; GtkWidget *table, *table2; GtkWidget *omenu; GtkWidget *controls; gchar *buffer; gint i; gint running = 0; if (pref_dialog) { gtk_window_present (GTK_WINDOW (pref_dialog)); return; } if (!paused) { unpause = 1; pause_game_cb (NULL, 0); } if (game_running ()) running = 1; pref_dialog = gtk_dialog_new_with_buttons (_("Nibbles Preferences"), GTK_WINDOW (window), 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_has_separator (GTK_DIALOG (pref_dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (pref_dialog), 5); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (pref_dialog)->vbox), 2); notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (notebook), 5); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pref_dialog)->vbox), notebook); label = gtk_label_new (_("Game")); table = gtk_table_new (1, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 18); gtk_container_set_border_width (GTK_CONTAINER (table), 12); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label); frame = games_frame_new (_("Speed")); if (running) gtk_widget_set_sensitive (frame, FALSE); gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, 0, GTK_FILL | GTK_EXPAND, 0, 0); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); button = gtk_radio_button_new_with_label (NULL, _("Nibbles newbie")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (properties->gamespeed == 4) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (game_speed_cb), (gpointer) 4); button = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), _("My second day")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (properties->gamespeed == 3) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (game_speed_cb), (gpointer) 3); button = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), _("Not too shabby")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (properties->gamespeed == 2) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (game_speed_cb), (gpointer) 2); button = gtk_radio_button_new_with_label (gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)), _("Finger-twitching good")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (properties->gamespeed == 1) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (game_speed_cb), (gpointer) 1); /* Options */ frame = games_frame_new (_("Options")); gtk_table_attach_defaults (GTK_TABLE (table), frame, 1, 2, 0, 1); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); button = gtk_check_button_new_with_mnemonic (_("_Play levels in random order")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (running || ggz_network_mode) gtk_widget_set_sensitive (button, FALSE); if (properties->random) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (random_order_cb), NULL); button = gtk_check_button_new_with_mnemonic (_("_Enable fake bonuses")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (running) gtk_widget_set_sensitive (button, FALSE); if (properties->fakes) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (fake_bonus_cb), NULL); button = gtk_check_button_new_with_mnemonic (_("E_nable sounds")); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (properties->sound) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK (sound_cb), NULL); table2 = gtk_table_new (3, 2, FALSE); gtk_box_pack_start (GTK_BOX (vbox), table2, FALSE, FALSE, 0); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); gtk_container_set_border_width (GTK_CONTAINER (table2), 0); label2 = gtk_label_new_with_mnemonic (_("_Starting level:")); start_level_label = label2; gtk_widget_set_name (label2, "StartLevelLabel"); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); if (properties->random) gtk_widget_set_sensitive (GTK_WIDGET (label2), FALSE); if (running) gtk_widget_set_sensitive (GTK_WIDGET (label2), FALSE); gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); adjustment = gtk_adjustment_new ((gfloat) properties->startlevel, 1.0, MAXLEVEL, 1.0, 5.0, 0.0); levelspinner = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0); start_level_spin_button = levelspinner; gtk_widget_set_name (levelspinner, "StartLevelSpinButton"); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (levelspinner), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), levelspinner); if (properties->random) gtk_widget_set_sensitive (GTK_WIDGET (levelspinner), FALSE); if (running) gtk_widget_set_sensitive (GTK_WIDGET (levelspinner), FALSE); gtk_table_attach_defaults (GTK_TABLE (table2), levelspinner, 1, 2, 0, 1); g_signal_connect (GTK_OBJECT (adjustment), "value_changed", G_CALLBACK (start_level_cb), levelspinner); label2 = gtk_label_new_with_mnemonic (_("Number of _human players:")); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); if (running || ggz_network_mode) gtk_widget_set_sensitive (label2, FALSE); adjustment = gtk_adjustment_new ((gfloat) properties->human, 0.0, NUMWORMS, 1.0, 1.0, 0.0); num_human = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (num_human), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), num_human); gtk_table_attach_defaults (GTK_TABLE (table2), num_human, 1, 2, 1, 2); if (running || ggz_network_mode) gtk_widget_set_sensitive (num_human, FALSE); g_signal_connect (GTK_OBJECT (adjustment), "value_changed", G_CALLBACK (num_worms_cb), num_human); label2 = gtk_label_new_with_mnemonic (_("Number of _AI players:")); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 2, 3, GTK_FILL, 0, 0, 0); if (running || ggz_network_mode) gtk_widget_set_sensitive (label2, FALSE); adjustment = gtk_adjustment_new ((gfloat) properties->ai, 0.0, NUMWORMS, 1.0, 1.0, 0.0); num_ai = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0); gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (num_ai), FALSE); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), num_ai); gtk_table_attach_defaults (GTK_TABLE (table2), num_ai, 1, 2, 2, 3); if (running || ggz_network_mode) gtk_widget_set_sensitive (num_ai, FALSE); g_signal_connect (GTK_OBJECT (adjustment), "value_changed", G_CALLBACK (num_worms_cb), num_ai); for (i = 0; i < NUMWORMS; i++) { char up_key[64]; char down_key[64]; char left_key[64]; char right_key[64]; buffer = g_strdup_printf ("%s %d", _("Worm"), i + 1); label = gtk_label_new (buffer); g_free (buffer); vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label); frame = games_frame_new (_("Keyboard Controls")); controls = games_controls_list_new (KEY_PREFERENCES_GROUP); g_snprintf (left_key, sizeof (left_key), KEY_WORM_LEFT, i); g_snprintf (right_key, sizeof (right_key), KEY_WORM_RIGHT, i); g_snprintf (up_key, sizeof (up_key), KEY_WORM_UP, i); g_snprintf (down_key, sizeof (down_key), KEY_WORM_DOWN, i); games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls), left_key, _("Move left"), GDK_Left, right_key, _("Move right"), GDK_Right, up_key, _("Move up"), GDK_Up, down_key, _("Move down"), GDK_Down, NULL); gtk_container_add (GTK_CONTAINER (frame), controls); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); frame = games_frame_new (_("Options")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); vbox2 = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox2); button = gtk_check_button_new_with_mnemonic (_("_Use relative movement")); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); table2 = gtk_table_new (1, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); gtk_box_pack_start (GTK_BOX (vbox2), table2, FALSE, FALSE, 0); label2 = gtk_label_new_with_mnemonic (_("_Worm color:")); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 0, 1, 0, 0, 0, 0); omenu = gtk_combo_box_new_text (); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), omenu); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Red")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Green")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Blue")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Yellow")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Cyan")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Purple")); gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Gray")); g_signal_connect (GTK_OBJECT (omenu), "changed", G_CALLBACK (set_worm_color_cb), GINT_TO_POINTER (i)); gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), properties->wormprops[i]->color - WORMRED); gtk_table_attach_defaults (GTK_TABLE (table2), omenu, 1, 2, 0, 1); set_worm_controls_sensitivity (i, properties->wormprops[i]->relmove); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), properties->wormprops[i]->relmove); g_signal_connect (G_OBJECT (button), "toggled", G_CALLBACK (worm_relative_movement_cb), GINT_TO_POINTER (i)); } g_signal_connect (G_OBJECT (pref_dialog), "response", G_CALLBACK (apply_cb), NULL); g_signal_connect (G_OBJECT (pref_dialog), "destroy", G_CALLBACK (destroy_cb), NULL); g_signal_connect (G_OBJECT (pref_dialog), "close", G_CALLBACK (destroy_cb), NULL); gtk_widget_show_all (pref_dialog); }
G_MODULE_EXPORT gint test_text_main (gint argc, gchar **argv) { ClutterActor *stage; ClutterActor *text, *text2; ClutterColor text_color = { 0x33, 0xff, 0x33, 0xff }; ClutterColor cursor_color = { 0xff, 0x33, 0x33, 0xff }; ClutterTextBuffer *buffer; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "Text Editing"); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); buffer = clutter_text_buffer_new_with_text ("·", -1); text = clutter_text_new_with_buffer (buffer); clutter_text_set_font_name (CLUTTER_TEXT (text), FONT); clutter_text_set_color (CLUTTER_TEXT (text), &text_color); clutter_container_add (CLUTTER_CONTAINER (stage), text, NULL); clutter_actor_set_position (text, 40, 30); clutter_actor_set_width (text, 1024); clutter_text_set_line_wrap (CLUTTER_TEXT (text), TRUE); clutter_actor_set_reactive (text, TRUE); clutter_stage_set_key_focus (CLUTTER_STAGE (stage), text); clutter_text_set_editable (CLUTTER_TEXT (text), TRUE); clutter_text_set_selectable (CLUTTER_TEXT (text), TRUE); clutter_text_set_cursor_color (CLUTTER_TEXT (text), &cursor_color); clutter_text_set_selected_text_color (CLUTTER_TEXT (text), CLUTTER_COLOR_Blue); text2 = clutter_text_new_with_buffer (buffer); clutter_text_set_color (CLUTTER_TEXT (text2), &text_color); clutter_container_add (CLUTTER_CONTAINER (stage), text2, NULL); clutter_actor_set_position (text2, 40, 300); clutter_actor_set_width (text2, 1024); clutter_text_set_line_wrap (CLUTTER_TEXT (text2), TRUE); clutter_actor_set_reactive (text2, TRUE); clutter_text_set_editable (CLUTTER_TEXT (text2), TRUE); clutter_text_set_selectable (CLUTTER_TEXT (text2), TRUE); clutter_text_set_cursor_color (CLUTTER_TEXT (text2), &cursor_color); clutter_text_set_selected_text_color (CLUTTER_TEXT (text2), CLUTTER_COLOR_Green); if (argv[1]) { GError *error = NULL; gchar *utf8; g_file_get_contents (argv[1], &utf8, NULL, &error); if (error) { utf8 = g_strconcat ("Unable to open '", argv[1], "':\n", error->message, NULL); g_error_free (error); } clutter_text_set_text (CLUTTER_TEXT (text), utf8); } else clutter_text_set_text (CLUTTER_TEXT (text), runes); clutter_actor_set_size (stage, 1024, 768); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
static GtkCellEditable * egg_cell_renderer_keys_start_editing (GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget, const gchar *path, const GdkRectangle *background_area, const GdkRectangle *cell_area, GtkCellRendererState flags) { GtkCellRendererText *celltext; EggCellRendererKeys *keys; GdkDisplay *display; GdkSeat *seat; GtkWidget *label; GtkWidget *eventbox; GValue celltext_editable = {0}; celltext = GTK_CELL_RENDERER_TEXT (cell); keys = EGG_CELL_RENDERER_KEYS (cell); /* If the cell isn't editable we return NULL. */ g_value_init (&celltext_editable, G_TYPE_BOOLEAN); g_object_get_property (G_OBJECT (celltext), "editable", &celltext_editable); if (g_value_get_boolean (&celltext_editable) == FALSE) return NULL; g_return_val_if_fail (gtk_widget_get_window (widget) != NULL, NULL); display = gtk_widget_get_display (widget); seat = gdk_display_get_default_seat (display); if (gdk_seat_grab (seat, gtk_widget_get_window (widget), GDK_SEAT_CAPABILITY_ALL, FALSE, NULL, event, NULL, NULL) != GDK_GRAB_SUCCESS) return NULL; keys->grab_widget = widget; g_signal_connect (G_OBJECT (widget), "key_press_event", G_CALLBACK (grab_key_callback), keys); eventbox = g_object_new (pointless_eventbox_subclass_get_type (), NULL); keys->edit_widget = eventbox; g_object_add_weak_pointer (G_OBJECT (keys->edit_widget), (void**) &keys->edit_widget); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_widget_modify_bg (eventbox, GTK_STATE_NORMAL, >k_widget_get_style (widget)->bg[GTK_STATE_SELECTED]); gtk_widget_modify_fg (label, GTK_STATE_NORMAL, >k_widget_get_style (widget)->fg[GTK_STATE_SELECTED]); gtk_label_set_text (GTK_LABEL (label), TOOLTIP_TEXT); gtk_container_add (GTK_CONTAINER (eventbox), label); g_object_set_data_full (G_OBJECT (keys->edit_widget), EGG_CELL_RENDERER_TEXT_PATH, g_strdup (path), g_free); gtk_widget_show_all (keys->edit_widget); g_signal_connect (G_OBJECT (keys->edit_widget), "unrealize", G_CALLBACK (ungrab_stuff), keys); keys->edit_key = keys->accel_key; return GTK_CELL_EDITABLE (keys->edit_widget); }
void gui_init(dt_imageio_module_storage_t *self) { self->gui_data = (dt_storage_piwigo_gui_data_t *)g_malloc0(sizeof(dt_storage_piwigo_gui_data_t)); dt_storage_piwigo_gui_data_t *ui = self->gui_data; ui->albums = NULL; ui->accounts = NULL; ui->api = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(8)); _piwigo_load_account(ui); gchar *server = dt_conf_get_string("plugins/imageio/storage/export/piwigo/server"); // look for last server information _piwigo_account_t *last_account = _piwigo_get_account(ui, server); GtkWidget *hbox, *label, *button; // account ui->account_list = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(ui->account_list, NULL, _("accounts")); GList *a = ui->accounts; int account_index = -1, index=0; while(a) { _piwigo_account_t *account = (_piwigo_account_t *)a->data; dt_bauhaus_combobox_add(ui->account_list, account->server); if(!strcmp(account->server, server)) account_index = index; index++; a = g_list_next(a); } gtk_widget_set_hexpand(ui->account_list, TRUE); g_signal_connect(G_OBJECT(ui->account_list), "value-changed", G_CALLBACK(_piwigo_account_changed), (gpointer)ui); gtk_box_pack_start(GTK_BOX(self->widget), ui->account_list, FALSE, FALSE, 0); // server hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8)); label = gtk_label_new(_("server")); g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0); ui->server_entry = GTK_ENTRY(gtk_entry_new()); gtk_widget_set_tooltip_text(GTK_WIDGET(ui->server_entry), _("the server name\ndefault protocol is https\nspecify http:// if non secure server")); gtk_widget_set_hexpand(GTK_WIDGET(ui->server_entry), TRUE); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->server_entry)); gtk_entry_set_text(ui->server_entry, last_account?last_account->server:"piwigo.com"); g_signal_connect(G_OBJECT(ui->server_entry), "changed", G_CALLBACK(_piwigo_server_entry_changed), (gpointer)ui); gtk_entry_set_width_chars(GTK_ENTRY(ui->server_entry), 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->server_entry), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0); g_free(server); // login hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8)); label = gtk_label_new(_("user")); g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0); ui->user_entry = GTK_ENTRY(gtk_entry_new()); gtk_widget_set_hexpand(GTK_WIDGET(ui->user_entry), TRUE); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->user_entry)); gtk_entry_set_text(ui->user_entry, last_account?last_account->username:""); g_signal_connect(G_OBJECT(ui->user_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui); gtk_entry_set_width_chars(GTK_ENTRY(ui->user_entry), 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->user_entry), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0); // password hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(8)); label = gtk_label_new(_("password")); g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0); ui->pwd_entry = GTK_ENTRY(gtk_entry_new()); gtk_entry_set_visibility(GTK_ENTRY(ui->pwd_entry), FALSE); gtk_widget_set_hexpand(GTK_WIDGET(ui->pwd_entry), TRUE); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->pwd_entry)); gtk_entry_set_text(ui->pwd_entry, last_account?last_account->password:""); g_signal_connect(G_OBJECT(ui->pwd_entry), "changed", G_CALLBACK(_piwigo_entry_changed), (gpointer)ui); gtk_entry_set_width_chars(GTK_ENTRY(ui->pwd_entry), 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(label), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->pwd_entry), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(hbox), TRUE, TRUE, 0); // login button button = gtk_button_new_with_label(_("login")); gtk_widget_set_tooltip_text(button, _("piwigo login")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_login_clicked), (gpointer)ui); gtk_box_pack_start(GTK_BOX(self->widget), button, FALSE, FALSE, 0); // status area ui->status_label = GTK_LABEL(gtk_label_new(NULL)); gtk_widget_set_halign(GTK_WIDGET(ui->status_label), GTK_ALIGN_START); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->status_label), FALSE, FALSE, 0); ui->export_tags = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(ui->export_tags, NULL, _("export tags")); dt_bauhaus_combobox_add(ui->export_tags, _("yes")); dt_bauhaus_combobox_add(ui->export_tags, _("no")); dt_bauhaus_combobox_set(ui->export_tags, 0); gtk_widget_set_hexpand(ui->export_tags, TRUE); gtk_box_pack_start(GTK_BOX(self->widget), ui->export_tags, FALSE, FALSE, 0); // select account if(account_index != -1) dt_bauhaus_combobox_set(ui->account_list, account_index); // permissions list ui->permission_list = dt_bauhaus_combobox_new(NULL); dt_bauhaus_widget_set_label(ui->permission_list, NULL, _("visible to")); dt_bauhaus_combobox_add(ui->permission_list, _("everyone")); dt_bauhaus_combobox_add(ui->permission_list, _("contacts")); dt_bauhaus_combobox_add(ui->permission_list, _("friends")); dt_bauhaus_combobox_add(ui->permission_list, _("family")); dt_bauhaus_combobox_add(ui->permission_list, _("you")); dt_bauhaus_combobox_set(ui->permission_list, 0); // Set default permission to private gtk_box_pack_start(GTK_BOX(self->widget), ui->permission_list, FALSE, FALSE, 0); // album list hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(5)); ui->album_list = dt_bauhaus_combobox_new(NULL); // Available albums dt_bauhaus_widget_set_label(ui->album_list, NULL, _("albums")); g_signal_connect(G_OBJECT(ui->album_list), "value-changed", G_CALLBACK(_piwigo_album_changed), (gpointer)ui); gtk_widget_set_sensitive(ui->album_list, FALSE); gtk_box_pack_start(GTK_BOX(hbox), ui->album_list, TRUE, TRUE, 0); button = dtgtk_button_new(dtgtk_cairo_paint_refresh, CPF_DO_NOT_USE_BORDER, NULL); gtk_widget_set_tooltip_text(button, _("refresh album list")); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(_piwigo_refresh_clicked), (gpointer)ui); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox, FALSE, FALSE, 0); // new album ui->create_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5))); gtk_widget_set_no_show_all(GTK_WIDGET(ui->create_box), TRUE); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(ui->create_box), FALSE, FALSE, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10)); label = gtk_label_new(_("title")); g_object_set(G_OBJECT(label), "xalign", 0.0, (gchar *)0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); ui->new_album_entry = GTK_ENTRY(gtk_entry_new()); // Album title dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(ui->new_album_entry)); gtk_entry_set_text(ui->new_album_entry, _("new album")); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(ui->new_album_entry), TRUE, TRUE, 0); gtk_entry_set_width_chars(GTK_ENTRY(ui->new_album_entry), 0); gtk_box_pack_start(ui->create_box, hbox, FALSE, FALSE, 0); // parent album list ui->parent_album_list = dt_bauhaus_combobox_new(NULL); // Available albums dt_bauhaus_widget_set_label(ui->parent_album_list, NULL, _("parent album")); gtk_widget_set_sensitive(ui->parent_album_list, TRUE); gtk_box_pack_start(ui->create_box, ui->parent_album_list, TRUE, TRUE, 0); _piwigo_set_status(ui, _("click login button to start"), "#ffffff"); }
static void connect_presence_watcher (GSWatcher *watcher) { DBusGConnection *bus; GError *error; DBusGProxy *proxy; guint status; GValue value = { 0, }; error = NULL; bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error); if (bus == NULL) { g_warning ("Unable to get session bus: %s", error->message); g_error_free (error); return; } watcher->priv->presence_proxy = dbus_g_proxy_new_for_name (bus, GSM_SERVICE, GSM_PRESENCE_PATH, GSM_PRESENCE_INTERFACE); dbus_g_proxy_add_signal (watcher->priv->presence_proxy, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (watcher->priv->presence_proxy, "StatusChanged", G_CALLBACK (on_presence_status_changed), watcher, NULL); proxy = dbus_g_proxy_new_from_proxy (watcher->priv->presence_proxy, "org.freedesktop.DBus.Properties", GSM_PRESENCE_PATH); status = 0; error = NULL; dbus_g_proxy_call (proxy, "Get", &error, G_TYPE_STRING, GSM_PRESENCE_INTERFACE, G_TYPE_STRING, "status", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID); if (error != NULL) { g_warning ("Couldn't get presence status: %s", error->message); g_error_free (error); return; } else { status = g_value_get_uint (&value); } g_value_unset (&value); error = NULL; set_status (watcher, status); }
static int gtkToggleMapMethod(Ihandle* ih) { Ihandle* radio = iupRadioFindToggleParent(ih); char *value; int is3state = 0; if (!ih->parent) return IUP_ERROR; if (radio) ih->data->is_radio = 1; value = iupAttribGet(ih, "IMAGE"); if (value) ih->data->type = IUP_TOGGLE_IMAGE; else ih->data->type = IUP_TOGGLE_TEXT; if (ih->data->is_radio) { GtkRadioButton* last_tg = (GtkRadioButton*)iupAttribGet(radio, "_IUPGTK_LASTRADIOBUTTON"); if (last_tg) ih->handle = gtk_radio_button_new_from_widget(last_tg); else ih->handle = gtk_radio_button_new(NULL); iupAttribSet(radio, "_IUPGTK_LASTRADIOBUTTON", (char*)ih->handle); /* make sure it has at least one name */ if (!iupAttribGetHandleName(ih)) iupAttribSetHandleName(ih); } else { if (ih->data->type == IUP_TOGGLE_TEXT) { ih->handle = gtk_check_button_new(); if (iupAttribGetBoolean(ih, "3STATE")) is3state = 1; } else ih->handle = gtk_toggle_button_new(); } if (!ih->handle) return IUP_ERROR; if (ih->data->type == IUP_TOGGLE_TEXT) { gtk_button_set_image((GtkButton*)ih->handle, gtk_label_new(NULL)); gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, TRUE); } else { gtk_button_set_image((GtkButton*)ih->handle, gtk_image_new()); gtk_toggle_button_set_mode((GtkToggleButton*)ih->handle, FALSE); } /* add to the parent, all GTK controls must call this. */ iupgtkAddToParent(ih); if (!iupAttribGetBoolean(ih, "CANFOCUS")) iupgtkSetCanFocus(ih->handle, 0); if (ih->data->type == IUP_TOGGLE_IMAGE && ih->data->flat) { gtk_button_set_relief((GtkButton*)ih->handle, GTK_RELIEF_NONE); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(gtkToggleEnterLeaveEvent), ih); } else { g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); } g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); g_signal_connect(G_OBJECT(ih->handle), "toggled", G_CALLBACK(gtkToggleToggled), ih); if (ih->data->type == IUP_TOGGLE_IMAGE || is3state) { g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(gtkToggleButtonEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(gtkToggleButtonEvent), ih); } if (is3state) { g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkToggleKeyEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "key-release-event", G_CALLBACK(gtkToggleKeyEvent), ih); } gtk_widget_realize(ih->handle); /* update a mnemonic in a label if necessary */ iupgtkUpdateMnemonic(ih); return IUP_NOERROR; }
#define TRASH_APPLET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \ TRASH_TYPE_APPLET, TrashApplet)) static void trash_applet_do_empty (GtkAction *action, TrashApplet *applet); static void trash_applet_show_about (GtkAction *action, TrashApplet *applet); static void trash_applet_open_folder (GtkAction *action, TrashApplet *applet); static void trash_applet_show_help (GtkAction *action, TrashApplet *applet); static const GtkActionEntry trash_applet_menu_actions [] = { { "EmptyTrash", GTK_STOCK_CLEAR, N_("_Empty Trash"), NULL, NULL, G_CALLBACK (trash_applet_do_empty) }, { "OpenTrash", GTK_STOCK_OPEN, N_("_Open Trash"), NULL, NULL, G_CALLBACK (trash_applet_open_folder) }, { "HelpTrash", GTK_STOCK_HELP, N_("_Help"), NULL, NULL, G_CALLBACK (trash_applet_show_help) }, { "AboutTrash", GTK_STOCK_ABOUT, N_("_About"), NULL, NULL, G_CALLBACK (trash_applet_show_about) } }; static void trash_applet_monitor_changed (TrashApplet *applet) { GError *error = NULL;
static void edit_preset(const char *name_in, dt_lib_module_info_t *minfo) { gchar *name = NULL; if(name_in == NULL) { name = get_active_preset_name(minfo); if(name == NULL) return; } else name = g_strdup(name_in); GtkWidget *dialog; /* Create the widgets */ char title[1024]; GtkWidget *window = dt_ui_main_window(darktable.gui->ui); snprintf(title, sizeof(title), _("edit `%s'"), name); dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_DESTROY_WITH_PARENT, _("_OK"), GTK_RESPONSE_ACCEPT, _("_Cancel"), GTK_RESPONSE_REJECT, NULL); GtkContainer *content_area = GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))); GtkBox *box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_widget_set_margin_start(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_end(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_top(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_widget_set_margin_bottom(GTK_WIDGET(box), DT_PIXEL_APPLY_DPI(10)); gtk_container_add(content_area, GTK_WIDGET(box)); dt_lib_presets_edit_dialog_t *g = (dt_lib_presets_edit_dialog_t *)g_malloc0(sizeof(dt_lib_presets_edit_dialog_t)); g->old_id = -1; g_strlcpy(g->plugin_name, minfo->plugin_name, sizeof(g->plugin_name)); g->version = minfo->version; g->params_size = minfo->params_size; g->params = minfo->params; g->name = GTK_ENTRY(gtk_entry_new()); g->module = minfo->module; g->original_name = name; gtk_entry_set_text(g->name, name); gtk_box_pack_start(box, GTK_WIDGET(g->name), FALSE, FALSE, 0); g_object_set(G_OBJECT(g->name), "tooltip-text", _("name of the preset"), (char *)NULL); g->description = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(g->description), FALSE, FALSE, 0); g_object_set(G_OBJECT(g->description), "tooltip-text", _("description or further information"), (char *)NULL); sqlite3_stmt *stmt; DT_DEBUG_SQLITE3_PREPARE_V2( dt_database_get(darktable.db), "select rowid, description from presets where name = ?1 and operation = ?2 and op_version = ?3", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, name, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 2, minfo->plugin_name, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_INT(stmt, 3, minfo->version); if(sqlite3_step(stmt) == SQLITE_ROW) { g->old_id = sqlite3_column_int(stmt, 0); gtk_entry_set_text(g->description, (const char *)sqlite3_column_text(stmt, 1)); } sqlite3_finalize(stmt); g_signal_connect(dialog, "response", G_CALLBACK(edit_preset_response), g); gtk_widget_show_all(dialog); }
static void setup_search (CinnamonControlCenter *shell) { GtkWidget *search_view, *widget; GtkCellRenderer *renderer; GtkTreeViewColumn *column; CinnamonControlCenterPrivate *priv = shell->priv; g_return_if_fail (priv->store != NULL); /* create the search filter */ priv->search_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->search_filter), (GtkTreeModelFilterVisibleFunc) model_filter_func, priv, NULL); /* set up the search view */ priv->search_view = search_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (search_view), FALSE); gtk_tree_view_set_model (GTK_TREE_VIEW (search_view), GTK_TREE_MODEL (priv->search_filter)); renderer = gtk_cell_renderer_pixbuf_new (); g_object_set (renderer, "follow-state", TRUE, "xpad", 15, "ypad", 10, "stock-size", GTK_ICON_SIZE_DIALOG, NULL); column = gtk_tree_view_column_new_with_attributes ("Icon", renderer, "gicon", COL_GICON, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 0, NULL); column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", COL_NAME, NULL); gtk_tree_view_column_set_expand (column, FALSE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "xpad", 15, NULL); column = gtk_tree_view_column_new_with_attributes ("Description", renderer, "text", COL_DESCRIPTION, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->search_view), column); priv->search_scrolled = W (priv->builder, "search-scrolled-window"); gtk_container_add (GTK_CONTAINER (priv->search_scrolled), search_view); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->search_view)), "changed", G_CALLBACK (on_search_selection_changed), shell); }
static void dt_lib_presets_popup_menu_show(dt_lib_module_info_t *minfo) { GtkMenu *menu = darktable.gui->presets_popup_menu; if(menu) gtk_widget_destroy(GTK_WIDGET(menu)); darktable.gui->presets_popup_menu = GTK_MENU(gtk_menu_new()); menu = darktable.gui->presets_popup_menu; GtkWidget *mi; int active_preset = -1, cnt = 0, writeprotect = 0; sqlite3_stmt *stmt; // order: get shipped defaults first DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params, writeprotect, description from presets where " "operation=?1 and op_version=?2 order by writeprotect desc, name, rowid", -1, &stmt, NULL); DT_DEBUG_SQLITE3_BIND_TEXT(stmt, 1, minfo->plugin_name, -1, SQLITE_TRANSIENT); DT_DEBUG_SQLITE3_BIND_INT(stmt, 2, minfo->version); // collect all presets for op from db int found = 0; while(sqlite3_step(stmt) == SQLITE_ROW) { void *op_params = (void *)sqlite3_column_blob(stmt, 1); int32_t op_params_size = sqlite3_column_bytes(stmt, 1); const char *name = (char *)sqlite3_column_text(stmt, 0); if(darktable.gui->last_preset && strcmp(darktable.gui->last_preset, name) == 0) found = 1; // selected in bold: // printf("comparing %d bytes to %d\n", op_params_size, minfo->params_size); // for(int k=0;k<op_params_size && !memcmp(minfo->params, op_params, k);k++) printf("compare [%c %c] %d: // %d\n", // ((const char*)(minfo->params))[k], // ((const char*)(op_params))[k], // k, memcmp(minfo->params, op_params, k)); if(op_params_size == minfo->params_size && !memcmp(minfo->params, op_params, op_params_size)) { active_preset = cnt; writeprotect = sqlite3_column_int(stmt, 2); char *markup; mi = gtk_menu_item_new_with_label(""); markup = g_markup_printf_escaped("<span weight=\"bold\">%s</span>", name); gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup); g_free(markup); } else { mi = gtk_menu_item_new_with_label((const char *)name); } g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(pick_callback), minfo); g_object_set(G_OBJECT(mi), "tooltip-text", sqlite3_column_text(stmt, 3), (char *)NULL); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); cnt++; } sqlite3_finalize(stmt); if(cnt > 0) gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new()); // FIXME: this doesn't seem to work. if(active_preset >= 0) { if(!writeprotect) { mi = gtk_menu_item_new_with_label(_("edit this preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_edit_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); mi = gtk_menu_item_new_with_label(_("delete this preset")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_delete_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); } } else { mi = gtk_menu_item_new_with_label(_("store new preset..")); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_new_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); if(darktable.gui->last_preset && found) { char label[128]; g_strlcpy(label, _("update preset"), sizeof(label)); g_strlcat(label, " <span weight=\"bold\">%s</span>", sizeof(label)); char *markup = g_markup_printf_escaped(label, darktable.gui->last_preset); mi = gtk_menu_item_new_with_label(""); gtk_label_set_markup(GTK_LABEL(gtk_bin_get_child(GTK_BIN(mi))), markup); g_signal_connect(G_OBJECT(mi), "activate", G_CALLBACK(menuitem_update_preset), minfo); gtk_menu_shell_append(GTK_MENU_SHELL(menu), mi); g_free(markup); } } }
#define PLUGIN_ACTIONS_NAME "gnc-plugin-basic-commands-actions" #define PLUGIN_UI_FILENAME "gnc-plugin-basic-commands-ui.xml" /** An array of all of the actions provided by the basic commands * plugin. */ static GtkActionEntry gnc_plugin_actions [] = { /* File menu */ { "FileNewAction", "document-new", N_("New _File"), "<primary>n", N_("Create a new file"), G_CALLBACK (gnc_main_window_cmd_file_new) }, { "FileOpenAction", "document-open", N_("_Open..."), "<primary>o", N_("Open an existing GnuCash file"), G_CALLBACK (gnc_main_window_cmd_file_open) }, { "FileSaveAction", "document-save", N_("_Save"), "<primary>s", N_("Save the current file"), G_CALLBACK (gnc_main_window_cmd_file_save) }, { "FileSaveAsAction", "document-save-as", N_("Save _As..."), "<shift><primary>s", N_("Save this file with a different name"), G_CALLBACK (gnc_main_window_cmd_file_save_as)
GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module) { /* check if module is expandable */ if(!module->expandable()) { module->expander = NULL; return NULL; } int bs = DT_PIXEL_APPLY_DPI(12); GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *expander = dtgtk_expander_new(header, module->widget); GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander)); GtkWidget *pluginui_frame = dtgtk_expander_get_frame(DTGTK_EXPANDER(expander)); /* setup the header box */ g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press), module); /* setup plugin content frame */ gtk_frame_set_shadow_type(GTK_FRAME(pluginui_frame), GTK_SHADOW_IN); /* * initialize the header widgets */ int idx = 0; GtkWidget *hw[5] = { NULL, NULL, NULL, NULL, NULL }; /* add the expand indicator icon */ hw[idx] = dtgtk_icon_new(dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add module label */ char label[128]; g_snprintf(label, sizeof(label), "<span size=\"larger\">%s</span>", module->name()); hw[idx] = gtk_label_new(""); gtk_widget_set_name(hw[idx], "panel_label"); gtk_label_set_markup(GTK_LABEL(hw[idx++]), label); /* add reset button if module has implementation */ if(module->gui_reset) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->reset_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("reset parameters"), (char *)NULL); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(dt_lib_gui_reset_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add preset button if module has implementation */ if(module->get_params) { hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER); module->presets_button = GTK_WIDGET(hw[idx]); g_object_set(G_OBJECT(hw[idx]), "tooltip-text", _("presets"), (char *)NULL); g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(popup_callback), module); } else hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* add a spacer to align buttons with iop buttons (enabled button) */ hw[idx] = gtk_fixed_new(); gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs); /* lets order header elements depending on left/right side panel placement */ int c = module->container(); if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) || (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM)) { for(int i = 0; i <= 4; i++) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_START); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_RIGHT); } else { for(int i = 4; i >= 0; i--) if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2); gtk_widget_set_halign(hw[1], GTK_ALIGN_END); dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT); } /* add empty space around widget */ gtk_widget_set_margin_start(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_end(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_top(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_set_margin_bottom(module->widget, DT_PIXEL_APPLY_DPI(8)); gtk_widget_show_all(module->widget); gtk_widget_set_name(pluginui_frame, "lib-plugin-ui"); module->expander = expander; gtk_widget_set_hexpand(module->widget, FALSE); gtk_widget_set_vexpand(module->widget, FALSE); return module->expander; }
bool sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument), girara_event_t* UNUSED(event), unsigned int UNUSED(t)) { g_return_val_if_fail(session != NULL, false); g_return_val_if_fail(session->global.data != NULL, false); zathura_t* zathura = session->global.data; if (zathura->document == NULL) { return false; } girara_tree_node_t* document_index = NULL; GtkWidget* treeview = NULL; GtkTreeModel* model = NULL; GtkCellRenderer* renderer = NULL; GtkCellRenderer* renderer2 = NULL; if (zathura->ui.index == NULL) { /* create new index widget */ zathura->ui.index = gtk_scrolled_window_new(NULL, NULL); if (zathura->ui.index == NULL) { goto error_ret; } gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* create index */ document_index = zathura_document_index_generate(zathura->document, NULL); if (document_index == NULL) { girara_notify(session, GIRARA_WARNING, _("This document does not contain any index")); goto error_free; } model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER)); if (model == NULL) { goto error_free; } treeview = gtk_tree_view_new_with_model(model); if (treeview == NULL) { goto error_free; } g_object_unref(model); renderer = gtk_cell_renderer_text_new(); if (renderer == NULL) { goto error_free; } renderer2 = gtk_cell_renderer_text_new(); if (renderer2 == NULL) { goto error_free; } document_index_build(model, NULL, document_index); girara_node_free(document_index); /* setup widget */ gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_object_set(G_OBJECT(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0)), "expand", TRUE, NULL); gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f); gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE); g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura); gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview); gtk_widget_show(treeview); } static double vvalue = 0; static double hvalue = 0; if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) { girara_set_view(session, zathura->ui.page_widget_alignment); gtk_widget_hide(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.normal); /* reset adjustment */ position_set_delayed(zathura, hvalue, vvalue); } else { /* save adjustment */ GtkAdjustment* vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); GtkAdjustment* hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(session->gtk.view)); vvalue = gtk_adjustment_get_value(vadjustment); hvalue = gtk_adjustment_get_value(hadjustment); /* save current position to the jumplist */ zathura_jumplist_save(zathura); girara_set_view(session, zathura->ui.index); gtk_widget_show(GTK_WIDGET(zathura->ui.index)); girara_mode_set(zathura->ui.session, zathura->modes.index); } return false; error_free: if (zathura->ui.index != NULL) { g_object_ref_sink(zathura->ui.index); zathura->ui.index = NULL; } if (document_index != NULL) { girara_node_free(document_index); } error_ret: return false; }
static GtkWidget * glade_eprop_icon_sources_create_input (GladeEditorProperty * eprop) { GladeEPropIconSources *eprop_sources = GLADE_EPROP_ICON_SOURCES (eprop); GtkWidget *vbox, *hbox, *button, *swin; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); /* hbox with comboboxentry add/remove source buttons on the right... */ gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); eprop_sources->combo = gtk_combo_box_text_new_with_entry (); g_signal_connect (G_OBJECT (gtk_bin_get_child (GTK_BIN (eprop_sources->combo))), "activate", G_CALLBACK (icon_name_entry_activated), eprop); gtk_box_pack_start (GTK_BOX (hbox), eprop_sources->combo, TRUE, TRUE, 0); button = gtk_button_new (); gtk_container_set_border_width (GTK_CONTAINER (button), 2); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (add_clicked), eprop_sources); button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("list-remove-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_container_set_border_width (GTK_CONTAINER (button), 2); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (delete_clicked), eprop_sources); /* Pack treeview/swindow on the left... */ swin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swin), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start (GTK_BOX (vbox), swin, TRUE, TRUE, 0); eprop_sources->view = build_view (eprop); gtk_container_add (GTK_CONTAINER (swin), GTK_WIDGET (eprop_sources->view)); g_object_set (G_OBJECT (vbox), "height-request", 350, NULL); eprop_sources->store = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, // COLUMN_TEXT G_TYPE_INT, // COLUMN_TEXT_WEIGHT G_TYPE_BOOLEAN, // COLUMN_TEXT_EDITABLE G_TYPE_STRING, // COLUMN_ICON_NAME G_TYPE_INT, // COLUMN_LIST_INDEX G_TYPE_BOOLEAN, // COLUMN_DIRECTION_ACTIVE G_TYPE_STRING, // COLUMN_DIRECTION G_TYPE_BOOLEAN, // COLUMN_SIZE_ACTIVE G_TYPE_STRING, // COLUMN_SIZE G_TYPE_BOOLEAN, // COLUMN_STATE_ACTIVE, G_TYPE_STRING); // COLUMN_STATE gtk_tree_view_set_model (eprop_sources->view, GTK_TREE_MODEL (eprop_sources->store)); g_object_unref (G_OBJECT (eprop_sources->store)); // <-- pass ownership here gtk_widget_show_all (vbox); return vbox; }