void keyboard_general_init (CcPanel *panel, GtkBuilder *builder) { if (keyboard_settings == NULL) keyboard_settings = g_settings_new ("org.gnome.desktop.peripherals.keyboard"); if (interface_settings == NULL) interface_settings = g_settings_new ("org.gnome.desktop.interface"); g_settings_bind (keyboard_settings, "repeat", WID ("repeat_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (keyboard_settings, "repeat", WID ("repeat_grid"), "sensitive", G_SETTINGS_BIND_GET); g_settings_bind (keyboard_settings, "delay", gtk_range_get_adjustment (GTK_RANGE (WID ("repeat_delay_scale"))), "value", G_SETTINGS_BIND_DEFAULT); g_settings_bind_with_mapping (keyboard_settings, "repeat-interval", gtk_range_get_adjustment (GTK_RANGE (WID ("repeat_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT, get_rate, set_rate, NULL, NULL); g_settings_bind (interface_settings, "cursor-blink", WID ("cursor_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (interface_settings, "cursor-blink", WID ("cursor_grid"), "sensitive", G_SETTINGS_BIND_GET); g_settings_bind (interface_settings, "cursor-blink-time", gtk_range_get_adjustment (GTK_RANGE (WID ("cursor_blink_time_scale"))), "value", G_SETTINGS_BIND_DEFAULT); g_signal_connect (WID ("linkbutton"), "activate-link", G_CALLBACK (layout_link_clicked), panel); }
static void cc_ua_panel_init_seeing (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; g_settings_bind_with_mapping (priv->interface_settings, KEY_GTK_THEME, WID (priv->builder, "seeing_contrast_switch"), "active", G_SETTINGS_BIND_DEFAULT, get_contrast_mapping, set_contrast_mapping, priv->interface_settings, NULL); g_settings_bind_with_mapping (priv->interface_settings, KEY_TEXT_SCALING_FACTOR, WID (priv->builder, "seeing_large_text_switch"), "active", G_SETTINGS_BIND_DEFAULT, get_large_text_mapping, set_large_text_mapping, priv->interface_settings, NULL); g_settings_bind (priv->kb_settings, "togglekeys-enable", WID (priv->builder, "seeing_toggle_keys_switch"), "active", G_SETTINGS_BIND_DEFAULT); priv->shell_watch_id = g_bus_watch_name (G_BUS_TYPE_SESSION, "org.gnome.Shell", G_BUS_NAME_WATCHER_FLAGS_NONE, (GBusNameAppearedCallback) shell_appeared_cb, (GBusNameVanishedCallback) shell_vanished_cb, self, NULL); g_signal_connect (WID (priv->builder, "seeing_zoom_preferences_button"), "clicked", G_CALLBACK (zoom_options_launch_cb), self); g_settings_bind (priv->application_settings, "screen-magnifier-enabled", WID (priv->builder, "seeing_zoom_switch"), "active", G_SETTINGS_BIND_DEFAULT); settings_on_off_editor_new (priv, priv->application_settings, "screen-reader-enabled", WID (priv->builder, "seeing_reader_switch"), NULL); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_enable_keybinding_label", "magnifier"); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_in_keybinding_label", "magnifier-zoom-in"); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_out_keybinding_label", "magnifier-zoom-out"); cc_ua_panel_set_shortcut_label (self, "seeing_reader_enable_keybinding_label", "screenreader"); }
/* Create popup dialog */ void xkb_options_popup_dialog (GtkBuilder * dialog) { GtkWidget *chooser; chooser_dialog = gtk_builder_new (); gtk_builder_set_translation_domain (chooser_dialog, GETTEXT_PACKAGE); gtk_builder_add_from_file (chooser_dialog, SAGARMATHACC_UI_DIR "/sagarmatha-region-panel-options-dialog.ui", NULL); chooser = CWID ("xkb_options_dialog"); gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (gtk_widget_get_toplevel (WID ("region_notebook")))); gtk_window_set_modal (GTK_WINDOW (chooser), TRUE); xkb_options_load_options (chooser_dialog); g_signal_connect (chooser, "response", G_CALLBACK (chooser_response_cb), dialog); gtk_widget_show (chooser); }
/* Create popup dialog */ void xkb_options_popup_dialog (GtkBuilder * dialog) { GtkWidget *chooser; chooser_dialog = gtk_builder_new (); gtk_builder_add_from_file (chooser_dialog, MATECC_UI_DIR "/mate-keyboard-properties-options-dialog.ui", NULL); chooser = CWID ("xkb_options_dialog"); gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (WID ("keyboard_dialog"))); xkb_options_load_options (chooser_dialog); g_signal_connect (chooser, "response", G_CALLBACK (chooser_response_cb), dialog); gtk_dialog_run (GTK_DIALOG (chooser)); }
static void update_remove_button (CcBackgroundPanel *panel, CcBackgroundItem *item) { CcBackgroundPanelPrivate *priv; const char *uri; char *cache_path; GFile *bg, *cache, *parent; gboolean sensitive = FALSE; priv = panel->priv; if (priv->current_source != SOURCE_PICTURES) goto bail; uri = cc_background_item_get_uri (item); if (uri == NULL) goto bail; bg = g_file_new_for_uri (uri); parent = g_file_get_parent (bg); if (parent == NULL) { g_object_unref (bg); goto bail; } cache_path = bg_pictures_source_get_cache_path (); cache = g_file_new_for_path (cache_path); g_free (cache_path); if (g_file_equal (parent, cache)) sensitive = TRUE; g_object_unref (parent); g_object_unref (cache); bail: gtk_widget_set_sensitive (WID ("remove_button"), sensitive); }
static void update_mixer_tracks_selection (GSList *tracks, GladeXML *dialog) { GtkWidget *tracks_widget; GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeIter iter; tracks_widget = WID ("mixer_tracks"); model = gtk_tree_view_get_model (GTK_TREE_VIEW (tracks_widget)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tracks_widget)); g_signal_handlers_block_by_func (G_OBJECT (selection), G_CALLBACK (mixer_tracks_selection_changed), NULL); gtk_tree_selection_unselect_all (selection); if (tracks != NULL) { if (gtk_tree_model_get_iter_first (model, &iter)) { do { gchar *label; GSList *t; gtk_tree_model_get (model, &iter, MIXER_TRACKS_MODEL_LABEL_COLUMN, &label, -1); for (t = tracks; t != NULL; t = t->next) { if (!strcmp (label, t->data)) { gtk_tree_selection_select_iter (selection, &iter); break; } } g_free (label); } while (gtk_tree_model_iter_next (model, &iter)); } } g_signal_handlers_unblock_by_func (G_OBJECT (selection), G_CALLBACK (mixer_tracks_selection_changed), NULL); /* FIXME: if none selected, select master track */ }
static void screen_position_notify_cb (GSettings *settings, const gchar *key, ZoomOptions *options) { ZoomOptionsPrivate *priv = options->priv; gchar *position; GtkTreeIter iter; GtkTreeModel *model; GtkComboBox *combobox; gboolean valid; gchar *combo_value; position = g_settings_get_string (settings, key); position = g_settings_get_string (priv->settings, key); combobox = GTK_COMBO_BOX (WID ("screen_position_combo_box")); model = gtk_combo_box_get_model (combobox); /* Find the matching screen position value in the combobox model. If nothing * matches, leave the combobox as is. */ valid = gtk_tree_model_get_iter_first (model, &iter); while (valid) { gtk_tree_model_get (model, &iter, POSITION_MODEL_VALUE_COLUMN, &combo_value, -1); if (!g_strcmp0 (combo_value, position)) { g_signal_handlers_block_by_func (combobox, screen_position_combo_changed_cb, priv); gtk_combo_box_set_active_iter (combobox, &iter); g_signal_handlers_unblock_by_func (combobox, screen_position_combo_changed_cb, priv); g_free (combo_value); break; } g_free (combo_value); valid = gtk_tree_model_iter_next (model, &iter); } }
static void update_button_sensitivity (GtkBuilder *builder) { GtkWidget *remove_button; GtkWidget *up_button; GtkWidget *down_button; GtkWidget *show_button; GtkWidget *settings_button; GtkTreeView *tv; GtkTreeModel *model; GtkTreeIter iter; gint n_active; gint index; gboolean settings_sensitive; GDesktopAppInfo *app_info; remove_button = WID("input_source_remove"); show_button = WID("input_source_show"); up_button = WID("input_source_move_up"); down_button = WID("input_source_move_down"); settings_button = WID("input_source_settings"); tv = GTK_TREE_VIEW (WID ("active_input_sources")); n_active = gtk_tree_model_iter_n_children (gtk_tree_view_get_model (tv), NULL); if (get_selected_iter (builder, &model, &iter)) { index = idx_from_model_iter (model, &iter); gtk_tree_model_get (model, &iter, SETUP_COLUMN, &app_info, -1); } else { index = -1; app_info = NULL; } settings_sensitive = (index >= 0 && app_info != NULL); if (app_info) g_object_unref (app_info); gtk_widget_set_sensitive (remove_button, index >= 0 && n_active > 1); gtk_widget_set_sensitive (show_button, index >= 0); gtk_widget_set_sensitive (up_button, index > 0); gtk_widget_set_sensitive (down_button, index >= 0 && index < n_active - 1); gtk_widget_set_sensitive (settings_button, settings_sensitive); }
/* Sets dialog busy state according to busy * * When busy: * Sets the cursor to busy * Disables the interface to prevent that the user interferes * Reverts all this when non-busy * * Note that this function takes into account the * authentication state of the dialog. So setting the * dialog to busy and then back to normal should leave * the dialog unchanged. */ static void passdlg_set_busy (PasswordDialog *pdialog, gboolean busy) { GtkBuilder *dialog; GtkWidget *toplevel; GdkCursor *cursor = NULL; GdkDisplay *display; dialog = pdialog->ui; /* Set cursor */ toplevel = WID ("change-password"); display = gtk_widget_get_display (toplevel); if (busy) { cursor = gdk_cursor_new_for_display (display, GDK_WATCH); } gdk_window_set_cursor (gtk_widget_get_window (toplevel), cursor); gdk_display_flush (display); if (busy) { gdk_cursor_unref (cursor); } /* Disable/Enable UI */ if (pdialog->authenticated) { /* Authenticated state */ /* Enable/disable new password section */ g_object_set (pdialog->new_password, "sensitive", !busy, NULL); g_object_set (pdialog->retyped_password, "sensitive", !busy, NULL); g_object_set (WID ("new-password-label"), "sensitive", !busy, NULL); g_object_set (WID ("retyped-password-label"), "sensitive", !busy, NULL); /* Enable/disable change password button */ g_object_set (WID ("change-password-button"), "sensitive", !busy, NULL); } else { /* Not-authenticated state */ /* Enable/disable auth section state */ g_object_set (pdialog->current_password, "sensitive", !busy, NULL); g_object_set (WID ("authenticate-button"), "sensitive", !busy, NULL); g_object_set (WID ("current-password-label"), "sensitive", !busy, NULL); } }
DIA_encoding::DIA_encoding( uint32_t fps1000 ) { assert(dialog==NULL); stopReq=0; _roundup=floor( (fps1000+999)/1000); for(uint32_t i=0;i<_roundup;i++) _bitrate[i]=0; _totalSize=0; _current=0; dialog=create_dialog1(); //gtk_transient(dialog); gtk_signal_connect(GTK_OBJECT(WID(closebutton1)), "clicked", GTK_SIGNAL_FUNC(DIA_stop), NULL); gtk_signal_connect(GTK_OBJECT(dialog), "delete_event", GTK_SIGNAL_FUNC(on_destroy_abort), NULL); gtk_widget_show(dialog); UI_iconify(); _lastTime=0; _lastFrame=0; _fps_average=0; }
static GladeXML * create_dialog (void) { GladeXML *dialog; GtkWidget *widget, *box, *view, *image; dialog = glade_xml_new (GNOMECC_GLADE_DIR "/sound-properties.glade", "sound_prefs_dialog", NULL); if (dialog == NULL) return NULL; widget = glade_xml_get_widget (dialog, "sound_prefs_dialog"); props = sound_properties_new (); sound_properties_add_defaults (props, NULL); g_signal_connect (G_OBJECT (props), "event_changed", (GCallback) props_changed_cb, NULL); view = sound_view_new (props); box = glade_xml_get_widget (dialog, "events_vbox"); gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0); gtk_widget_show_all (view); g_signal_connect_swapped (G_OBJECT (widget), "destroy", (GCallback) gtk_object_destroy, props); gtk_image_set_from_file (GTK_IMAGE (WID ("bell_image")), GNOMECC_DATA_DIR "/pixmaps/visual-bell.png"); image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (WID ("sounds_playback_test")), image); image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (WID ("music_playback_test")), image); image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (WID ("chat_audio_playback_test")), image); image = gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (WID ("chat_audio_capture_test")), image); if (!CheckXKB()) { gtk_widget_set_sensitive (WID ("bell_flash_alignment"), FALSE); } return dialog; }
/** \fn DIA_getHue \brief Handle Hue (fly)Dialog */ uint8_t DIA_getHue(Hue_Param *param, AVDMGenericVideoStream *in) { uint32_t width,height; uint8_t ret=0; // Allocate space for green-ised video width=in->getInfo()->width; height=in->getInfo()->height; dialog=create_dialog1(); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_register_dialog(dialog); gtk_window_set_title (GTK_WINDOW (dialog), QT_TR_NOOP("Hue")); gtk_signal_connect(GTK_OBJECT(WID(drawingarea1)), "expose_event", GTK_SIGNAL_FUNC(draw), NULL); // gtk_signal_connect(GTK_OBJECT(WID(hscale1)), "value_changed",GTK_SIGNAL_FUNC(frame_changed), NULL); gtk_signal_connect(GTK_OBJECT(WID(hscaleHue)), "value_changed",GTK_SIGNAL_FUNC(hue_changed), NULL); gtk_signal_connect(GTK_OBJECT(WID(hscaleSaturation)), "value_changed",GTK_SIGNAL_FUNC(hue_changed), NULL); gtk_widget_show(dialog); myCrop=new flyHue( width, height,in,WID(drawingarea1),WID(hscale1)); memcpy(&(myCrop->param),param,sizeof(Hue_Param)); myCrop->upload(); myCrop->sliderChanged(); ret=0; int response; response=gtk_dialog_run(GTK_DIALOG(dialog)); if(response==GTK_RESPONSE_OK) { myCrop->download(); memcpy(param,&(myCrop->param),sizeof(Hue_Param)); ret=1; } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); delete myCrop; return ret; }
static void finish_calibration (CalibArea *area, gpointer user_data) { CcWacomPage *page = (CcWacomPage *) user_data; CcWacomPagePrivate *priv = page->priv; XYinfo axis; gboolean swap_xy; int cal[4]; if (calib_area_finish (area, &axis, &swap_xy)) { cal[0] = axis.x_min; cal[1] = axis.y_min; cal[2] = axis.x_max; cal[3] = axis.y_max; set_calibration(cal, 4, priv->wacom_settings); } calib_area_free (area); priv->area = NULL; gtk_widget_set_sensitive (WID ("button-calibrate"), TRUE); }
static void cc_ua_panel_init_seeing (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; text_scaling_factor_notify_cb (priv->interface_settings, "text-scaling-factor", self); g_signal_connect (priv->interface_settings, "changed::text-scaling-factor", G_CALLBACK (text_scaling_factor_notify_cb), self); g_signal_connect (WID (priv->builder, "seeing_contrast_combobox"), "changed", G_CALLBACK (contrast_combobox_changed_cb), self); g_signal_connect (WID (priv->builder, "seeing_text_size_combobox"), "changed", G_CALLBACK (text_scaling_factor_combo_box_changed), self); g_settings_bind (priv->kb_settings, "togglekeys-enable", WID (priv->builder, "seeing_enable_toggle_keys_checkbutton"), "active", G_SETTINGS_BIND_DEFAULT); priv->shell_watch_id = g_bus_watch_name (G_BUS_TYPE_SESSION, "org.gnome.Shell", G_BUS_NAME_WATCHER_FLAGS_NONE, (GBusNameAppearedCallback) shell_appeared_cb, (GBusNameVanishedCallback) shell_vanished_cb, self, NULL); g_signal_connect (WID (priv->builder, "seeing_zoom_preferences_button"), "clicked", G_CALLBACK (zoom_options_launch_cb), self); g_settings_bind (priv->application_settings, "screen-magnifier-enabled", WID (priv->builder, "seeing_zoom_switch"), "active", G_SETTINGS_BIND_DEFAULT); settings_on_off_editor_new (priv, priv->application_settings, "screen-reader-enabled", WID (priv->builder, "seeing_reader_switch"), NULL); cc_ua_panel_set_shortcut_label (self, "seeing_contrast_toggle_keybinding_label", "toggle-contrast"); cc_ua_panel_set_shortcut_label (self, "seeing_increase_size_keybinding_label", "increase-text-size"); cc_ua_panel_set_shortcut_label (self, "seeing_decrease_size_keybinding_label", "decrease-text-size"); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_enable_keybinding_label", "magnifier"); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_in_keybinding_label", "magnifier-zoom-in"); cc_ua_panel_set_shortcut_label (self, "seeing_zoom_out_keybinding_label", "magnifier-zoom-out"); cc_ua_panel_set_shortcut_label (self, "seeing_reader_enable_keybinding_label", "screenreader"); }
static void display_properties_dialog (GtkAction *action, TasklistData *tasklist) { if (tasklist->properties_dialog == NULL) { GtkBuilder *builder; GError *error; builder = gtk_builder_new (); gtk_builder_set_translation_domain (builder, GETTEXT_PACKAGE); error = NULL; gtk_builder_add_from_file (builder, TASKLIST_BUILDERDIR "/window-list.ui", &error); if (error) { g_warning ("Error loading preferences: %s", error->message); g_error_free (error); return; } tasklist->properties_dialog = WID ("tasklist_properties_dialog"); g_object_add_weak_pointer (G_OBJECT (tasklist->properties_dialog), (void**) &tasklist->properties_dialog); setup_dialog (builder, tasklist); g_object_unref (builder); } gtk_window_set_icon_name (GTK_WINDOW (tasklist->properties_dialog), WINDOW_LIST_ICON); gtk_window_set_resizable (GTK_WINDOW (tasklist->properties_dialog), FALSE); gtk_window_set_screen (GTK_WINDOW (tasklist->properties_dialog), gtk_widget_get_screen (tasklist->applet)); gtk_window_present (GTK_WINDOW (tasklist->properties_dialog)); }
DIA_encoding::DIA_encoding( uint32_t fps1000 ) { uint32_t useTray=0; if(!prefs->get(FEATURE_USE_SYSTRAY,&useTray)) useTray=0; ADM_assert(dialog==NULL); stopReq=0; _totalSize=0; _audioSize=0; _videoSize=0; _current=0; setFps(fps1000); dialog=create_dialog1(); gtk_register_dialog(dialog); //gtk_transient(dialog); gtk_signal_connect(GTK_OBJECT(WID(closebutton1)), "clicked", GTK_SIGNAL_FUNC(DIA_stop), NULL); gtk_signal_connect(GTK_OBJECT(dialog), "delete_event", GTK_SIGNAL_FUNC(on_destroy_abort), NULL); gtk_widget_show(dialog); // gtk_window_set_modal(GTK_WINDOW(dialog), 1); if(useTray) { gtk_window_iconify(GTK_WINDOW(dialog)); UI_iconify(); } _lastTime=0; _lastFrame=0; _fps_average=0; tray=NULL; if(useTray) tray=new ADM_tray("Encoding"); }
static void empty_trash (CcPrivacyPanel *self) { GDBusConnection *bus; gboolean result; GtkWidget *dialog; dialog = WID ("trash_dialog"); result = run_warning (GTK_WINDOW (dialog), _("Empty all items from Trash?"), _("All items in the Trash will be permanently deleted."), _("_Empty Trash")); if (!result) return; bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL); g_dbus_connection_call (bus, "org.gnome.SettingsDaemon", "/org/gnome/SettingsDaemon/Housekeeping", "org.gnome.SettingsDaemon.Housekeeping", "EmptyTrash", NULL, NULL, 0, -1, NULL, NULL, NULL); g_object_unref (bus); }
void GUI_PreviewInit(uint32_t w , uint32_t h,uint32_t modal) { if(rgb_render) { printf("\n Warning rgb render not null...\n"); delete [] rgb_render; delete [] rgb_alternate; rgb_alternate=NULL; rgb_render=NULL; } stacked=0; ADM_assert(rgb_render=new uint8_t [w*h*4]); ADM_assert(rgb_alternate=new uint8_t [w*h*4]); uw=w; uh=h; rgbConv.reset(w,h); // add callback for destroy lock=0; needDestroy=1; #define CNX(x,y,z) gtk_signal_connect(GTK_OBJECT(x), #y, \ GTK_SIGNAL_FUNC(z), (void *) NULL); dialog=create_dialog1(); /* CNX(WID(buttonNext),clicked ,cb_next); CNX(WID(buttonPrev),clicked ,cb_prev); */ CNX(WID(drawingarea1),expose_event,previewRender); // CNX(dialog ,delete_event,preview_exit_short); gtk_widget_set_usize (lookup_widget(dialog,"drawingarea1"),w,h); gtk_widget_show( dialog); }
static void chooser_response (GtkDialog *chooser, int response_id, GtkBuilder *dialog) { if (response_id == GTK_RESPONSE_OK) { char *id, *name; GtkListStore *list_store; list_store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (WID ("xkb_layouts_selected")))); id = xkb_layout_chooser_get_selected_id (chooser); name = xkb_layout_description_utf8 (id); gtk_list_store_insert_with_values (list_store, NULL, G_MAXINT, SEL_LAYOUT_TREE_COL_DESCRIPTION, name, SEL_LAYOUT_TREE_COL_ID, id, SEL_LAYOUT_TREE_COL_ENABLED, TRUE, -1); g_free (name); add_default_switcher_if_necessary (); update_layouts_list (GTK_TREE_MODEL (list_store), dialog); } xkb_layout_chooser_response (chooser, response_id); }
static void _utoa(struct fmtctx *ctx, unsigned int base, unsigned long long arg) { static const char digits[] = "0123456789abcdef"; char buf[23]; /* 64 bits = 22 octal digits, leading '-' */ char *n = buf + sizeof(buf) - 1; char *o = n; if (!arg) { *n = digits[0]; n--; } while (arg) { *n = digits[arg % base]; n--; arg /= base; } if (ctx->state & ST_ZEROPAD) while ((o - n) < WID(ctx) && n > buf) *n-- = '0'; if (ctx->state & ST_NEGATIVE) *n-- = '-'; n++; while (n < buf + sizeof(buf)) ctx->out(ctx->priv, *n++); }
static void purge_temp (CcPrivacyPanel *self) { GDBusConnection *bus; gboolean result; GtkWidget *dialog; dialog = WID ("trash_dialog"); result = run_warning (GTK_WINDOW (dialog), _("Delete all the temporary files?"), _("All the temporary files will be permanently deleted."), _("_Purge Temporary Files")); if (!result) return; bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL); g_dbus_connection_call (bus, "org.gnome.SettingsDaemon", "/org/gnome/SettingsDaemon/Housekeeping", "org.gnome.SettingsDaemon.Housekeeping", "RemoveTempFiles", NULL, NULL, 0, -1, NULL, NULL, NULL); g_object_unref (bus); }
static void cc_ua_panel_init_mouse (CcUaPanel *self) { CcUaPanelPrivate *priv = self->priv; GtkWidget *w; /* mouse keys */ w = WID (priv->builder, "pointing_mouse_keys_switch"); settings_on_off_editor_new (priv, priv->kb_settings, "mousekeys-enable", w, NULL); /* simulated secondary click */ w = WID (priv->builder, "pointing_second_click_switch"); settings_on_off_editor_new (priv, priv->mouse_settings, "secondary-click-enabled", w, secondary_click_section); w = WID (priv->builder, "pointing_secondary_click_delay_scale"); g_settings_bind (priv->mouse_settings, "secondary-click-time", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* dwell click */ w = WID (priv->builder, "pointing_hover_click_switch"); settings_on_off_editor_new (priv, priv->mouse_settings, "dwell-click-enabled", w, dwell_click_section); w = WID (priv->builder, "pointing_dwell_delay_scale"); g_settings_bind (priv->mouse_settings, "dwell-time", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); w = WID (priv->builder, "pointing_dwell_threshold_scale"); g_settings_bind (priv->mouse_settings, "dwell-threshold", gtk_range_get_adjustment (GTK_RANGE (w)), "value", G_SETTINGS_BIND_DEFAULT); /* mouse preferences button */ g_signal_connect (WID (priv->builder, "pointing_mouse_preferences_link"), "activate-link", G_CALLBACK (pointing_mouse_preferences_clicked_cb), self); }
static void init_screen_part_section (ZoomOptionsPrivate *priv, PangoAttrList *pango_attrs) { gboolean lens_mode; GSList *mouse_mode_group; priv->follow_mouse_radio = WID ("moveableLens"); priv->screen_part_radio = WID ("screenPart"); priv->centered_radio = WID ("centered"); priv->push_radio = WID ("push"); priv->proportional_radio = WID ("proportional"); priv->extend_beyond_checkbox = WID ("scrollAtEdges"); /* Scale the labels of the toggles */ scale_label (GTK_BIN(priv->follow_mouse_radio), pango_attrs); scale_label (GTK_BIN(priv->screen_part_radio), pango_attrs); scale_label (GTK_BIN(priv->centered_radio), pango_attrs); scale_label (GTK_BIN(priv->push_radio), pango_attrs); scale_label (GTK_BIN(priv->proportional_radio), pango_attrs); scale_label (GTK_BIN(priv->extend_beyond_checkbox), pango_attrs); lens_mode = g_settings_get_boolean (priv->settings, "lens-mode"); set_active (priv->follow_mouse_radio, lens_mode); set_active (priv->screen_part_radio, !lens_mode); mouse_mode_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (priv->centered_radio)); init_mouse_mode_radio_group (mouse_mode_group, priv); set_enable_screen_part_ui (priv->screen_part_radio, priv); g_settings_bind (priv->settings, "lens-mode", priv->follow_mouse_radio, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->settings, "scroll-at-edges", priv->extend_beyond_checkbox, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (G_OBJECT (priv->screen_part_radio), "toggled", G_CALLBACK (set_enable_screen_part_ui), priv); g_signal_connect (G_OBJECT (priv->settings), "changed::mouse-tracking", G_CALLBACK (mouse_tracking_notify_cb), priv); }
static void update_preview (CcBackgroundPanelPrivate *priv, GSettings *settings, CcBackgroundItem *item) { gboolean changes_with_time; CcBackgroundItem *current_background; current_background = CURRENT_BG; if (item && current_background) { g_object_unref (current_background); current_background = cc_background_item_copy (item); if (settings == priv->settings) priv->current_background = current_background; else priv->current_lock_background = current_background; cc_background_item_load (current_background, NULL); } changes_with_time = FALSE; if (current_background) { changes_with_time = cc_background_item_changes_with_time (current_background); } if (settings == priv->settings) { gtk_widget_set_visible (WID ("slide_image"), changes_with_time); gtk_widget_set_visible (WID ("slide-label"), changes_with_time); gtk_widget_queue_draw (WID ("background-desktop-drawingarea")); } else { gtk_widget_set_visible (WID ("slide_image1"), changes_with_time); gtk_widget_set_visible (WID ("slide-label1"), changes_with_time); gtk_widget_queue_draw (WID ("background-lock-drawingarea")); } }
static const char * selected_finger (GtkBuilder *dialog) { int index; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (WID ("radiobutton1")))) { gtk_widget_set_sensitive (WID ("finger_combobox"), FALSE); return "right-index-finger"; } if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (WID ("radiobutton2")))) { gtk_widget_set_sensitive (WID ("finger_combobox"), FALSE); return "left-index-finger"; } gtk_widget_set_sensitive (WID ("finger_combobox"), TRUE); index = gtk_combo_box_get_active (GTK_COMBO_BOX (WID ("finger_combobox"))); switch (index) { case 0: return "left-thumb"; case 1: return "left-middle-finger"; case 2: return "left-ring-finger"; case 3: return "left-little-finger"; case 4: return "right-thumb"; case 5: return "right-middle-finger"; case 6: return "right-ring-finger"; case 7: return "right-little-finger"; default: g_assert_not_reached (); } return NULL; }
static void xkb_layouts_enable_disable_buttons (GtkBuilder * dialog) { GtkWidget *add_layout_btn = WID ("xkb_layouts_add"); GtkWidget *show_layout_btn = WID ("xkb_layouts_show"); GtkWidget *del_layout_btn = WID ("xkb_layouts_remove"); GtkWidget *selected_layouts_tree = WID ("xkb_layouts_selected"); GtkWidget *move_up_layout_btn = WID ("xkb_layouts_move_up"); GtkWidget *move_down_layout_btn = WID ("xkb_layouts_move_down"); GtkTreeSelection *s_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (selected_layouts_tree)); const int n_selected_selected_layouts = gtk_tree_selection_count_selected_rows (s_selection); GtkTreeModel *selected_layouts_model = gtk_tree_view_get_model (GTK_TREE_VIEW (selected_layouts_tree)); const int n_selected_layouts = gtk_tree_model_iter_n_children (selected_layouts_model, NULL); gint sidx = find_selected_layout_idx (dialog); if (disable_buttons_sensibility_update) return; gtk_widget_set_sensitive (add_layout_btn, (n_selected_layouts < max_selected_layouts || max_selected_layouts == 0)); gtk_widget_set_sensitive (del_layout_btn, (n_selected_layouts > 1) && (n_selected_selected_layouts > 0)); gtk_widget_set_sensitive (show_layout_btn, (n_selected_selected_layouts > 0)); gtk_widget_set_sensitive (move_up_layout_btn, sidx > 0); gtk_widget_set_sensitive (move_down_layout_btn, sidx >= 0 && sidx < (n_selected_layouts - 1)); }
static void create_dialog (CcMousePropertiesPrivate *d) { GtkSizeGroup *size_group; size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (size_group, WID ("primary_button_label")); gtk_size_group_add_widget (size_group, WID ("pointer_speed_label")); gtk_size_group_add_widget (size_group, WID ("double_click_label")); gtk_size_group_add_widget (size_group, WID ("touchpad_pointer_speed_label")); size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (size_group, WID ("pointer_speed_fast_label")); gtk_size_group_add_widget (size_group, WID ("double_click_fast_label")); gtk_size_group_add_widget (size_group, WID ("touchpad_pointer_speed_fast_label")); size_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_size_group_add_widget (size_group, WID ("pointer_speed_slow_label")); gtk_size_group_add_widget (size_group, WID ("double_click_slow_label")); gtk_size_group_add_widget (size_group, WID ("touchpad_pointer_speed_slow_label")); gtk_widget_set_direction (WID ("primary_button_box"), GTK_TEXT_DIR_LTR); }
/* Set up the property editors in the dialog. */ static void setup_dialog (CcMousePropertiesPrivate *d) { GtkRadioButton *radio; /* Orientation radio buttons */ radio = GTK_RADIO_BUTTON (WID ("left_handed_radio")); g_settings_bind (d->mouse_settings, "left-handed", radio, "active", G_SETTINGS_BIND_DEFAULT); /* explicitly connect to button-release so that you can change orientation with either button */ g_signal_connect (WID ("right_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); g_signal_connect (WID ("left_handed_radio"), "button_release_event", G_CALLBACK (orientation_radio_button_release_event), NULL); /* Double-click time */ g_settings_bind (d->gsd_mouse_settings, "double-click", gtk_range_get_adjustment (GTK_RANGE (WID ("double_click_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Mouse section */ gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse); gtk_scale_add_mark (GTK_SCALE (WID ("pointer_speed_scale")), 0, GTK_POS_TOP, NULL); g_settings_bind (d->mouse_settings, "speed", gtk_range_get_adjustment (GTK_RANGE (WID ("pointer_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT); /* Trackpad page */ gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad); gtk_widget_set_visible (WID ("touchpad_enabled_switch"), show_touchpad_enabling_switch (d)); g_settings_bind_with_mapping (d->touchpad_settings, "send-events", WID ("touchpad_enabled_switch"), "active", G_SETTINGS_BIND_DEFAULT, touchpad_enabled_get_mapping, touchpad_enabled_set_mapping, NULL, NULL); g_settings_bind_with_mapping (d->touchpad_settings, "send-events", WID ("touchpad_options_box"), "sensitive", G_SETTINGS_BIND_GET, touchpad_enabled_get_mapping, touchpad_enabled_set_mapping, NULL, NULL); g_settings_bind (d->touchpad_settings, "tap-to-click", WID ("tap_to_click_toggle"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (d->touchpad_settings, "natural-scroll", WID ("natural_scroll_toggle"), "active", G_SETTINGS_BIND_DEFAULT); gtk_scale_add_mark (GTK_SCALE (WID ("touchpad_pointer_speed_scale")), 0, GTK_POS_TOP, NULL); g_settings_bind (d->touchpad_settings, "speed", gtk_range_get_adjustment (GTK_RANGE (WID ("touchpad_pointer_speed_scale"))), "value", G_SETTINGS_BIND_DEFAULT); if (d->have_touchpad) { synaptics_check_capabilities (d); setup_scrollmethod_radios (d); } g_signal_connect (WID ("two_finger_scroll_toggle"), "toggled", G_CALLBACK (scrollmethod_changed_event), d); }
static void synaptics_check_capabilities_x11 (CcMousePropertiesPrivate *d) { int numdevices, i; XDeviceInfo *devicelist; Atom realtype, prop_capabilities, prop_scroll_methods, prop_tapping_enabled; int realformat; unsigned long nitems, bytes_after; unsigned char *data; gboolean tap_to_click, two_finger_scroll; prop_capabilities = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "Synaptics Capabilities", False); prop_scroll_methods = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "libinput Scroll Methods Available", False); prop_tapping_enabled = XInternAtom (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), "libinput Tapping Enabled", False); if (!prop_capabilities || !prop_scroll_methods || !prop_tapping_enabled) return; tap_to_click = FALSE; two_finger_scroll = FALSE; devicelist = XListInputDevices (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), &numdevices); for (i = 0; i < numdevices; i++) { if (devicelist[i].use != IsXExtensionPointer) continue; gdk_error_trap_push (); XDevice *device = XOpenDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), devicelist[i].id); if (gdk_error_trap_pop ()) continue; gdk_error_trap_push (); /* xorg-x11-drv-synaptics */ if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device, prop_capabilities, 0, 2, False, XA_INTEGER, &realtype, &realformat, &nitems, &bytes_after, &data) == Success) && (realtype != None)) { /* Property data is booleans for has_left, has_middle, has_right, has_double, has_triple. * Newer drivers (X.org/kerrnel) will also include has_pressure and has_width. */ /* Set tap_to_click_toggle sensitive only if the device has hardware buttons */ if (data[0]) tap_to_click = TRUE; /* Set two_finger_scroll_toggle sensitive if the hardware supports double touch */ if (data[3]) two_finger_scroll = TRUE; XFree (data); } /* xorg-x11-drv-libinput */ if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device, prop_scroll_methods, 0, 2, False, XA_INTEGER, &realtype, &realformat, &nitems, &bytes_after, &data) == Success) && (realtype != None)) { /* Property data is booleans for two-finger, edge, on-button scroll available. */ if (data[0] && data[1]) two_finger_scroll = TRUE; XFree (data); } if ((XGetDeviceProperty (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device, prop_tapping_enabled, 0, 1, False, XA_INTEGER, &realtype, &realformat, &nitems, &bytes_after, &data) == Success) && (realtype != None)) { /* Property data is boolean for tapping enabled. */ tap_to_click = TRUE; XFree (data); } gdk_error_trap_pop_ignored (); XCloseDevice (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), device); } XFreeDeviceList (devicelist); gtk_widget_set_sensitive (WID ("tap_to_click_toggle"), tap_to_click); gtk_widget_set_sensitive (WID ("two_finger_scroll_toggle"), two_finger_scroll); }
/*----------------------------------------------*/ uint8_t DIA_resize(uint32_t *width,uint32_t *height,uint32_t *alg,uint32_t originalw, uint32_t originalh,uint32_t fps1000) { char str[100]; uint8_t ret=0; if(fps1000>24600 && fps1000<25400) { aprintf("Pal\n"); pal=1; } else { aprintf("NTSC\n"); pal=0; } ow=originalw; oh=originalh; iw=*width; ih=*height; dialog=create_dialog1(); gtk_dialog_set_alternative_button_order(GTK_DIALOG(dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, GTK_RESPONSE_APPLY, -1); //gtk_transient(dialog); gtk_register_dialog(dialog); erx=ery=0; double val; val=100.*iw; if(ow) val=val/ow; adj_angle= gtk_range_get_adjustment (GTK_RANGE(WID(hscale1))); gtk_adjustment_set_value( GTK_ADJUSTMENT(adj_angle),( gdouble ) val ); // remember algo gtk_option_menu_set_history (GTK_OPTION_MENU (WID(optionmenu1)), *alg); #define CONNECT(w,x) gtk_signal_connect(GTK_OBJECT(lookup_widget(dialog,#w)), #x, \ GTK_SIGNAL_FUNC(drag), NULL) CONNECT(hscale1,drag_data_received); CONNECT(hscale1,drag_motion); CONNECT(hscale1,drag_data_get); CONNECT(hscale1,drag_begin); gtk_signal_connect(GTK_OBJECT(adj_angle),"value_changed", GTK_SIGNAL_FUNC(drag), NULL); write(); ret=0; uint8_t stop=0; while(!stop) { switch(gtk_dialog_run(GTK_DIALOG(dialog))) { case GTK_RESPONSE_OK: gchar *s; SPIN_GET(spinbutton_width,*width); SPIN_GET(spinbutton_height,*height); *alg= getRangeInMenu(lookup_widget(dialog,"optionmenu1")); ret=1; stop=1; break; default: case GTK_RESPONSE_CANCEL: stop=1; break; case GTK_RESPONSE_APPLY: drag(NULL,NULL); break; } } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); return ret; }