void GlobalPressedKeys_disconnect( ui::Window window ){ g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_press_handler" ) ) ); g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "key_release_handler" ) ) ); g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_in_handler" ) ) ); g_signal_handler_disconnect( G_OBJECT( window ), gpointer_to_int( g_object_get_data( G_OBJECT( window ), "focus_out_handler" ) ) ); }
static gboolean piece_button_press (GooCanvasItem *item, GooCanvasItem *target, GdkEventButton *event, gpointer data) { GooCanvas *canvas; GooCanvasItemModel **board; GooCanvasItemModel *model, *text G_GNUC_UNUSED; int num G_GNUC_UNUSED, pos, newpos; int x, y; double dx = 0.0, dy = 0.0; int move; model = goo_canvas_item_get_model (item); canvas = goo_canvas_item_get_canvas (item); board = g_object_get_data (G_OBJECT (canvas), "board"); num = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model), "piece_num")); pos = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (model), "piece_pos")); text = g_object_get_data (G_OBJECT (model), "text"); #if 0 g_print ("In piece_event pos: %i,%i num: %i\n", pos % 4, pos / 4, num + 1); #endif y = pos / 4; x = pos % 4; move = TRUE; if ((y > 0) && (board[(y - 1) * 4 + x] == NULL)) { dx = 0.0; dy = -1.0; y--; } else if ((y < 3) && (board[(y + 1) * 4 + x] == NULL)) { dx = 0.0; dy = 1.0; y++; } else if ((x > 0) && (board[y * 4 + x - 1] == NULL)) { dx = -1.0; dy = 0.0; x--; } else if ((x < 3) && (board[y * 4 + x + 1] == NULL)) { dx = 1.0; dy = 0.0; x++; } else move = FALSE; if (move) { newpos = y * 4 + x; board[pos] = NULL; board[newpos] = model; g_object_set_data (G_OBJECT (model), "piece_pos", GINT_TO_POINTER (newpos)); goo_canvas_item_model_translate (model, dx * PIECE_SIZE, dy * PIECE_SIZE); test_win (board); } return FALSE; }
void file_revert_cmd_callback (GtkAction *action, gpointer data) { GimpDisplay *display; GimpImage *image; GtkWidget *dialog; const gchar *uri; return_if_no_display (display, data); image = gimp_display_get_image (display); uri = gimp_image_get_uri (image); if (! uri) uri = gimp_image_get_imported_uri (image); dialog = g_object_get_data (G_OBJECT (image), REVERT_DATA_KEY); if (! uri) { gimp_message_literal (image->gimp, G_OBJECT (display), GIMP_MESSAGE_ERROR, _("Revert failed. " "No file name associated with this image.")); } else if (dialog) { gtk_window_present (GTK_WINDOW (dialog)); } else { gchar *filename; dialog = gimp_message_dialog_new (_("Revert Image"), GTK_STOCK_REVERT_TO_SAVED, GTK_WIDGET (gimp_display_get_shell (display)), 0, gimp_standard_help_func, GIMP_HELP_FILE_REVERT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_REVERT_TO_SAVED, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_signal_connect_object (display, "disconnect", G_CALLBACK (gtk_widget_destroy), dialog, G_CONNECT_SWAPPED); g_signal_connect (dialog, "response", G_CALLBACK (file_revert_confirm_response), display); filename = file_utils_uri_display_name (uri); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("Revert '%s' to '%s'?"), gimp_image_get_display_name (image), filename); g_free (filename); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, _("By reverting the image to the state saved " "on disk, you will lose all changes, " "including all undo information.")); g_object_set_data (G_OBJECT (image), REVERT_DATA_KEY, dialog); gtk_widget_show (dialog); } }
void on_colordiag_ok_clicked (GtkButton * button, gpointer user_data) { GtkWidget *colorsel, *colorseldiag; GdkColor gdk_color; GtkTreePath *gpath = NULL; GtkTreeViewColumn *gcol = NULL; GtkTreeIter it; gint isadd; EATreePos ep; if (!get_color_store (&ep)) return; colorseldiag = glade_xml_get_widget (appdata.xml, "colorselectiondialog"); isadd = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(colorseldiag), "isadd")); /* gets the row (path) at cursor */ gtk_tree_view_get_cursor (ep.gv, &gpath, &gcol); if (isadd) { if (gpath) { /* row sel, add/change color */ GtkTreeIter itsibling; if (!gtk_tree_model_get_iter (GTK_TREE_MODEL (ep.gs), &itsibling, gpath)) return; /* path not found */ gtk_list_store_insert_before (ep.gs, &it, &itsibling); } else gtk_list_store_append (ep.gs, &it); /* no row selected, append */ } else { if (!gpath || !gtk_tree_model_get_iter(GTK_TREE_MODEL (ep.gs), &it, gpath)) return; /* path not found */ } /* get the selected color */ colorsel = GTK_COLOR_SELECTION_DIALOG (colorseldiag)->colorsel; gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (colorsel), &gdk_color); /* Since we are only going to save 24bit precision, we might as well * make sure we don't display any more than that */ gdk_color.red = (gdk_color.red >> 8) << 8; gdk_color.green = (gdk_color.green >> 8) << 8; gdk_color.blue = (gdk_color.blue >> 8) << 8; /* fill data */ if (isadd) gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color, 2, "", -1); else gtk_list_store_set (ep.gs, &it, 0, COLSPACES, 1, &gdk_color, -1); gtk_widget_hide (colorseldiag); color_list_to_pref (); colors_changed = TRUE; } /* on_colordiag_ok_clicked */
static AtkStateSet * gtk_widget_accessible_ref_state_set (AtkObject *accessible) { GtkWidget *widget; AtkStateSet *state_set; state_set = ATK_OBJECT_CLASS (gtk_widget_accessible_parent_class)->ref_state_set (accessible); widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (accessible)); if (widget == NULL) atk_state_set_add_state (state_set, ATK_STATE_DEFUNCT); else { if (gtk_widget_is_sensitive (widget)) { atk_state_set_add_state (state_set, ATK_STATE_SENSITIVE); atk_state_set_add_state (state_set, ATK_STATE_ENABLED); } if (gtk_widget_get_can_focus (widget)) { atk_state_set_add_state (state_set, ATK_STATE_FOCUSABLE); } /* * We do not currently generate notifications when an ATK object * corresponding to a GtkWidget changes visibility by being scrolled * on or off the screen. The testcase for this is the main window * of the testgtk application in which a set of buttons in a GtkVBox * is in a scrolled window with a viewport. * * To generate the notifications we would need to do the following: * 1) Find the GtkViewport among the ancestors of the objects * 2) Create an accessible for the viewport * 3) Connect to the value-changed signal on the viewport * 4) When the signal is received we need to traverse the children * of the viewport and check whether the children are visible or not * visible; we may want to restrict this to the widgets for which * accessible objects have been created. * 5) We probably need to store a variable on_screen in the * GtkWidgetAccessible data structure so we can determine whether * the value has changed. */ if (gtk_widget_get_visible (widget)) { atk_state_set_add_state (state_set, ATK_STATE_VISIBLE); if (gtk_widget_accessible_on_screen (widget) && gtk_widget_get_mapped (widget) && gtk_widget_accessible_all_parents_visible (widget)) atk_state_set_add_state (state_set, ATK_STATE_SHOWING); } if (gtk_widget_has_focus (widget) && (widget == _focus_widget)) { AtkObject *focus_obj; focus_obj = g_object_get_data (G_OBJECT (accessible), "gail-focus-object"); if (focus_obj == NULL) atk_state_set_add_state (state_set, ATK_STATE_FOCUSED); } if (gtk_widget_has_default (widget)) atk_state_set_add_state (state_set, ATK_STATE_DEFAULT); if (GTK_IS_ORIENTABLE (widget)) { if (gtk_orientable_get_orientation (GTK_ORIENTABLE (widget)) == GTK_ORIENTATION_HORIZONTAL) atk_state_set_add_state (state_set, ATK_STATE_HORIZONTAL); else atk_state_set_add_state (state_set, ATK_STATE_VERTICAL); } } return state_set; }
/* * Set up the airpcap toolbar for the new capture interface */ void airpcap_set_toolbar_start_capture(airpcap_if_info_t* if_info) { GtkWidget *airpcap_toolbar_label; GtkWidget *toolbar_channel_cb; GtkWidget *airpcap_toolbar_channel_lb; GtkWidget *airpcap_toolbar_channel_offset; GtkWidget *airpcap_toolbar_channel_offset_lb; GtkWidget *airpcap_toolbar_button; GtkWidget *airpcap_toolbar_fcs; GtkWidget *airpcap_toolbar_fcs_lb; GtkWidget *airpcap_toolbar_decryption; GtkWidget *airpcap_toolbar_decryption_lb; GtkWidget *airpcap_toolbar_keys_button; gchar *if_label_text; airpcap_toolbar_label = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_INTERFACE_KEY); toolbar_channel_cb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_KEY); airpcap_toolbar_channel_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_LABEL_KEY); airpcap_toolbar_channel_offset = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_KEY); airpcap_toolbar_channel_offset_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_CHANNEL_OFFSET_LABEL_KEY); airpcap_toolbar_fcs = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_KEY); airpcap_toolbar_fcs_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_FCS_FILTER_LABEL_KEY); airpcap_toolbar_button = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_ADVANCED_KEY); airpcap_toolbar_decryption = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY); airpcap_toolbar_decryption_lb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_LABEL_KEY); airpcap_toolbar_keys_button = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_KEY_MANAGEMENT_KEY); /* The current interface is an airpcap interface */ if(if_info != NULL) { gtk_widget_set_sensitive(airpcap_tb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_label,TRUE); gtk_widget_set_sensitive(toolbar_channel_cb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,TRUE); gtk_widget_set_sensitive(airpcap_toolbar_fcs,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_keys_button,FALSE); /*decryption check box*/ g_signal_handlers_block_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, airpcap_tb); if(if_info->DecryptionOn == AIRPCAP_DECRYPTION_ON) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),TRUE); else gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(airpcap_toolbar_decryption),FALSE); g_signal_handlers_unblock_by_func (airpcap_toolbar_decryption,airpcap_toolbar_encryption_cb, airpcap_tb); if_label_text = g_strdup_printf("Current Wireless Interface: #%s", airpcap_get_if_string_number(if_info)); gtk_label_set_text(GTK_LABEL(airpcap_toolbar_label),if_label_text); g_free(if_label_text); change_airpcap_settings = FALSE; if (if_info->pSupportedChannels != NULL && if_info->numSupportedChannels > 0){ guint i = 0; for (; i<if_info->numSupportedChannels; i++){ gtk_combo_box_append_text(GTK_COMBO_BOX(toolbar_channel_cb), ieee80211_mhz_to_str(if_info->pSupportedChannels[i].Frequency)); } } airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cb),if_info); airpcap_update_channel_offset_combo(if_info, if_info->channelInfo.Frequency, airpcap_toolbar_channel_offset, TRUE); change_airpcap_settings = TRUE; } else /* Current interface is NOT an AirPcap one... */ { gtk_widget_set_sensitive(airpcap_tb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_label,FALSE); gtk_widget_set_sensitive(toolbar_channel_cb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_channel_offset_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_fcs_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_button,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_decryption_lb,FALSE); gtk_widget_set_sensitive(airpcap_toolbar_keys_button,FALSE); } }
/** * gnome_popup_menu_attach: * @popup: A menu widget. * @widget: The widget to attach the popup menu to. * @user_data: Application specific data passed to the callback. * * Attaches the specified popup menu to the specified widget. The * menu can then be activated by pressing mouse button 3 over the * widget. When a menu item callback is invoked, the specified * user_data will be passed to it. * * This function requires the widget to have its own window * (i.e. GTK_WIDGET_NO_WINDOW (widget) == FALSE), This function will * try to set the GDK_BUTTON_PRESS_MASK flag on the widget's event * mask if it does not have it yet; if this is the case, then the * widget must not be realized for it to work. * * The popup menu can be attached to different widgets at the same * time. A reference count is kept on the popup menu; when all the * widgets it is attached to are destroyed, the popup menu will be * destroyed as well. * * Under the current implementation, setting a popup menu for a NO_WINDOW * widget and then reparenting that widget will cause Bad Things to happen. */ void gnome_popup_menu_attach (GtkWidget *popup, GtkWidget *widget, gpointer user_data) { GtkWidget *ev_widget; g_return_if_fail (popup != NULL); g_return_if_fail (GTK_IS_MENU (popup)); g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_WIDGET (widget)); if(g_object_get_data (G_OBJECT (widget), "gnome_popup_menu")) return; g_object_set_data (G_OBJECT (widget), "gnome_popup_menu", popup); /* This operation can fail if someone is trying to set a popup on e.g. an uncontained label, so we do it first. */ for(ev_widget = widget; ev_widget && GTK_WIDGET_NO_WINDOW(ev_widget); ev_widget = ev_widget->parent) { g_object_set_data (G_OBJECT (ev_widget), "gnome_popup_menu_nowindow", GUINT_TO_POINTER(1)); } g_return_if_fail (ev_widget); /* Ref/sink the popup menu so that we take "ownership" of it */ g_object_ref (G_OBJECT (popup)); gtk_object_sink (GTK_OBJECT (popup)); /* Store the user data pointer in the widget -- we will use it later when the menu has to be * invoked. */ g_object_set_data (G_OBJECT (widget), "gnome_popup_menu_attach_user_data", user_data); g_object_set_data (G_OBJECT (widget), "gnome_popup_menu", user_data); /* Prepare the widget to accept button presses -- the proper assertions will be * shouted by gtk_widget_set_events(). */ gtk_widget_add_events (ev_widget, GDK_BUTTON_PRESS_MASK | GDK_KEY_PRESS_MASK); g_signal_connect (widget, "button_press_event", G_CALLBACK (popup_button_pressed), popup); g_signal_connect (G_OBJECT (widget), "popup_menu", G_CALLBACK (popup_menu_pressed), popup); if (ev_widget != widget) { GClosure *closure; closure = g_cclosure_new (G_CALLBACK (relay_popup_button_pressed), popup, NULL); g_object_watch_closure (G_OBJECT (widget), closure); g_signal_connect_closure (ev_widget, "button_press_event", closure, FALSE); } /* This callback will unref the popup menu when the widget it is attached to gets destroyed. */ g_signal_connect (widget, "destroy", G_CALLBACK (popup_attach_widget_destroyed), popup); }
static void add_emblems_dialog_response_cb (GtkWidget *dialog, int response, CajaEmblemSidebar *emblem_sidebar) { Emblem *emblem; GSList *emblems; GSList *l; switch (response) { case GTK_RESPONSE_CANCEL: gtk_widget_destroy (dialog); break; case GTK_RESPONSE_HELP: g_message ("Implement me!"); break; case GTK_RESPONSE_OK: emblems = g_object_get_data (G_OBJECT (dialog), "emblems-to-add"); for (l = emblems; l; l = l->next) { char *keyword; emblem = (Emblem *)l->data; if (emblem->keyword != NULL) { /* this one has already been verified */ continue; } keyword = caja_emblem_create_unique_keyword (emblem->name); if (!caja_emblem_verify_keyword (GTK_WINDOW (dialog), keyword, emblem->name)) { g_free (keyword); return; } else { emblem->keyword = keyword; } } for (l = emblems; l; l = l->next) { emblem = (Emblem *)l->data; caja_emblem_install_custom_emblem (emblem->pixbuf, emblem->keyword, emblem->name, GTK_WINDOW (dialog)); } gtk_widget_destroy (dialog); send_emblems_changed (); break; } }
void change_surface_type_event(GtkToggleButton *button, SurfaceDialog* dialog){ int btnId = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "ID")); ObjType type = (ObjType) btnId; dialog->setSurfaceType(type); }
/* When selecting user specified range, then focus on the entry */ if (range->process == range_process_user_range) gtk_widget_grab_focus(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_ENTRY_KEY)); } static void range_entry(GtkWidget *widget _U_, gpointer data) { const gchar *entry_text; GtkWidget *entry; packet_range_t *range; range = g_object_get_data(G_OBJECT(data), RANGE_VALUES_KEY); entry = g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_ENTRY_KEY); gtk_toggle_button_set_active(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_KEY), TRUE); entry_text = gtk_entry_get_text (GTK_ENTRY (entry)); packet_range_convert_str(range, entry_text); range_update_dynamics(data); } static void range_entry_in_event(GtkWidget *widget _U_, GdkEventFocus *event _U_, gpointer user_data _U_) { /* This event is called, if the "enter" key is pressed while the key focus (right name?) */ /* is in the range entry field. */
/* update all "dynamic" things */ void range_update_dynamics(gpointer data) { packet_range_t *range; GtkWidget *range_displayed_bt; gboolean filtered_active; gint selected_num; gboolean can_select; gchar label_text[100]; range = g_object_get_data(G_OBJECT(data), RANGE_VALUES_KEY); range_displayed_bt = g_object_get_data(G_OBJECT(data), RANGE_DISPLAYED_BT_KEY); filtered_active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(range_displayed_bt)); /* Enable saving only the displayed packets only if there *are* displayed packets. */ if (range->displayed_cnt != 0) gtk_widget_set_sensitive(range_displayed_bt, TRUE); else { /* If saving the displayed packets is selected, select saving the captured packets. */ filtered_active = FALSE; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), FALSE); gtk_widget_set_sensitive(range_displayed_bt, FALSE); } gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_C_KEY), !filtered_active); g_snprintf(label_text, sizeof(label_text), "%u", cfile.count); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_C_KEY)), label_text); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_D_KEY), filtered_active); g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_D_KEY)), label_text); /* Enable saving the currently-selected packet only if there *is* a currently-selected packet. */ selected_num = (cfile.current_frame) ? cfile.current_frame->num : 0; can_select = (selected_num != 0); if (can_select) { gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_KEY), TRUE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY), !filtered_active); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY), filtered_active); } else { /* If "save selected packet" is selected, select "save all packets". */ if (range->process == range_process_selected) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY), FALSE); } /* XXX: how to update the radio button label but keep the mnemonic? */ /*g_snprintf(label_text, sizeof(label_text), "_Selected packet #%u only", selected_num); gtk_label_set_text(GTK_LABEL(GTK_BIN(select_curr_rb)->child), label_text);*/ g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_C_KEY)), label_text); g_snprintf(label_text, sizeof(label_text), "%u", selected_num ? 1 : 0); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_CURR_D_KEY)), label_text); /* Enable the buttons for saving marked packets only if there *are* marked packets. */ if (filtered_active) can_select = (range->displayed_marked_cnt != 0); else can_select = (cfile.marked_count > 0); if (can_select) { gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_KEY), TRUE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY), !filtered_active); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY), filtered_active); } else { /* If "save marked packet" is selected, select "save all packets". */ if (range->process == range_process_marked) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY), FALSE); } g_snprintf(label_text, sizeof(label_text), "%u", cfile.marked_count); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_C_KEY)), label_text); g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_marked_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_D_KEY)), label_text); /* Enable the buttons for saving the range of marked packets only if there *is* a range of marked packets. */ if (filtered_active) can_select = (range->displayed_mark_range_cnt != 0); else can_select = (range->mark_range_cnt != 0); if (can_select) { gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_KEY), TRUE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY), !filtered_active); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY), filtered_active); } else { /* If "save range between first and last marked packet" is selected, select "save all packets". */ if (range->process == range_process_marked_range) { range->process = range_process_all; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(g_object_get_data(G_OBJECT(data), RANGE_SELECT_ALL_KEY)), TRUE); } gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY), FALSE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY), FALSE); } g_snprintf(label_text, sizeof(label_text), "%u", range->mark_range_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_C_KEY)), label_text); g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_mark_range_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_MARKED_RANGE_D_KEY)), label_text); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_KEY), TRUE); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_C_KEY), !filtered_active); gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_D_KEY), filtered_active); g_snprintf(label_text, sizeof(label_text), "%u", range->user_range_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_C_KEY)), label_text); g_snprintf(label_text, sizeof(label_text), "%u", range->displayed_user_range_cnt); gtk_label_set_text(GTK_LABEL(g_object_get_data(G_OBJECT(data), RANGE_SELECT_USER_D_KEY)), label_text); }
static void request_fields_cb(GntWidget *button, PurpleRequestFields *fields) { PurpleRequestFieldsCb callback = g_object_get_data(G_OBJECT(button), "activate-callback"); gpointer data = g_object_get_data(G_OBJECT(button), "activate-userdata"); GList *list; /* Update the data of the fields. Pidgin does this differently. Instead of * updating the fields at the end like here, it updates the appropriate field * instantly whenever a change is made. That allows it to make sure the * 'required' fields are entered before the user can hit OK. It's not the case * here, althought it can be done. */ for (list = purple_request_fields_get_groups(fields); list; list = list->next) { PurpleRequestFieldGroup *group = list->data; GList *fields = purple_request_field_group_get_fields(group); for (; fields ; fields = fields->next) { PurpleRequestField *field = fields->data; PurpleRequestFieldType type = purple_request_field_get_type(field); if (type == PURPLE_REQUEST_FIELD_BOOLEAN) { GntWidget *check = FINCH_GET_DATA(field); gboolean value = gnt_check_box_get_checked(GNT_CHECK_BOX(check)); purple_request_field_bool_set_value(field, value); } else if (type == PURPLE_REQUEST_FIELD_STRING) { GntWidget *entry = FINCH_GET_DATA(field); const char *text = gnt_entry_get_text(GNT_ENTRY(entry)); purple_request_field_string_set_value(field, (text && *text) ? text : NULL); } else if (type == PURPLE_REQUEST_FIELD_INTEGER) { GntWidget *entry = FINCH_GET_DATA(field); const char *text = gnt_entry_get_text(GNT_ENTRY(entry)); int value = (text && *text) ? atoi(text) : 0; purple_request_field_int_set_value(field, value); } else if (type == PURPLE_REQUEST_FIELD_CHOICE) { GntWidget *combo = FINCH_GET_DATA(field); int id; id = GPOINTER_TO_INT(gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo))); purple_request_field_choice_set_value(field, id); } else if (type == PURPLE_REQUEST_FIELD_LIST) { GList *list = NULL; if (purple_request_field_list_get_multi_select(field)) { GList *iter; GntWidget *tree = FINCH_GET_DATA(field); iter = purple_request_field_list_get_items(field); for (; iter; iter = iter->next) { const char *text = iter->data; gpointer key = purple_request_field_list_get_data(field, text); if (gnt_tree_get_choice(GNT_TREE(tree), key)) list = g_list_prepend(list, key); } } else { GntWidget *combo = FINCH_GET_DATA(field); gpointer data = gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo)); list = g_list_append(list, data); } purple_request_field_list_set_selected(field, list); g_list_free(list); } else if (type == PURPLE_REQUEST_FIELD_ACCOUNT) { GntWidget *combo = FINCH_GET_DATA(field); PurpleAccount *acc = gnt_combo_box_get_selected_data(GNT_COMBO_BOX(combo)); purple_request_field_account_set_value(field, acc); } } } purple_notify_close_with_handle(button); if (!g_object_get_data(G_OBJECT(button), "cancellation-function") && !purple_request_fields_all_required_filled(fields)) { purple_notify_error(button, _("Error"), _("You must fill all the required fields."), _("The required fields are underlined.")); return; } if (callback) callback(data, fields); while (button->parent) button = button->parent; purple_request_close(PURPLE_REQUEST_FIELDS, button); }
void bmd_cell_edited (GtkCellRendererText *cell, const gchar *path_string, const gchar *new_text, gpointer data) { GtkTreeModel *model = (GtkTreeModel *) data; GtkTreePath *path = gtk_tree_path_new_from_string (path_string); GtkTreeIter iter; gint column = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (cell), "column")); gtk_tree_model_get_iter (model, &iter, path); switch (column) { case COLUMN_ITEM_NUMBER: { gint i; i = gtk_tree_path_get_indices (path) [0]; g_array_index (articles, Item, i).number = atoi (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).number, -1); } break; case COLUMN_ITEM_TITLE: { gint i; gchar *old_text; gtk_tree_model_get (model, &iter, column, &old_text, -1); g_free (old_text); i = gtk_tree_path_get_indices (path) [0]; g_free (g_array_index (articles, Item, i).title); g_array_index (articles, Item, i).title = g_strdup (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).title, -1); } break; case COLUMN_ITEM_AUTHOR: { gint i; gchar *old_text; gtk_tree_model_get (model, &iter, column, &old_text, -1); g_free (old_text); i = gtk_tree_path_get_indices (path) [0]; g_free (g_array_index (articles, Item, i).author); g_array_index (articles, Item, i).author = g_strdup (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).author, -1); } break; case COLUMN_ITEM_PAGES: { gint i; i = gtk_tree_path_get_indices (path) [0]; g_array_index (articles, Item, i).pages = atoi (new_text); gtk_list_store_set (GTK_LIST_STORE (model), &iter, column, g_array_index (articles, Item, i).pages, -1); } break; } gtk_tree_path_free (path); }
static gint process_event (GtkWidget *widget, GdkEvent *event, gpointer data G_GNUC_UNUSED) { static GtkWidget *original_widget = NULL; static GdkCursor *cursor = NULL; switch (event->type) { case GDK_BUTTON_PRESS: if (event->button.button != gstroke_get_mouse_button()) { /* Similar to the bug below catch when any other button is * clicked after the middle button is clicked (but possibly * not released) */ gstroke_cancel(event); original_widget = NULL; break; } original_widget = widget; /* remeber the widget where the stroke started */ gstroke_invisible_window_init (widget); record_stroke_segment (widget); if (cursor == NULL) cursor = gdk_cursor_new(GDK_PENCIL); gdk_pointer_grab (widget->window, FALSE, GDK_BUTTON_RELEASE_MASK, NULL, cursor, event->button.time); timer_id = g_timeout_add (GSTROKE_TIMEOUT_DURATION, gstroke_timeout, widget); return TRUE; case GDK_BUTTON_RELEASE: if ((event->button.button != gstroke_get_mouse_button()) || (original_widget == NULL)) { /* Nice bug when you hold down one button and press another. */ /* We'll just cancel the gesture instead. */ gstroke_cancel(event); original_widget = NULL; break; } last_mouse_position.invalid = TRUE; original_widget = NULL; g_source_remove (timer_id); gdk_pointer_ungrab (event->button.time); timer_id = 0; { char result[GSTROKE_MAX_SEQUENCE]; struct gstroke_metrics *metrics; metrics = (struct gstroke_metrics *)g_object_get_data(G_OBJECT (widget), GSTROKE_METRICS); if (gstroke_draw_strokes()) { /* get rid of the invisible stroke window */ XUnmapWindow (gstroke_disp, gstroke_window); XFlush (gstroke_disp); } _gstroke_canonical (result, metrics); gstroke_execute (widget, result); return FALSE; } return TRUE; default: break; } return FALSE; }
/** * Clear the text from the text page. */ static void text_page_clear(GtkWidget *page) { GtkTextBuffer *buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(g_object_get_data(G_OBJECT(page), TEXT_KEY))); gtk_text_buffer_set_text(buf, "", 0); }
void change_alg_event(GtkToggleButton *button, MainWindow* window){ int btnId = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(button), "ID")); LineClipAlgs alg = (LineClipAlgs) btnId; window->changeLineClipAlg(alg); }
static guint get_rows (GtkTreeView *treeview) { return GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (treeview), "rows")); }
void dev_select_rescan(GtkAction *action, GtkWindow *parent) { GtkComboBox *devbox = g_object_get_data(G_OBJECT(parent), "devcombo"); g_return_if_fail(devbox != NULL); GtkListStore *devlist = GTK_LIST_STORE(gtk_combo_box_get_model(devbox)); GtkTreeIter iter; struct sr_dev *dev; const struct sr_dev_inst *sdi; gchar *sdevname = NULL; GSList *devs, *l; GtkUIManager *ui = g_object_get_data(G_OBJECT(parent), "ui_manager"); GtkWidget *menuitem = gtk_ui_manager_get_widget(ui, "/menubar/DevMenu/DevSelectMenu"); GtkMenuShell *devmenu = GTK_MENU_SHELL(gtk_menu_item_get_submenu(GTK_MENU_ITEM(menuitem))); GSList *radiolist = NULL; (void)action; /* Make a copy of the selected device's short name for comparison. * We wish to select the same device after the refresh if possible. */ if (gtk_combo_box_get_active_iter(devbox, &iter)) { gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 1, &dev, -1); /* FIXME: Use something other than dev->driver->name */ sdevname = g_strdup(dev->driver->name); } /* Destroy the old menu items */ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) do { GtkMenuItem *item; gtk_tree_model_get(GTK_TREE_MODEL(devlist), &iter, 2, &item, -1); gtk_object_destroy(GTK_OBJECT(item)); } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter)); gtk_list_store_clear(devlist); /* Scan for new devices and update our list */ /* TODO: Fix this in libsigrok first. */ /*sr_dev_scan();*/ devs = sr_dev_list(); for (l = devs; l; l = l->next) { dev = l->data; sdi = GET_DEV_INST(dev); gchar *name = sdi->model ? sdi->model : sdi->vendor; if (!name) name = "(unknown)"; menuitem = gtk_radio_menu_item_new_with_label(radiolist, name); gtk_widget_show(GTK_WIDGET(menuitem)); if (!radiolist) radiolist = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(menuitem)); g_signal_connect(menuitem, "toggled", G_CALLBACK(dev_menuitem_toggled), devbox); gtk_menu_shell_prepend(devmenu, menuitem); gtk_list_store_append(devlist, &iter); gtk_list_store_set(devlist, &iter, 0, name, 1, dev, 2, menuitem, -1); if (sdevname && g_str_equal(sdevname, dev->driver->name)) gtk_combo_box_set_active_iter(devbox, &iter); } if (sdevname) g_free(sdevname); /* Select a default if nothing selected */ if (!gtk_combo_box_get_active_iter(devbox, &iter)) { if (!gtk_tree_model_get_iter_first(GTK_TREE_MODEL(devlist), &iter)) return; /* Skip demo if there's another available */ GtkTreeIter first = iter; if (gtk_tree_model_iter_next(GTK_TREE_MODEL(devlist), &iter)) gtk_combo_box_set_active_iter(devbox, &iter); else gtk_combo_box_set_active_iter(devbox, &first); } }
static void plugins_combo_changed_cb (GtkComboBox *combo, TablePreferences *tpref) { GtkTreeIter iter; GtkWidget *old_options = NULL; if (tpref->priv->options_wid) { old_options = tpref->priv->options_wid; tpref->priv->options_wid = NULL; } if (gtk_combo_box_get_active_iter (combo, &iter)) { GdauiPlugin *plugin; GtkTreeModel *model; GError *error = NULL; model = gtk_combo_box_get_model (combo); gtk_tree_model_get (model, &iter, PL_COLUMN_PLUGIN, &plugin, -1); if (plugin && plugin->options_xml_spec) { GdaSet *plist; plist = gda_set_new_from_spec_string (plugin->options_xml_spec, &error); if (!plist) { g_warning ("Cannot parse XML spec for plugin options: %s", error && error->message ? error->message : "No detail"); g_clear_error (&error); } else { if (!old_options || (g_object_get_data (G_OBJECT (old_options), "plugin") != plugin)) { tpref->priv->options_wid = gdaui_basic_form_new (plist); g_object_set_data (G_OBJECT (tpref->priv->options_wid), "plugin", plugin); g_signal_connect (G_OBJECT (tpref->priv->options_wid), "holder-changed", G_CALLBACK (options_form_param_changed_cb), tpref); gtk_box_pack_start (GTK_BOX (tpref->priv->options_vbox), tpref->priv->options_wid, TRUE, TRUE, 0); } else { tpref->priv->options_wid = old_options; old_options = NULL; } g_object_unref (plist); } if (tpref->priv->options_wid) { plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid)); gtk_widget_hide (tpref->priv->options_none); gtk_widget_show (tpref->priv->options_wid); if (plist && !tpref->priv->save_plugin_changes) { /* load plugin options */ GtkTreeSelection *select; GtkTreeIter citer; select = gtk_tree_view_get_selection (tpref->priv->columns_treeview); if (gtk_tree_selection_get_selected (select, NULL, &citer)) { gchar *plugin_str; gtk_tree_model_get (GTK_TREE_MODEL (tpref->priv->columns_store), &citer, COLUMN_PLUGIN, &plugin_str, -1); /*g_print ("%p PLUGIN_STR:[%s]\n", tpref, plugin_str);*/ if (plugin_str) { GdaQuarkList *ql; GSList *list; gchar *tmp; for (tmp = plugin_str; *tmp && (*tmp != ':'); tmp++); if (*tmp == ':') { ql = gda_quark_list_new_from_string (tmp+1); for (list = plist->holders; list; list = list->next) { GdaHolder *holder = GDA_HOLDER (list->data); const gchar *cstr; cstr = gda_quark_list_find (ql, gda_holder_get_id (holder)); if (cstr) gda_holder_set_value_str (holder, NULL, cstr, NULL); else gda_holder_set_value (holder, NULL, NULL); } gda_quark_list_free (ql); } g_free (plugin_str); } } } } } if (tpref->priv->save_plugin_changes && tpref->priv->current_table && tpref->priv->current_column && ! t_connection_set_table_column_attribute (tpref->priv->tcnc, tpref->priv->current_table, tpref->priv->current_column, T_CONNECTION_COLUMN_PLUGIN, plugin ? plugin->plugin_name : NULL, &error)) { TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */ g_warning ("Error: %s\n", error && error->message ? error->message : _("No detail")); g_clear_error (&error); } set_preview_widget (tpref); } if (old_options) gtk_widget_destroy (old_options); if (! tpref->priv->options_wid) gtk_widget_show (tpref->priv->options_none); }
static MMModem * grab_port (MMPluginBase *base, MMModem *existing, MMPluginBaseSupportsTask *task, GError **error) { GUdevDevice *port = NULL; MMModem *modem = NULL; const char *name, *subsys, *devfile, *sysfs_path; guint32 caps; guint16 vendor = 0, product = 0; MMPortType ptype; int usbif; MMAtPortFlags pflags = MM_AT_PORT_FLAG_NONE; port = mm_plugin_base_supports_task_get_port (task); g_assert (port); devfile = g_udev_device_get_device_file (port); if (!devfile) { g_set_error (error, 0, 0, "Could not get port's sysfs file."); return NULL; } subsys = g_udev_device_get_subsystem (port); name = g_udev_device_get_name (port); if (!mm_plugin_base_get_device_ids (base, subsys, name, &vendor, &product)) { g_set_error (error, 0, 0, "Could not get modem product ID."); return NULL; } usbif = g_udev_device_get_property_as_int (port, "ID_USB_INTERFACE_NUM"); if (usbif < 0) { g_set_error (error, 0, 0, "Could not get USB device interface number."); return NULL; } caps = mm_plugin_base_supports_task_get_probed_capabilities (task); ptype = mm_plugin_base_probed_capabilities_to_port_type (caps); if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (base), TAG_HUAWEI_PCUI_PORT))) pflags = MM_AT_PORT_FLAG_PRIMARY; else if (usbif + 1 == GPOINTER_TO_INT (g_object_get_data (G_OBJECT (base), TAG_HUAWEI_MODEM_PORT))) pflags = MM_AT_PORT_FLAG_PPP; else if (!g_object_get_data (G_OBJECT (base), TAG_GETPORTMODE_SUPPORTED)) { /* If GETPORTMODE is not supported, we assume usbif 0 is the modem port */ if ((usbif == 0) && (ptype == MM_PORT_TYPE_AT)) { pflags = MM_AT_PORT_FLAG_PPP; /* For CDMA modems we assume usbif0 is both primary and PPP, since * they don't have problems with talking on secondary ports. */ if (caps & CAP_CDMA) pflags |= MM_AT_PORT_FLAG_PRIMARY; } } sysfs_path = mm_plugin_base_supports_task_get_physdev_path (task); if (!existing) { if (caps & MM_PLUGIN_BASE_PORT_CAP_GSM) { modem = mm_modem_huawei_gsm_new (sysfs_path, mm_plugin_base_supports_task_get_driver (task), mm_plugin_get_name (MM_PLUGIN (base)), vendor, product); } else if (caps & CAP_CDMA) { modem = mm_modem_huawei_cdma_new (sysfs_path, mm_plugin_base_supports_task_get_driver (task), mm_plugin_get_name (MM_PLUGIN (base)), !!(caps & MM_PLUGIN_BASE_PORT_CAP_IS856), !!(caps & MM_PLUGIN_BASE_PORT_CAP_IS856_A), vendor, product); } if (modem) { if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error)) { g_object_unref (modem); return NULL; } } } else { modem = existing; if (!mm_modem_grab_port (modem, subsys, name, ptype, pflags, NULL, error)) return NULL; } return modem; }
static GtkWidget* get_toplevel(GtkWidget* menuitem) { return g_object_get_data (G_OBJECT (menuitem), TOPLEVEL_MENUSHELL_KEY); }
void widget_progressbar_refresh(variable *var) { GList *element; gchar *act; gint initialised = FALSE; #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Entering.\n", __func__); #endif /* Get initialised state of widget */ if (g_object_get_data(G_OBJECT(var->Widget), "_initialised") != NULL) initialised = (gint)g_object_get_data(G_OBJECT(var->Widget), "_initialised"); /* The <input> tag... */ act = attributeset_get_first(&element, var->Attributes, ATTR_INPUT); while (act) { if (input_is_shell_command(act)) widget_progressbar_input_by_command(var, act + 8); /* input file stock = "File:", input file = "File:/path/to/file" */ if (strncasecmp(act, "file:", 5) == 0 && strlen(act) > 5) { widget_progressbar_input_by_file(var, act + 5); } act = attributeset_get_next(&element, var->Attributes, ATTR_INPUT); } /* The <item> tags... */ if (attributeset_is_avail(var->Attributes, ATTR_ITEM)) widget_progressbar_input_by_items(var); /* Initialise these only once at start-up */ if (!initialised) { /* Apply directives */ if (attributeset_is_avail(var->Attributes, ATTR_DEFAULT)) fprintf(stderr, "%s(): <default> not implemented for this widget.\n", __func__); if (attributeset_is_avail(var->Attributes, ATTR_HEIGHT)) fprintf(stderr, "%s(): <height> not implemented for this widget.\n", __func__); if (attributeset_is_avail(var->Attributes, ATTR_WIDTH)) fprintf(stderr, "%s(): <width> not implemented for this widget.\n", __func__); if ((attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "false")) || (attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "disabled")) || /* Deprecated */ (attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "no")) || (attributeset_cmp_left(var->Attributes, ATTR_SENSITIVE, "0"))) gtk_widget_set_sensitive(var->Widget, FALSE); /* Connect signals */ /* Thunor: This is all original code moved across when refactoring */ /* We start the input command in a separate thread when the * widget gets realized */ g_signal_connect(G_OBJECT(var->Widget), "realize", G_CALLBACK(widget_progressbar_realized_callback), (gpointer)var->Attributes); } #ifdef DEBUG_TRANSITS fprintf(stderr, "%s(): Exiting.\n", __func__); #endif }
void linphone_gtk_push_text(GtkWidget *w, const LinphoneAddress *from, gboolean me,LinphoneChatRoom *cr,LinphoneChatMessage *msg, gboolean hist){ GtkTextView *text=GTK_TEXT_VIEW(linphone_gtk_get_widget(w,"textview")); GtkTextBuffer *buffer=gtk_text_view_get_buffer(text); GtkTextIter iter; char *from_str=linphone_address_as_string_uri_only(from); gchar *from_message=(gchar *)g_object_get_data(G_OBJECT(w),"from_message"); GHashTable *table=(GHashTable*)g_object_get_data(G_OBJECT(w),"table"); const GRegex *uri_regex = get_uri_regex(); GMatchInfo *match_info = NULL; const char *message = linphone_chat_message_get_text(msg); time_t t; char buf[80]; time_t tnow; struct tm *tm; int tnow_day; int tnow_year; int pos = 0, start, end; gtk_text_buffer_get_end_iter(buffer, &iter); if (g_strcmp0(from_message,from_str)!=0){ gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, get_display_name(from), -1, "from", me ? "me" : NULL, NULL); gtk_text_buffer_insert_with_tags_by_name(buffer,&iter, " : ", -1, "from", me ? "me" : NULL, NULL); gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_free(from_message); g_object_set_data(G_OBJECT(w),"from_message",g_strdup(from_str)); } ms_free(from_str); // Inserts message body and tags URIs as hypertext links if(message) { g_regex_match(uri_regex, message, 0, &match_info); while(g_match_info_matches(match_info)) { g_match_info_fetch_pos(match_info, 0, &start, &end); if(pos < start) write_body(buffer, &iter, &message[pos], start-pos, me, FALSE); write_body(buffer, &iter, &message[start], end-start, me, TRUE); pos = end; g_match_info_next(match_info, NULL); } if(pos < strlen(message)) write_body(buffer, &iter, &message[pos], -1, me, FALSE); gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_match_info_free(match_info); } t=linphone_chat_message_get_time(msg); switch (linphone_chat_message_get_state (msg)){ case LinphoneChatMessageStateInProgress: g_hash_table_insert(table,(gpointer)msg,GINT_TO_POINTER(gtk_text_iter_get_line(&iter))); gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1, "status", me ? "me" : NULL, NULL); //g_object_set_data(G_OBJECT(w),"table",table); break; case LinphoneChatMessageStateDelivered: tnow=time(NULL); tm=localtime(&tnow); tnow_day=tm->tm_yday; tnow_year=tm->tm_year; tm=localtime(&t); if(tnow_day != tm->tm_yday || (tnow_day == tm->tm_yday && tnow_year != tm->tm_year)) { strftime(buf,80,"%a %x, %H:%M",tm); } else { strftime(buf,80,"%H:%M",tm); } gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,buf,-1, "status", me ? "me" : NULL, NULL); break; case LinphoneChatMessageStateNotDelivered: gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Message not sent",-1, "status", me ? "me" : NULL, NULL); break; default : gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1, "status", me ? "me" : NULL, NULL); } gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_idle_add((GSourceFunc)scroll_to_end,text); }
gboolean simple_dialog_check_get(gpointer dialog) { GtkWidget *ask_cb = (GtkWidget *)g_object_get_data(G_OBJECT(GTK_WIDGET(dialog)), CHECK_BUTTON); return gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ask_cb)); }
/* * Note that this is called every time the user clicks on an item, * whether it is already selected or not. */ static void field_select_row_cb(GtkTreeSelection *sel, gpointer tree) { GtkWidget *window = (GtkWidget *)gtk_widget_get_toplevel((GtkWidget *)tree); GtkWidget *relation_list = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RELATION_LIST_KEY); GtkWidget *range_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_LABEL_KEY); GtkWidget *range_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_RANGE_ENTRY_KEY); GtkWidget *value_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LABEL_KEY); GtkWidget *value_entry = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_ENTRY_KEY); GtkWidget *value_list_label = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_LABEL_KEY); GtkWidget *value_list = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_KEY); GtkWidget *value_list_scrolled_win = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_VALUE_LIST_SW_KEY); GtkWidget *ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_OK_BT_KEY); header_field_info *hfinfo, *cur_hfinfo; const char *value_type; char value_label_string[1024+1]; /* XXX - should be large enough */ GtkTreeModel *model; GtkTreeIter iter; if (!gtk_tree_selection_get_selected(sel, &model, &iter)) return; gtk_tree_model_get(model, &iter, 0, &hfinfo, -1); /* * What was the item that was last selected? */ cur_hfinfo = (header_field_info *)g_object_get_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY); if (cur_hfinfo == hfinfo) { /* * It's still selected; no need to change anything. */ return; } /* * Mark it as currently selected. */ g_object_set_data(G_OBJECT(window), E_DFILTER_EXPR_CURRENT_VAR_KEY, hfinfo); show_relations(relation_list, hfinfo->type); /* * Set the label for the value to indicate what type of value * it is. */ value_type = ftype_pretty_name(hfinfo->type); if (value_type != NULL) { /* * Indicate what type of value it is. */ g_snprintf(value_label_string, sizeof value_label_string, "Value (%s)", value_type); gtk_label_set_text(GTK_LABEL(value_label), value_label_string); } /* * Clear the entry widget for the value, as whatever * was there before doesn't apply. */ gtk_entry_set_text(GTK_ENTRY(value_entry), ""); switch (hfinfo->type) { case FT_BOOLEAN: /* * The list of values should be the strings for "true" * and "false"; show them in the value list. */ build_boolean_values(value_list_scrolled_win, value_list, (const true_false_string *)hfinfo->strings); break; case FT_UINT8: case FT_UINT16: case FT_UINT24: case FT_UINT32: case FT_INT8: case FT_INT16: case FT_INT24: case FT_INT32: /* * If this has a value_string table (not a range_string table) associated with it, * fill up the list of values, otherwise clear the list of values. */ /* XXX: ToDo: Implement "range-string" filter ? */ if ((hfinfo->strings != NULL) && ! (hfinfo->display & BASE_RANGE_STRING) && ! (hfinfo->display & BASE_VAL64_STRING) && ! ((hfinfo->display & FIELD_DISPLAY_E_MASK) == BASE_CUSTOM)) { const value_string *vals = (const value_string *)hfinfo->strings; if (hfinfo->display & BASE_EXT_STRING) vals = VALUE_STRING_EXT_VS_P((value_string_ext *)vals); build_enum_values(value_list_scrolled_win, value_list, vals); } else gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)))); break; default: /* * Clear the list of values. */ gtk_list_store_clear(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(value_list)))); break; } /* * Display various items for the value, as appropriate. * The relation we start out with is never a comparison. */ display_value_fields(hfinfo, FALSE, value_label, value_entry, value_list_label, value_list, value_list_scrolled_win, range_label, range_entry); /* * XXX - in browse mode, there always has to be something * selected, so this should always be sensitive. */ gtk_widget_set_sensitive(ok_bt, TRUE); }
static GtkWidget * display_simple_dialog(gint type, gint btn_mask, char *message) { GtkWidget *win, *main_vb, *top_hb, *msg_vb, *type_pm, *msg_label, *ask_cb, *bbox, *ok_bt, *yes_bt, *bt, *save_bt, *dont_save_bt; /* Main window */ switch (type) { case ESD_TYPE_WARN : type_pm = ws_gtk_image_new_from_stock( GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); break; case ESD_TYPE_CONFIRMATION: type_pm = ws_gtk_image_new_from_stock( GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG); break; case ESD_TYPE_ERROR: type_pm = ws_gtk_image_new_from_stock( GTK_STOCK_DIALOG_ERROR, GTK_ICON_SIZE_DIALOG); break; case ESD_TYPE_STOP : type_pm = ws_gtk_image_new_from_stock( GTK_STOCK_STOP, GTK_ICON_SIZE_DIALOG); break; case ESD_TYPE_INFO : default : type_pm = ws_gtk_image_new_from_stock( GTK_STOCK_DIALOG_INFO, GTK_ICON_SIZE_DIALOG); break; } /* * The GNOME HIG: * * http://developer.gnome.org/projects/gup/hig/1.0/windows.html#alert-windows * * says that the title should be empty for alert boxes, so there's "less * visual noise and confounding text." * * The Windows HIG: * * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnwue/html/ch09f.asp * * says it should * * ...appropriately identify the source of the message -- usually * the name of the object. For example, if the message results * from editing a document, the title text is the name of the * document, optionally followed by the application name. If the * message results from a non-document object, then use the * application name." * * and notes that the title is important "because message boxes might * not always the the result of current user interaction" (e.g., some * app might randomly pop something up, e.g. some browser letting you * know that it couldn't fetch something because of a timeout). * * It also says not to use "warning" or "caution", as there's already * an icon that tells you what type of alert it is, and that you * shouldn't say "error", as that provides no useful information. * * So we give it a title on Win32, and don't give it one on UN*X. * For now, we give it a Win32 title of just "Wireshark"; we should * arguably take an argument for the title. */ if(btn_mask == ESD_BTN_NONE) { win = splash_window_new(); } else { #ifdef _WIN32 win = dlg_window_new("Wireshark"); #else win = dlg_window_new(""); #endif } gtk_window_set_modal(GTK_WINDOW(win), TRUE); gtk_container_set_border_width(GTK_CONTAINER(win), 6); /* Container for our rows */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE); gtk_container_add(GTK_CONTAINER(win), main_vb); gtk_widget_show(main_vb); /* Top row: Icon and message text */ top_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 6); gtk_box_pack_start(GTK_BOX(main_vb), top_hb, TRUE, TRUE, 0); gtk_widget_show(top_hb); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_box_pack_start(GTK_BOX(top_hb), type_pm, TRUE, TRUE, 0); gtk_widget_show(type_pm); /* column for message and optional check button */ msg_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE); gtk_box_set_spacing(GTK_BOX(msg_vb), 24); gtk_box_pack_start(GTK_BOX(top_hb), msg_vb, TRUE, TRUE, 0); gtk_widget_show(msg_vb); /* message */ msg_label = gtk_label_new(message); gtk_label_set_markup(GTK_LABEL(msg_label), message); gtk_label_set_selectable(GTK_LABEL(msg_label), TRUE); g_object_set(gtk_widget_get_settings(msg_label), "gtk-label-select-on-focus", FALSE, NULL); gtk_label_set_justify(GTK_LABEL(msg_label), GTK_JUSTIFY_FILL); gtk_misc_set_alignment (GTK_MISC (type_pm), 0.5f, 0.0f); gtk_box_pack_start(GTK_BOX(msg_vb), msg_label, TRUE, TRUE, 0); gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE); gtk_widget_show(msg_label); if(btn_mask == ESD_BTN_NONE) { gtk_widget_show(win); return win; } /* optional check button */ ask_cb = gtk_check_button_new_with_label("replace with text..."); gtk_box_pack_start(GTK_BOX(msg_vb), ask_cb, TRUE, TRUE, 0); g_object_set_data(G_OBJECT(win), CHECK_BUTTON, ask_cb); /* Button row */ switch(btn_mask) { case(ESD_BTN_OK): bbox = dlg_button_row_new(GTK_STOCK_OK, NULL); break; case(ESD_BTN_OK | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTN_CLEAR | ESD_BTN_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_CLEAR, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_DONTSAVE): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, NULL); break; case(ESD_BTNS_SAVE_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL): bbox = dlg_button_row_new(GTK_STOCK_SAVE, WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case (ESD_BTNS_QUIT_DONTSAVE_CANCEL): bbox = dlg_button_row_new(WIRESHARK_STOCK_QUIT_DONT_SAVE, GTK_STOCK_CANCEL, NULL); break; case(ESD_BTNS_YES_NO): bbox = dlg_button_row_new(GTK_STOCK_YES, GTK_STOCK_NO, NULL); break; default: g_assert_not_reached(); bbox = NULL; break; } gtk_box_pack_start(GTK_BOX(main_vb), bbox, TRUE, TRUE, 0); gtk_widget_show(bbox); ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK); if(ok_bt) { g_object_set_data(G_OBJECT(ok_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_OK)); g_signal_connect(ok_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE); if (save_bt) { g_object_set_data(G_OBJECT(save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_SAVE)); g_signal_connect(save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } dont_save_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_QUIT_DONT_SAVE); if (dont_save_bt) { g_object_set_data(G_OBJECT(dont_save_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_QUIT_DONT_SAVE)); g_signal_connect(dont_save_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLEAR); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CLEAR)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } yes_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_YES); if(yes_bt) { g_object_set_data(G_OBJECT(yes_bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_YES)); g_signal_connect(yes_bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_NO); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_NO)); g_signal_connect(bt, "clicked", G_CALLBACK(simple_dialog_cancel_cb), win); } bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL); if(bt) { g_object_set_data(G_OBJECT(bt), CALLBACK_BTN_KEY, GINT_TO_POINTER(ESD_BTN_CANCEL)); window_set_cancel_button(win, bt, simple_dialog_cancel_cb); } if(!bt) { if(yes_bt) { window_set_cancel_button(win, yes_bt, simple_dialog_cancel_cb); } else if (ok_bt) { window_set_cancel_button(win, ok_bt, simple_dialog_cancel_cb); } } dlg_button_focus_nth(bbox, 0); gtk_widget_show(win); return win; }
GtkWidget *GetDlgWidget( const char* name ) { return GTK_WIDGET( g_object_get_data( G_OBJECT( SurfaceInspector ), name ) ); }
void gimp_enum_radio_frame_add (GtkFrame *frame, GtkWidget *widget, gint enum_value) { GtkWidget *vbox; GList *children; GList *list; gint pos; g_return_if_fail (GTK_IS_FRAME (frame)); g_return_if_fail (GTK_IS_WIDGET (widget)); vbox = gtk_bin_get_child (GTK_BIN (frame)); g_return_if_fail (GTK_IS_VBOX (vbox)); children = gtk_container_get_children (GTK_CONTAINER (vbox)); for (list = children, pos = 1; list; list = g_list_next (list), pos++) { if (GTK_IS_RADIO_BUTTON (list->data) && GPOINTER_TO_INT (g_object_get_data (list->data, "gimp-item-data")) == enum_value) { GtkWidget *radio = list->data; GtkWidget *hbox; GtkWidget *spacer; gint indicator_size; gint indicator_spacing; gint focus_width; gint focus_padding; gtk_widget_style_get (radio, "indicator-size", &indicator_size, "indicator-spacing", &indicator_spacing, "focus-line-width", &focus_width, "focus-padding", &focus_padding, NULL); hbox = gtk_hbox_new (FALSE, 0); spacer = gtk_vbox_new (FALSE, 0); gtk_widget_set_size_request (spacer, indicator_size + 3 * indicator_spacing + focus_width + focus_padding + GTK_CONTAINER (radio)->border_width, -1); gtk_box_pack_start (GTK_BOX (hbox), spacer, FALSE, FALSE, 0); gtk_widget_show (spacer); gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0); gtk_widget_show (widget); g_object_set_data (G_OBJECT (radio), "set_sensitive", hbox); g_signal_connect (radio, "toggled", G_CALLBACK (gimp_toggle_button_sensitive_update), NULL); gtk_widget_set_sensitive (hbox, GTK_TOGGLE_BUTTON (list->data)->active); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (vbox), hbox, pos); gtk_widget_show (hbox); break; } } g_list_free (children); }
/** * gdk_x11_screen_supports_net_wm_hint: * @screen: (type GdkX11Screen): the relevant #GdkScreen. * @property: a property atom. * * This function is specific to the X11 backend of GDK, and indicates * whether the window manager supports a certain hint from the * Extended Window Manager Hints Specification. You can find this * specification on * <ulink url="http://www.freedesktop.org">http://www.freedesktop.org</ulink>. * * When using this function, keep in mind that the window manager * can change over time; so you shouldn't use this function in * a way that impacts persistent application state. A common bug * is that your application can start up before the window manager * does when the user logs in, and before the window manager starts * gdk_x11_screen_supports_net_wm_hint() will return %FALSE for every property. * You can monitor the window_manager_changed signal on #GdkScreen to detect * a window manager change. * * Return value: %TRUE if the window manager supports @property * * Since: 2.2 **/ gboolean gdk_x11_screen_supports_net_wm_hint (GdkScreen *screen, GdkAtom property) { gulong i; GdkX11Screen *x11_screen; NetWmSupportedAtoms *supported_atoms; GdkDisplay *display; g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); x11_screen = GDK_X11_SCREEN (screen); display = x11_screen->display; if (!G_LIKELY (GDK_X11_DISPLAY (display)->trusted_client)) return FALSE; supported_atoms = g_object_get_data (G_OBJECT (screen), "gdk-net-wm-supported-atoms"); if (!supported_atoms) { supported_atoms = g_new0 (NetWmSupportedAtoms, 1); g_object_set_data_full (G_OBJECT (screen), "gdk-net-wm-supported-atoms", supported_atoms, cleanup_atoms); } fetch_net_wm_check_window (screen); if (x11_screen->wmspec_check_window == None) return FALSE; if (x11_screen->need_refetch_net_supported) { /* WM has changed since we last got the supported list, * refetch it. */ Atom type; gint format; gulong bytes_after; x11_screen->need_refetch_net_supported = FALSE; if (supported_atoms->atoms) XFree (supported_atoms->atoms); supported_atoms->atoms = NULL; supported_atoms->n_atoms = 0; XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), x11_screen->xroot_window, gdk_x11_get_xatom_by_name_for_display (display, "_NET_SUPPORTED"), 0, G_MAXLONG, False, XA_ATOM, &type, &format, &supported_atoms->n_atoms, &bytes_after, (guchar **)&supported_atoms->atoms); if (type != XA_ATOM) return FALSE; } if (supported_atoms->atoms == NULL) return FALSE; i = 0; while (i < supported_atoms->n_atoms) { if (supported_atoms->atoms[i] == gdk_x11_atom_to_xatom_for_display (display, property)) return TRUE; ++i; } return FALSE; }
void save_all_file(GtkWidget *button, gpointer user_data) { /** All files saving callback. **/ #ifdef DEBUG DEBUG_FUNC_MARK #endif gint number_of_pages = gtk_notebook_get_n_pages(GTK_NOTEBOOK(gui->editor_notebook)) ; int c ; for (c=0 ; c < number_of_pages ; c++) { /** We iterate over every notebook page. **/ GtkWidget *notebook_page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(gui->editor_notebook), c) ; GtkWidget *notebook_tab = gtk_notebook_get_tab_label(GTK_NOTEBOOK(gui->editor_notebook), notebook_page); /** The tab contains an mimetype icon, the filename and the page closing button. **/ GList *tab_compound_list = gtk_container_get_children(GTK_CONTAINER(notebook_tab)) ; tab_compound_list = g_list_first(tab_compound_list) ; while (tab_compound_list->data != NULL) { if (g_object_get_data(G_OBJECT(tab_compound_list->data), "tab_filename_widget")) { /** We get the filename tab label. **/ const char *tab_label = gtk_label_get_text(GTK_LABEL(tab_compound_list->data)) ; if (tab_label[0] == '*' && g_strcmp0(tab_label,"*New") != 0) { /** Check if the file is modified (marked with an'*') and is not the default "New" named file. **/ GtkWidget *current_textview = gtk_bin_get_child(GTK_BIN(notebook_page)) ; GtkTextBuffer *current_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(current_textview)) ; gpointer filepath = g_object_get_data(G_OBJECT(current_buffer), "filepath") ; if (filepath != NULL) { /** Getting current editor content **/ GtkTextIter iter_start, iter_end ; GError *error=NULL ; gtk_text_buffer_get_start_iter(current_buffer, &iter_start); gtk_text_buffer_get_end_iter(current_buffer, &iter_end); gchar *file_content = gtk_text_buffer_get_text(current_buffer, &iter_start, &iter_end, FALSE); char *back_up_filepath = NULL ; if (settings.backup_file) { /** backup creation by renaming the ancient (last saved) file (content) by adding an '~' the backup files suffix. **/ back_up_filepath = g_strdup_printf("%s~", (char *) filepath) ; rename(filepath,back_up_filepath) ; } if ( ! g_file_set_contents(filepath, file_content, -1, &error) ) { /** The content saving has failed **/ rename(back_up_filepath, filepath) ; /** We must reset the renaming because else we lost the correct filename in this error case. **/ char *msg = g_strdup_printf( _("Failed to save file:\n%s"), (gchar *) filepath) ; display_message_dialog( _("Cannot save file !!!"), msg, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE) ; free(msg) ; } g_free(file_content) ; g_free(back_up_filepath) ; /** setting the base filename in the bottom bar. **/ gtk_label_set_text(GTK_LABEL(tab_compound_list->data), g_path_get_basename(filepath)) ; /** We mark the TextBuffer as not modified since last saving operation. **/ gtk_text_buffer_set_modified(current_buffer, FALSE) ; if (settings.rm_trailing_spaces) { /** Deleting trailing spaces. **/ char *trailing_spaces_deleting ; trailing_spaces_deleting = g_strdup_printf("sed -i 's/[[:space:]]$//' '%s'", (char *) filepath) ; int ret ; if ((ret = system(trailing_spaces_deleting)) == -1) { g_warning(_("Removing trailing space failure:\n%s\n"), trailing_spaces_deleting) ; } free(trailing_spaces_deleting) ; } #ifdef RELOADING_FUNC /** Update Last modification timestamp. **/ File_Editor *file_editor = (File_Editor *) g_object_get_data(G_OBJECT(current_textview), "file_editor") ; g_stat(filepath, &file_editor->file_info) ; #endif } } break ; } tab_compound_list = tab_compound_list->next ; } } return ; }