static gboolean cell_changed_cb (GtkEditable *editable, gpointer user_data) { char *cell_text; guint column; #if GTK_CHECK_VERSION(3,0,0) GdkRGBA rgba; #else GdkColor color; #endif gboolean value_valid = FALSE; const char *colorname = NULL; cell_text = gtk_editable_get_chars (editable, 0, -1); /* The Netmask column can also contain prefix */ column = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (user_data), "column")); if (column == COL_PREFIX) { /* The COL_PREFIX can contain IP address or prefix */ guint32 tmp_prefix; errno = 0; /* Is it a prefix? */ if (!strchr (cell_text, '.')) { tmp_prefix = strtol (cell_text, NULL, 10); if (!errno && tmp_prefix >= 0 && tmp_prefix <= 32) value_valid = TRUE; } else { struct in_addr tmp_addr; /* Is it a netmask? */ if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0) value_valid = TRUE; } } else if (column == COL_METRIC) { long int tmp_int; errno = 0; tmp_int = strtol (cell_text, NULL, 10); if (errno || tmp_int < 0 || tmp_int > G_MAXUINT32) value_valid = FALSE; else value_valid = TRUE; } else { struct in_addr tmp_addr; if (inet_pton (AF_INET, cell_text, &tmp_addr) > 0) value_valid = TRUE; } /* Change cell's background color while editing */ colorname = value_valid ? "lightgreen" : "red"; #if GTK_CHECK_VERSION(3,0,0) gdk_rgba_parse (&rgba, colorname); gtk_widget_override_background_color (GTK_WIDGET (editable), GTK_STATE_NORMAL, &rgba); #else gdk_color_parse (colorname, &color); gtk_widget_modify_base (GTK_WIDGET (editable), GTK_STATE_NORMAL, &color); #endif g_free (cell_text); return FALSE; }
static void gimp_file_entry_browse_clicked (GtkWidget *widget, GimpFileEntry *entry) { GtkFileChooser *chooser; gchar *utf8; gchar *filename; utf8 = gtk_editable_get_chars (GTK_EDITABLE (entry->entry), 0, -1); filename = g_filename_from_utf8 (utf8, -1, NULL, NULL, NULL); g_free (utf8); if (! entry->file_dialog) { const gchar *title = entry->title; if (! title) { if (entry->dir_only) title = _("Select Folder"); else title = _("Select File"); } entry->file_dialog = gtk_file_chooser_dialog_new (title, NULL, entry->dir_only ? GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER : GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (entry->file_dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); chooser = GTK_FILE_CHOOSER (entry->file_dialog); gtk_window_set_position (GTK_WINDOW (chooser), GTK_WIN_POS_MOUSE); gtk_window_set_role (GTK_WINDOW (chooser), "gimp-file-entry-file-dialog"); g_signal_connect (chooser, "response", G_CALLBACK (gimp_file_entry_chooser_response), entry); g_signal_connect (chooser, "delete-event", G_CALLBACK (gtk_true), NULL); g_signal_connect_swapped (entry, "unmap", G_CALLBACK (gtk_widget_hide), chooser); } else { chooser = GTK_FILE_CHOOSER (entry->file_dialog); } gtk_file_chooser_set_filename (chooser, filename); g_free (filename); gtk_window_set_screen (GTK_WINDOW (chooser), gtk_widget_get_screen (widget)); gtk_window_present (GTK_WINDOW (chooser)); }
static void on_ok_action_activated (GtkAction *action, GitMergePane *self) { Git *plugin; GtkEditable *merge_revision_entry; GtkToggleAction *no_commit_action; GtkToggleAction *squash_action; GtkToggleButton *use_custom_log_check; gchar *revision; gchar *log; AnjutaColumnTextView *merge_log_view; GitMergeCommand *merge_command; plugin = ANJUTA_PLUGIN_GIT (anjuta_dock_pane_get_plugin (ANJUTA_DOCK_PANE (self))); merge_revision_entry = GTK_EDITABLE (gtk_builder_get_object (self->priv->builder, "merge_revision_entry")); no_commit_action = GTK_TOGGLE_ACTION (gtk_builder_get_object (self->priv->builder, "no_commit_action")); squash_action = GTK_TOGGLE_ACTION (gtk_builder_get_object (self->priv->builder, "squash_action")); use_custom_log_check = GTK_TOGGLE_BUTTON (gtk_builder_get_object (self->priv->builder, "use_custom_log_check")); revision = gtk_editable_get_chars (merge_revision_entry, 0, -1); log = NULL; if (!git_pane_check_input (GTK_WIDGET (ANJUTA_PLUGIN (plugin)->shell), GTK_WIDGET (merge_revision_entry), revision, _("Please enter a revision."))) { g_free (revision); return; } if (gtk_toggle_button_get_active (use_custom_log_check)) { merge_log_view = ANJUTA_COLUMN_TEXT_VIEW (gtk_builder_get_object (self->priv->builder, "merge_log_view")); log = anjuta_column_text_view_get_text (merge_log_view); if (!git_pane_check_input (GTK_WIDGET (ANJUTA_PLUGIN (plugin)->shell), GTK_WIDGET (merge_log_view), log, _("Please enter a log message."))) { g_free (revision); g_free (log); return; } } merge_command = git_merge_command_new (plugin->project_root_directory, revision, log, gtk_toggle_action_get_active (no_commit_action), gtk_toggle_action_get_active (squash_action)); g_free (revision); g_free (log); git_pane_create_message_view (plugin); g_signal_connect (G_OBJECT (merge_command), "data-arrived", G_CALLBACK (git_pane_on_command_info_arrived), plugin); g_signal_connect (G_OBJECT (merge_command), "command-finished", G_CALLBACK (git_pane_report_errors), plugin); g_signal_connect (G_OBJECT (merge_command), "command-finished", G_CALLBACK (g_object_unref), NULL); anjuta_command_start (ANJUTA_COMMAND (merge_command)); git_pane_remove_from_dock (GIT_PANE (self)); }
void *reader_loop(void* wojd) { mkfifo(fpipeout, S_IRWXU); FILE *fileout = fopen(fpipeout, "a+"); if(!fileout) { fprintf(stderr, "Error opening pipe %s !\n", fpipeout); pthread_exit(NULL); } mkfifo(fpipein, S_IRWXU); FILE *filein = fopen(fpipein, "r+"); if(!filein) { fprintf(stderr, "Error opening pipe %s !\n", fpipein); pthread_exit(NULL); } if(VERBOSE) fprintf(stderr, "Using pipes out:%s in:%s\n", fpipeout, fpipein); char input[1024]; char *operanda = NULL; char *object = NULL; char *command = NULL; while(RUNNING) { fgets(input, 1024, filein); if(!RUNNING) break; object = input; command = input; operanda = input; while(*command && *command != ' ') command++; *command = '\0'; operanda = ++command; while(*operanda && *operanda != ' ') operanda++; *operanda++ = '\0'; if(VERBOSE) fprintf(stderr, "Command:> %s %s %s\n", object, command, operanda); GtkWidget *widget = GTK_WIDGET(gtk_builder_get_object(builder, object)); //window set title if(!strcmp(command, "set_window_title")) { gtk_window_set_title(GTK_WINDOW(widget), operanda); } else //window show if(!strcmp(command, "show")) { gtk_widget_show(widget); } else //window hide if(!strcmp(command, "hide")) { gtk_widget_hide(widget); } else //textview set text if(!strcmp(command, "set_textview_text")) { gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)), operanda, -1); } else //textview get text if(!strcmp(command, "get_textview_text")) { GtkTextIter a, b; GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget)); gtk_text_buffer_get_iter_at_offset(buffer, &a, 0); gtk_text_buffer_get_iter_at_offset(buffer, &b, -1); gchar* mtext = gtk_text_buffer_get_text(buffer, &a, &b, FALSE); fprintf(fileout, "%s\n", mtext); fflush(fileout); } else // //spinner activate/deactivate if(!strcmp(command, "spinner_start")) { gtk_spinner_start(GTK_SPINNER(widget)); } else if(!strcmp(command, "spinner_stop")) { gtk_spinner_stop(GTK_SPINNER(widget)); } else //label set/get if(!strcmp(command, "set_label_text")) { gtk_label_set_text(GTK_LABEL(widget), operanda); } else //set button label if(!strcmp(command, "set_button_label")) { gtk_button_set_label(GTK_BUTTON(widget), operanda); } else //entrytext set/get if(!strcmp(command, "get_entry_text")) { gchar* mtext = gtk_editable_get_chars(GTK_EDITABLE(widget), 0, -1); fprintf(fileout, "%s\n", mtext); fflush(fileout); } else if(!strcmp(command, "set_entry_text")) { gtk_entry_set_text(GTK_ENTRY(widget), operanda); } else //combobox add options, get/set selected if(!strcmp(command, "set_combobox_items")) { //GtkTreeModel *tree_model; //gtk_combo_box_model_set(GTK_COMBO_BOX(widget), tree_model); } else if(!strcmp(command, "get_selected_combobox_item")) { fprintf(fileout, "%d\n", gtk_combo_box_get_active(GTK_COMBO_BOX(widget))); fflush(fileout); } else //image set image TODO doesn't work if(!strcmp(command, "set_image")) { gtk_image_set_from_file(GTK_IMAGE(widget), operanda); gtk_widget_show(widget); } else //progressbar set, show/hide if(!strcmp(command, "set_progressbar")) { } else //togglebutton istoggled //toggle, check, radio button if(!strcmp(command, "get_button_state")) { if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) fprintf(fileout, "1\n"); else fprintf(fileout, "0\n"); fflush(fileout); } } fclose(filein); fflush(fileout); fclose(fileout); pthread_exit(NULL); }
static int gtk_combo_entry_key_press (GtkEntry * entry, GdkEventKey * event, GtkCombo * combo) { GList *li; /* completion */ if ((event->keyval == GDK_Tab) && (event->state & GDK_MOD1_MASK)) { GCompletion * cmpl; gchar* prefix; gchar* nprefix = NULL; gint pos; if ( !GTK_LIST (combo->list)->children ) return FALSE; gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event"); cmpl = g_completion_new ((GCompletionFunc)gtk_combo_func); g_completion_add_items (cmpl, GTK_LIST (combo->list)->children); pos = GTK_EDITABLE (entry)->current_pos; prefix = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, pos); g_completion_complete(cmpl, prefix, &nprefix); if (nprefix && strlen (nprefix) > strlen (prefix)) { gtk_editable_insert_text (GTK_EDITABLE (entry), nprefix + pos, strlen (nprefix) - strlen (prefix), &pos); GTK_EDITABLE (entry)->current_pos = pos; } if (nprefix) g_free (nprefix); g_free (prefix); g_completion_free (cmpl); return TRUE; } if (!combo->use_arrows || !GTK_LIST (combo->list)->children) return FALSE; li = g_list_find (GTK_LIST (combo->list)->children, gtk_combo_find (combo)); if ((event->keyval == GDK_Up) || (event->keyval == GDK_KP_Up) || ((event->state & GDK_MOD1_MASK) && ((event->keyval == 'p') || (event->keyval == 'P')))) { if (li) li = li->prev; if (!li && combo->use_arrows_always) { li = g_list_last (GTK_LIST (combo->list)->children); } if (li) { gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data)); gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event"); return TRUE; } } else if ((event->keyval == GDK_Down) || (event->keyval == GDK_KP_Down) || ((event->state & GDK_MOD1_MASK) && ((event->keyval == 'n') || (event->keyval == 'N')))) { if (li) li = li->next; if (!li && combo->use_arrows_always) { li = GTK_LIST (combo->list)->children; } if (li) { gtk_list_select_child (GTK_LIST (combo->list), GTK_WIDGET (li->data)); gtk_signal_emit_stop_by_name (GTK_OBJECT (entry), "key_press_event"); return TRUE; } } return FALSE; }
static void on_pull_dialog_response (GtkDialog *dialog, gint response_id, GitUIData *data) { GtkWidget *pull_remote_toggle; GtkWidget *pull_url_toggle; GtkWidget *pull_remote_view; GtkWidget *pull_origin_check; GtkWidget *pull_rebase_check; GtkWidget *pull_url_entry; GtkWidget *pull_no_commit_check; GtkWidget *pull_squash_check; GtkWidget *pull_fast_forward_commit_check; GtkWidget *pull_append_fetch_data_check; GtkWidget *pull_force_check; GtkWidget *pull_no_follow_tags_check; GtkTreeModel *remote_list_model; GtkWidget *input_widget; const gchar *input_error; gchar *url; GtkTreeSelection *selection; GtkTreeIter iter; GitPullCommand *pull_command; if (response_id == GTK_RESPONSE_OK) { pull_remote_toggle = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_remote_toggle")); pull_url_toggle = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_url_toggle")); pull_remote_view = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_remote_view")); pull_origin_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_origin_check")); pull_rebase_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_rebase_check")); pull_url_entry = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_url_entry")); pull_no_commit_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_no_commit_check")); pull_squash_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_squash_check")); pull_fast_forward_commit_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_fast_forward_commit_check")); pull_append_fetch_data_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_append_fetch_data_check")); pull_force_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_force_check")); pull_no_follow_tags_check = GTK_WIDGET (gtk_builder_get_object (data->bxml, "pull_no_follow_tags_check")); remote_list_model = GTK_TREE_MODEL (gtk_builder_get_object (data->bxml, "remote_list_model")); /* The "input widget" is the widget that should receive focus if the * user does not properly enter anything */ input_error = _("Please select a remote to pull from."); input_widget = pull_remote_view; url = NULL; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_origin_check))) url = g_strdup ("origin"); else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_remote_toggle))) { selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pull_remote_view)); if (gtk_tree_selection_get_selected (selection, NULL, &iter)) gtk_tree_model_get (remote_list_model, &iter, 0, &url, -1); } else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_url_toggle))) { url = gtk_editable_get_chars (GTK_EDITABLE (pull_url_entry), 0, -1); input_widget = pull_url_entry; input_error = _("Please enter the URL of the repository to pull from."); } if (!git_check_input (GTK_WIDGET (dialog), input_widget, url, input_error)) { g_free (url); return; } pull_command = git_pull_command_new (data->plugin->project_root_directory, url, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_rebase_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_no_commit_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_squash_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_fast_forward_commit_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_append_fetch_data_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_force_check)), gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (pull_no_follow_tags_check))); g_free (url); git_create_message_view (data->plugin); g_signal_connect (G_OBJECT (pull_command), "command-finished", G_CALLBACK (on_pull_command_finished), data->plugin); g_signal_connect (G_OBJECT (pull_command), "data-arrived", G_CALLBACK (on_git_command_info_arrived), data->plugin); anjuta_command_start (ANJUTA_COMMAND (pull_command)); } gtk_widget_destroy (GTK_WIDGET (dialog)); git_ui_data_free (data); }
static void save_archiver_prefs(PrefsPage * _page) { struct ArchiverPrefsPage *page = (struct ArchiverPrefsPage *) _page; PrefFile *pref_file; gchar *rc_file_path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, COMMON_RC, NULL); archiver_prefs.save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1); if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->zip_radiobtn))) archiver_prefs.compression = COMPRESSION_ZIP; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->bzip_radiobtn))) archiver_prefs.compression = COMPRESSION_BZIP; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->compress_radiobtn))) archiver_prefs.compression = COMPRESSION_COMPRESS; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->none_radiobtn))) archiver_prefs.compression = COMPRESSION_NONE; if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->tar_radiobtn))) archiver_prefs.format = FORMAT_TAR; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->shar_radiobtn))) archiver_prefs.format = FORMAT_SHAR; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->cpio_radiobtn))) archiver_prefs.format = FORMAT_CPIO; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->pax_radiobtn))) archiver_prefs.format = FORMAT_PAX; if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->recursive_chkbtn))) archiver_prefs.recursive = TRUE; else archiver_prefs.recursive = FALSE; if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->md5sum_chkbtn))) archiver_prefs.md5sum = TRUE; else archiver_prefs.md5sum = FALSE; if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->rename_chkbtn))) archiver_prefs.rename = TRUE; else archiver_prefs.rename = FALSE; if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->unlink_chkbtn))) archiver_prefs.unlink = TRUE; else archiver_prefs.unlink = FALSE; pref_file = prefs_write_open(rc_file_path); g_free(rc_file_path); if (!(pref_file) || (prefs_set_block_label(pref_file, PREFS_BLOCK_NAME) < 0)) return; if (prefs_write_param(param, pref_file->fp) < 0) { g_warning("failed to write Archiver Plugin configuration\n"); prefs_file_close_revert(pref_file); return; } if (fprintf(pref_file->fp, "\n") < 0) { FILE_OP_ERROR(rc_file_path, "fprintf"); prefs_file_close_revert(pref_file); } else prefs_file_close(pref_file); }
static bool handle_link(GtkEntry* entry, girara_session_t* session, zathura_link_action_t action) { g_return_val_if_fail(session != NULL, FALSE); g_return_val_if_fail(session->global.data != NULL, FALSE); zathura_t* zathura = session->global.data; bool eval = true; char* input = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1); if (input == NULL || strlen(input) == 0) { eval = false; } int index = 0; if (eval == true) { index = atoi(input); if (index == 0 && g_strcmp0(input, "0") != 0) { girara_notify(session, GIRARA_WARNING, _("Invalid input '%s' given."), input); eval = false; } index = index - 1; } /* set pages to draw links */ bool invalid_index = true; unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) { zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); if (page == NULL || zathura_page_get_visibility(page) == false) { continue; } GtkWidget* page_widget = zathura_page_get_widget(zathura, page); g_object_set(page_widget, "draw-links", FALSE, NULL); if (eval == true) { zathura_link_t* link = zathura_page_widget_link_get(ZATHURA_PAGE(page_widget), index); if (link != NULL) { invalid_index = false; switch (action) { case ZATHURA_LINK_ACTION_FOLLOW: zathura_jumplist_save(zathura); zathura_link_evaluate(zathura, link); zathura_jumplist_add(zathura); break; case ZATHURA_LINK_ACTION_DISPLAY: zathura_link_display(zathura, link); break; } } } } if (eval == true && invalid_index == true) { girara_notify(session, GIRARA_WARNING, _("Invalid index '%s' given."), input); } g_free(input); return (eval == TRUE) ? TRUE : FALSE; }
uint8_t DIA_Preferences(void) { uint8_t ret=0; gint r; char *str; const char *nullstring=""; dialog=create_dialog1(); gtk_transient(dialog); #define CONNECT(A,B) gtk_signal_connect (GTK_OBJECT(lookup_widget(dialog,#A)), "clicked", \ GTK_SIGNAL_FUNC (B), (void *) NULL); CONNECT(buttonLame,on_callback_lame); CONNECT(buttonToolame,on_callback_toolame); CONNECT(buttonLvemux,on_callback_lvemux); CONNECT(buttonRequant,on_callback_requant); CONNECT(button_audioDevice,on_callback_audio); // prepare if(!prefs->get(TOOLAME_PATH, &str)) { str=(char *)nullstring; } gtk_write_entry_string(WID(entryToolame), str); if(!prefs->get(LAME_PATH, &str)) { str=(char *)nullstring; } gtk_write_entry_string(WID(entryLame), str); if(!prefs->get(LVEMUX_PATH, &str)) { str=(char *)nullstring; } gtk_write_entry_string(WID(entryLvemux), str); if(!prefs->get(REQUANT_PATH, &str)) { str=(char *)nullstring; } gtk_write_entry_string(WID(entryRequant), str); if(gtk_dialog_run(GTK_DIALOG(dialog))==GTK_RESPONSE_OK) { ret=1; str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryToolame)), 0, -1); prefs->set(TOOLAME_PATH, str); str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryLame)), 0, -1); prefs->set(LAME_PATH, str); str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryLvemux)), 0, -1); prefs->set(LVEMUX_PATH, str); str = gtk_editable_get_chars(GTK_EDITABLE (WID(entryRequant)), 0, -1); prefs->set(REQUANT_PATH, str); } gtk_widget_destroy(dialog); dialog=NULL; return ret; }
note_data * fill_note_data_from_page(_notetype notetype) { note_data *note; gchar *l_ptr; note = (note_data *) malloc(sizeof (note_data)); if (note == NULL) { g_warning(_("Error while allocating memory for note (0)")); return (NULL); } note->notetype = notetype; note->title = g_strdup(gtk_entry_get_text(GTK_ENTRY(sp->title_entry))); if (note->title == NULL) { g_warning(_("Error while allocating memory for note (1)")); return (NULL); } note->text = gtk_editable_get_chars(GTK_EDITABLE(sp->text_entry), 0, gtk_text_get_length(GTK_TEXT( sp->text_entry))); if (note->text == NULL) { g_warning(_("Error while allocating memory for note (2)")); return (NULL); } if (notetype == CheckNote || notetype == TodoNote) { note->todo = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(sp->todo_check)); } else { note->todo = 0; } note->expire = time_label_get_time(TIME_LABEL(sp->tlabel_expire)); note->created = time_label_get_time(TIME_LABEL(sp->tlabel_created)); note->changed = time(NULL); time_label_set_time(TIME_LABEL(sp->tlabel_changed), note->changed); gtk_label_get(GTK_LABEL(sp->label_changes), &l_ptr); note->changes = atoi(l_ptr); note->changes++; l_ptr = g_strdup_printf("%ld", note->changes); gtk_label_set_text(GTK_LABEL(sp->label_changes), l_ptr); g_free(l_ptr); note->id = g_strdup(gtk_entry_get_text(GTK_ENTRY(sp->note_id_entry))); if (note->id == NULL) { g_warning(_("Error while allocating memory for note (3)")); return (NULL); } if (notetype == TodoNote) { note->deadline = gnome_date_edit_get_date( GNOME_DATE_EDIT(sp->de_deadline)); note->prio = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(sp->prio_entry)); note->complete = GTK_ADJUSTMENT(sp->ad_complete)->value; } else { note->deadline = 0; note->prio = 0; note->complete = 0; } return (note); }
void window_open_display_cmd_callback (GtkAction *action, gpointer data) { GtkWidget *widget; GtkWidget *dialog; GtkWidget *entry; return_if_no_widget (widget, data); dialog = gimp_message_dialog_new ("Open Display", GIMP_STOCK_WILBER_EEK, widget, GTK_DIALOG_MODAL, NULL, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box, "Experimental multi-display stuff!\n" "Click OK and have fun crashing GIMP..."); gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, "Please enter the name of the new display:"); entry = gtk_entry_new (); gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE); gtk_box_pack_start (GTK_BOX (GIMP_MESSAGE_DIALOG (dialog)->box), entry, TRUE, TRUE, 0); gtk_widget_grab_focus (entry); gtk_widget_show_all (dialog); while (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { gchar *screen_name; screen_name = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); if (strcmp (screen_name, "")) { GdkDisplay *display; gtk_widget_set_sensitive (dialog, FALSE); display = gdk_display_open (screen_name); if (! display) gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box, "Can't open display '%s'. " "Please try another one:", screen_name); g_free (screen_name); gtk_widget_set_sensitive (dialog, TRUE); if (display) break; } gtk_widget_grab_focus (entry); } gtk_widget_destroy (dialog); }
static void dt_time_edit_window(GtkWidget *button, cbdata *cbd) { GtkWidget *hbox = cbd->hbox; GtkWidget *inputbox = dt_time_retrieve_inputbox(hbox); GtkWidget *editwindow, *main_vbox, *calendar, *w; GtkWidget *hbox2, *button2; GtkAdjustment *adj; char titlebuffer[1024]; /* FIXME: fixed buffer length */ struct tm tm; int y, m, d, offset; int ofs_h, ofs_m, ofs_sign; time_t t; struct tm *l; gchar *content; #if ! defined(HAVE_TM_GMTOFF) && defined(HAVE_TIMEZONE) extern long timezone; #endif time(&t); l = localtime(&t); /* implicitly calls tzset() for us */ y = l->tm_year + 1900; m = l->tm_mon + 1; d = l->tm_mday; #ifdef HAVE_TM_GMTOFF ofs_sign = l->TM_GMTOFF < 0 ? 1 : -1; ofs_m = (l->TM_GMTOFF > 0 ? l->TM_GMTOFF : -l->TM_GMTOFF) / 60; ofs_h = ofs_m / 60; ofs_m = ofs_m % 60; #else /* HAVE_TM_GMTOFF */ # ifdef HAVE_TIMEZONE ofs_sign = timezone > 0 ? 1 : -1; ofs_m = (timezone > 0 ? timezone : -timezone) / 60; ofs_h = ofs_m / 60; ofs_m = ofs_m % 60; /* extern long timezone does not take DST into account */ if (l->tm_isdst) { ofs_h++; } # else /* HAVE_TIMEZONE */ ofs_h = ofs_m = 0; # endif /* HAVE_TIMEZONE */ #endif /* HAVE_TM_GMTOFF */ /* NOTE: generalizedTime includes offset relative to GMT while the timezone variable hold seconds west of GMT */ offset = -ofs_sign * (100 * ofs_h + ofs_m); #ifdef GTK_WINDOW_DIALOG editwindow = gtk_window_new(GTK_WINDOW_DIALOG); #else editwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif cbd->editwindow = editwindow; g_snprintf(titlebuffer, sizeof(titlebuffer), _("%s: choose date and time"), cbd->form->attrname); gtk_window_set_title(GTK_WINDOW(editwindow), titlebuffer); gtk_window_set_policy(GTK_WINDOW(editwindow), TRUE, TRUE, FALSE); main_vbox = gtk_vbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(main_vbox), 5); gtk_widget_show(main_vbox); gtk_container_add(GTK_CONTAINER(editwindow), main_vbox); calendar = gtk_calendar_new(); gtk_box_pack_start(GTK_BOX(main_vbox), calendar, TRUE, TRUE, 0); gtk_widget_show(calendar); gtk_object_set_data(GTK_OBJECT(editwindow), "calendar", calendar); content = gtk_editable_get_chars(GTK_EDITABLE(inputbox), 0, -1); if (content) { int n = parse_time(content, &tm, &offset); /* printf("n=%d\n", n); */ if (n >= 1) y = tm.tm_year + 1900; if (n >= 2) m = tm.tm_mon + 1; if (n >= 3) d = tm.tm_mday; g_free(content); } gtk_calendar_select_month(GTK_CALENDAR(calendar), m - 1, y); gtk_calendar_select_day(GTK_CALENDAR(calendar), d); hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 5); gtk_widget_show(hbox2); w = gtk_label_new(_("Time [hh:mm:ss]")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 23.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_hour); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "hour", w); w = gtk_label_new(_(":")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 59.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_min); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "minute", w); w = gtk_label_new(_(":")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); w = gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 59.0, 1.0, 1.0, 1.0)), 1.0, 0); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), tm.tm_sec); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, FALSE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "second", w); hbox2 = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, TRUE, TRUE, 0); gtk_widget_show(hbox2); w = gtk_label_new(_("Timezone (Offset) [+-hhmm]")); gtk_box_pack_start(GTK_BOX(hbox2), w, FALSE, TRUE, 0); gtk_widget_show(w); adj = GTK_ADJUSTMENT(gtk_adjustment_new(0.0, -1259.0, 1259.0, 100.0, 100.0, 100.0)); w = gtk_spin_button_new(adj, 100.0, 0); gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(w), FALSE); gtk_spin_button_set_value(GTK_SPIN_BUTTON(w), offset); g_signal_connect(adj, "value-changed", G_CALLBACK(tz_value_changed_callback), w); gtk_box_pack_start(GTK_BOX(hbox2), w, TRUE, TRUE, 10); gtk_widget_show(w); gtk_object_set_data(GTK_OBJECT(editwindow), "timezone", w); hbox2 = gtk_hbutton_box_new(); gtk_box_pack_start(GTK_BOX(main_vbox), hbox2, FALSE, TRUE, 5); gtk_widget_show(hbox2); button2 = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_widget_show(button2); g_signal_connect(button2, "clicked", G_CALLBACK(dt_time_ok_callback), cbd); gtk_box_pack_start(GTK_BOX(hbox2), button2, FALSE, TRUE, 0); GTK_WIDGET_SET_FLAGS(button2, GTK_CAN_DEFAULT); gtk_widget_grab_default(button2); button2 = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_box_pack_end(GTK_BOX(hbox2), button2, FALSE, TRUE, 0); g_signal_connect_swapped(button2, "clicked", G_CALLBACK(gtk_widget_destroy), editwindow); gtk_widget_show(button2); gtk_widget_show(editwindow); }
static void gnc_ui_to_employee (EmployeeWindow *ew, GncEmployee *employee) { GncAddress *addr; addr = gncEmployeeGetAddr (employee); gnc_suspend_gui_refresh (); gncEmployeeBeginEdit (employee); if (ew->dialog_type == NEW_EMPLOYEE) qof_event_gen(QOF_INSTANCE(employee), QOF_EVENT_ADD, NULL); gncEmployeeSetID (employee, gtk_editable_get_chars (GTK_EDITABLE (ew->id_entry), 0, -1)); gncEmployeeSetUsername (employee, gtk_editable_get_chars (GTK_EDITABLE (ew->username_entry), 0, -1)); gncAddressSetName (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->name_entry), 0, -1)); gncAddressSetAddr1 (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->addr1_entry), 0, -1)); gncAddressSetAddr2 (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->addr2_entry), 0, -1)); gncAddressSetAddr3 (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->addr3_entry), 0, -1)); gncAddressSetAddr4 (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->addr4_entry), 0, -1)); gncAddressSetPhone (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->phone_entry), 0, -1)); gncAddressSetFax (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->fax_entry), 0, -1)); gncAddressSetEmail (addr, gtk_editable_get_chars (GTK_EDITABLE (ew->email_entry), 0, -1)); gncEmployeeSetActive (employee, gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ew->active_check))); gncEmployeeSetLanguage (employee, gtk_editable_get_chars (GTK_EDITABLE (ew->language_entry), 0, -1)); /* Parse and set the workday and rate amounts */ gncEmployeeSetWorkday (employee, gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (ew->workday_amount))); gncEmployeeSetRate (employee, gnc_amount_edit_get_amount (GNC_AMOUNT_EDIT (ew->rate_amount))); gncEmployeeSetCurrency (employee, gnc_currency_edit_get_currency (GNC_CURRENCY_EDIT (ew->currency_edit))); /* Fill in the CCard Acct */ gncEmployeeSetCCard (employee, (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ew->ccard_acct_check)) ? gnc_account_sel_get_account (GNC_ACCOUNT_SEL (ew->ccard_acct_sel)) : NULL)); gncEmployeeCommitEdit (employee); gnc_resume_gui_refresh (); }
static gboolean command_key_event (GtkEntry *entry, GdkEventKey *event, MCData *mc) { guint key = event->keyval; char *command; static char current_command[MC_MAX_COMMAND_LENGTH]; char buffer[MC_MAX_COMMAND_LENGTH]; gboolean propagate_event = TRUE; const gchar *str; if (mc->error) { mc->error = FALSE; str = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); gtk_entry_set_text (entry, (gchar *) str + 3); gtk_editable_set_position (GTK_EDITABLE (entry), strlen (str)); } if(key == GDK_Tab || key == GDK_KP_Tab || key == GDK_ISO_Left_Tab) { if(event->state == GDK_CONTROL_MASK) { /* * Move focus to the next widget (browser) button. */ gtk_widget_child_focus (GTK_WIDGET (mc->applet), GTK_DIR_TAB_FORWARD); propagate_event = FALSE; } else if(event->state != GDK_SHIFT_MASK) { /* tab key pressed */ strcpy(buffer, (char *) gtk_entry_get_text(GTK_ENTRY(entry))); mc_cmd_completion (mc, buffer); gtk_entry_set_text(GTK_ENTRY(entry), (gchar *) buffer); propagate_event = FALSE; } } else if(key == GDK_Up || key == GDK_KP_Up || key == GDK_ISO_Move_Line_Up || key == GDK_Pointer_Up) { /* up key pressed */ if(history_position == MC_HISTORY_LIST_LENGTH) { /* store current command line */ strcpy(current_command, (char *) gtk_entry_get_text(entry)); } if(history_position > 0 && exists_history_entry(history_position - 1)) { gtk_entry_set_text(entry, (gchar *) get_history_entry(--history_position)); } propagate_event = FALSE; } else if(key == GDK_Down || key == GDK_KP_Down || key == GDK_ISO_Move_Line_Down || key == GDK_Pointer_Down) { /* down key pressed */ if(history_position < MC_HISTORY_LIST_LENGTH - 1) { gtk_entry_set_text(entry, (gchar *) get_history_entry(++history_position)); } else if(history_position == MC_HISTORY_LIST_LENGTH - 1) { gtk_entry_set_text(entry, (gchar *) current_command); ++history_position; } propagate_event = FALSE; } else if(key == GDK_Return || key == GDK_KP_Enter || key == GDK_ISO_Enter || key == GDK_3270_Enter) { /* enter pressed -> exec command */ command = (char *) malloc(sizeof(char) * MC_MAX_COMMAND_LENGTH); strcpy(command, (char *) gtk_entry_get_text(entry)); mc_exec_command(mc, command); history_position = MC_HISTORY_LIST_LENGTH; free(command); strcpy(current_command, ""); propagate_event = FALSE; } else if (mc->preferences.auto_complete_history && key >= GDK_space && key <= GDK_asciitilde ) { char *completed_command; gint current_position = gtk_editable_get_position(GTK_EDITABLE(entry)); if(current_position != 0) { gtk_editable_delete_text( GTK_EDITABLE(entry), current_position, -1 ); completed_command = history_auto_complete(GTK_WIDGET (entry), event); if(completed_command != NULL) { gtk_entry_set_text(entry, completed_command); gtk_editable_set_position(GTK_EDITABLE(entry), current_position + 1); propagate_event = FALSE; } } } return !propagate_event; }
ReplyType glyphToText(admGlyph *glyph,admGlyph *head,char *decodedString) { admGlyph *cand; //printf("2t: %d x %d\n",glyph->width,glyph->height); if(glyph->width<2 && glyph->height<2) { delete glyph; return ReplyOk; } cand=searchGlyph(head,glyph); if(!cand) // New glyph { char *string; // Draw it displaySmall(glyph); gtk_label_set_text(GTK_LABEL(WID(labelText)),decodedString); gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),1); //gtk_widget_set_sensitive(WID(buttonSkip),1); //gtk_widget_set_sensitive(WID(entryEntry),1); gtk_widget_grab_focus (WID(entry)); gtk_widget_grab_default (WID(buttonOk)); //printf("i\n"); switch(gtk_dialog_run(GTK_DIALOG(dialog))) { case actionIgnore: glyph->code=NULL; insertInGlyphTree(head,glyph); //*nbGl++; break; case actionCalibrate: return ReplyCalibrate; case actionAccept: string =gtk_editable_get_chars(GTK_EDITABLE (WID(entry)), 0, -1); if(string&& strlen(string)) { glyph->code=ADM_strdup(string); insertInGlyphTree(head,glyph); //printf("New glyph:%s\n",glyph->code); strcat(decodedString,glyph->code); //*nbGl++; } else delete glyph; break; case actionSkip: //SKIP return ReplySkip; break; case actionSkipAll: return ReplySkipAll; break; case GTK_RESPONSE_CLOSE: if(GUI_Question(QT_TR_NOOP("Sure ?"))) return ReplyClose; break; // Abort } gtk_editable_delete_text(GTK_EDITABLE(WID(entry)), 0,-1); //gtk_widget_set_sensitive(WID(buttonAccept),0); //gtk_widget_set_sensitive(WID(buttonSkip),0); //gtk_widget_set_sensitive(WID(entryEntry),0); } else { //printf("Glyph known :%s \n",cand->code); if(cand->code) strcat(decodedString,cand->code); delete glyph; } return ReplyOk; }
static void spamassassin_save_func(PrefsPage *_page) { struct SpamAssassinPage *page = (struct SpamAssassinPage *) _page; SpamAssassinConfig *config; debug_print("Saving SpamAssassin Page\n"); config = spamassassin_get_config(); /* enable */ config->enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->enable_sa_checkbtn)); config->transport = page->trans; /* username */ g_free(config->username); config->username = gtk_editable_get_chars(GTK_EDITABLE(page->username), 0, -1); spamassassin_check_username(); /* hostname */ g_free(config->hostname); config->hostname = gtk_editable_get_chars(GTK_EDITABLE(page->hostname), 0, -1); /* port */ config->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->port)); /* hostname */ g_free(config->socket); config->socket = gtk_editable_get_chars(GTK_EDITABLE(page->socket), 0, -1); /* process_emails */ config->process_emails = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->process_emails)); /* receive_spam */ config->receive_spam = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->receive_spam)); /* save_folder */ g_free(config->save_folder); config->save_folder = gtk_editable_get_chars(GTK_EDITABLE(page->save_folder), 0, -1); /* max_size */ config->max_size = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->max_size)); /* timeout */ config->timeout = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(page->timeout)); /* mark_as_read */ config->mark_as_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->mark_as_read)); /* whitelist_ab */ config->whitelist_ab = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->whitelist_ab)); g_free(config->whitelist_ab_folder); config->whitelist_ab_folder = gtk_editable_get_chars( GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((page->whitelist_ab_folder_combo)))), 0, -1); /* store UNtranslated "Any" */ if (g_utf8_collate(config->whitelist_ab_folder, _("Any")) == 0) { g_free(config->whitelist_ab_folder); config->whitelist_ab_folder = g_strdup("Any"); } if (config->process_emails) { spamassassin_register_hook(); } else { spamassassin_unregister_hook(); } if (!config->enable) { procmsg_unregister_spam_learner(spamassassin_learn); procmsg_spam_set_folder(NULL, NULL); } else { if (config->transport == SPAMASSASSIN_TRANSPORT_TCP) debug_print("enabling learner with a remote spamassassin server requires spamc/spamd 3.1.x\n"); procmsg_register_spam_learner(spamassassin_learn); procmsg_spam_set_folder(config->save_folder, spamassassin_get_spam_folder); } spamassassin_save_config(); }
/*! *\brief Returns action from the content of the dialog * *\param alert specifies whether alert dialog boxes should be shown * or not. * *\return FilteringAction * action entered in the dialog box. */ static FilteringAction * prefs_filtering_action_dialog_to_action(gboolean alert) { Action action_id; gint action_type; gint list_id; gint account_id; gchar * destination = NULL; gint labelcolor = 0; FilteringAction * action; gint score; gchar * header = NULL; action_id = combobox_get_active_data(GTK_COMBO_BOX(filtering_action.action_combo)); action_type = prefs_filtering_action_get_matching_from_action(action_id); list_id = gtk_combo_box_get_active(GTK_COMBO_BOX(filtering_action.account_combo)); account_id = get_account_id_from_list_id(list_id); score = 0; destination = NULL; switch (action_id) { case ACTION_MOVE: case ACTION_COPY: case ACTION_EXECUTE: destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1); if (*destination == '\0') { if (alert) alertpanel_error(action_id == ACTION_EXECUTE ? _("Command-line not set") : _("Destination is not set.")); g_free(destination); return NULL; } break; case ACTION_FORWARD: case ACTION_FORWARD_AS_ATTACHMENT: case ACTION_REDIRECT: destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1); if (*destination == '\0') { if (alert) alertpanel_error(_("Recipient is not set.")); g_free(destination); return NULL; } break; #if !GTK_CHECK_VERSION(3, 0, 0) case ACTION_COLOR: labelcolor = colorlabel_get_color_menu_active_item( gtk_cmoption_menu_get_menu(GTK_CMOPTION_MENU(filtering_action.color_optmenu))); destination = NULL; break; #endif case ACTION_CHANGE_SCORE: case ACTION_SET_SCORE: score = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON( filtering_action.score_entry)); if (!score && action_id == ACTION_CHANGE_SCORE) { if (alert) alertpanel_error(_("Score is not set")); return NULL; } break; case ACTION_ADD_TO_ADDRESSBOOK: header = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.header_entry), 0, -1); if (*header == '\0') { if (alert) alertpanel_error(_("Header is not set.")); g_free(header); return NULL; } destination = gtk_editable_get_chars(GTK_EDITABLE(filtering_action.dest_entry), 0, -1); if (*destination == '\0') { if (alert) alertpanel_error(_("Target addressbook/folder is not set.")); g_free(destination); return NULL; } break; case ACTION_SET_TAG: case ACTION_UNSET_TAG: #if !GTK_CHECK_VERSION(2, 24, 0) destination = gtk_combo_box_get_active_text(GTK_COMBO_BOX(filtering_action.tags_combo)); #else destination = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filtering_action.tags_combo)); #endif if (!destination || *destination == '\0') { if (alert) alertpanel_error(_("Tag name is empty.")); g_free(destination); return NULL; } break; case ACTION_STOP: case ACTION_HIDE: case ACTION_IGNORE: case ACTION_WATCH: case ACTION_DELETE: case ACTION_MARK: case ACTION_UNMARK: case ACTION_LOCK: case ACTION_UNLOCK: case ACTION_MARK_AS_READ: case ACTION_MARK_AS_UNREAD: case ACTION_MARK_AS_SPAM: case ACTION_MARK_AS_HAM: case ACTION_CLEAR_TAGS: default: break; } action = filteringaction_new(action_type, account_id, destination, labelcolor, score, header); g_free(destination); return action; }
static void sync_pattern_data (void) { struct player_pattern *pp; char *pattern; char *comment; enum pattern_mode mode; int update_pattern = FALSE; int update_comment = FALSE; GSList *list; if (current_row < 0) return; list = g_slist_nth (curplrs, current_row); pp = (struct player_pattern *) list->data; if (GTK_TOGGLE_BUTTON (mode_buttons[PATTERN_MODE_STRING])->active) mode = PATTERN_MODE_STRING; else if (GTK_TOGGLE_BUTTON (mode_buttons[PATTERN_MODE_SUBSTR])->active) mode = PATTERN_MODE_SUBSTR; else mode = PATTERN_MODE_REGEXP; pattern = strdup_strip (gtk_entry_get_text (GTK_ENTRY (pattern_entry))); comment = gtk_editable_get_chars (GTK_EDITABLE (comment_text), 0, -1); update_pattern = (pp->pattern && pp->pattern[0])? !pattern || !pattern[0] || strcmp (pp->pattern, pattern) : pattern && pattern[0]; update_comment = (pp->comment && pp->comment[0])? !comment || !comment[0] || strcmp (pp->comment, comment) : comment && comment[0]; /* * Test everything but groups. * They are synchronized by pattern_set_groups() */ if (mode != pp->mode || update_comment || update_pattern) { if (!pp->dirty) { pp = player_pattern_new (pp); list->data = pp; } if (update_pattern) { if (pp->pattern) g_free (pp->pattern); pp->pattern = pattern; } if (update_comment) { if (pp->comment) g_free (pp->comment); pp->comment = comment; } if (pp->mode != mode || update_pattern) { free_player_pattern_compiled_data (pp); pp->mode = mode; player_pattern_compile (pp); } pattern_clist_update_row (pp, current_row); } if (!update_comment) g_free (comment); if (!update_pattern) g_free (pattern); }
int xfsm_splash_screen_choose (XfsmSplashScreen *splash, GList *sessions, const gchar *default_session, gchar **name_return) { GtkWidget *chooser; GtkWidget *label; GtkWidget *dialog; GtkWidget *entry; gchar title[256]; int result; g_assert (default_session != NULL); if (splash->engine.choose != NULL) { result = splash->engine.choose (&splash->engine, sessions, default_session, name_return); } else { again: xfsm_splash_screen_next (splash, _("Choose session")); chooser = g_object_new (XFSM_TYPE_CHOOSER, "screen", splash->engine.primary_screen, "type", GTK_WINDOW_POPUP, NULL); xfsm_window_add_border (GTK_WINDOW (chooser)); xfsm_chooser_set_sessions (XFSM_CHOOSER (chooser), sessions, default_session); result = xfsm_splash_screen_run (splash, chooser); if (result == XFSM_RESPONSE_LOAD) { if (name_return != NULL) *name_return = xfsm_chooser_get_session (XFSM_CHOOSER (chooser)); result = XFSM_CHOOSE_LOAD; } else if (result == XFSM_RESPONSE_NEW) { result = XFSM_CHOOSE_NEW; } else { result = XFSM_CHOOSE_LOGOUT; } gtk_widget_destroy (chooser); if (result == XFSM_CHOOSE_NEW) { xfsm_splash_screen_next (splash, _("Choose session name")); dialog = gtk_dialog_new_with_buttons (NULL, NULL, GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); g_snprintf (title, 256, "<big>%s</big>", _("Choose a name for the new session:")); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, TRUE, TRUE, 6); gtk_widget_show (label); entry = gtk_entry_new (); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), entry, TRUE, TRUE, 6); gtk_widget_show (entry); xfsm_window_add_border (GTK_WINDOW (dialog)); again1: result = xfsm_splash_screen_run (splash, dialog); if (result != GTK_RESPONSE_OK) { gtk_widget_destroy (dialog); goto again; } if (name_return != NULL) { *name_return = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); if (strlen (*name_return) == 0) { g_free (*name_return); goto again1; } } gtk_widget_destroy (dialog); result = XFSM_CHOOSE_NEW; } } return result; }
static gchar *input_dialog_open(const gchar *title, const gchar *message, const gchar *checkbtn_label, const gchar *default_string, gboolean default_checkbtn_state, gboolean *remember) { gchar *str; if (dialog && gtk_widget_get_visible(dialog)) return NULL; if (!dialog) input_dialog_create(FALSE); if (checkbtn_label) gtk_button_set_label(GTK_BUTTON(remember_checkbtn), checkbtn_label); else gtk_button_set_label(GTK_BUTTON(remember_checkbtn), _("Remember this")); input_dialog_set(title, message, default_string); gtk_window_present(GTK_WINDOW(dialog)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(remember_checkbtn), default_checkbtn_state); if (remember) gtk_widget_show(remember_checkbtn); else gtk_widget_hide(remember_checkbtn); gtk_window_set_modal(GTK_WINDOW(dialog), TRUE); manage_window_set_transient(GTK_WINDOW(dialog)); ack = fin = FALSE; while (fin == FALSE) gtk_main_iteration(); manage_window_focus_out(dialog, NULL, NULL); if (ack) { GtkEditable *editable; if (type == INPUT_DIALOG_COMBO) editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN((combo)))); else editable = GTK_EDITABLE(entry); str = gtk_editable_get_chars(editable, 0, -1); if (str && *str == '\0' && !is_pass) { g_free(str); str = NULL; } } else str = NULL; GTK_EVENTS_FLUSH(); if (remember) { *remember = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(remember_checkbtn)); } gtk_widget_destroy(dialog); dialog = NULL; if (is_pass) debug_print("return string = %s\n", str ? "********": ("none")); else debug_print("return string = %s\n", str ? str : "(none)"); return str; }
static void integer_tie_cb(GtkEditable *e, SettingsWidget *sw) { char *text = gtk_editable_get_chars(e, 0, -1); *(int*)sw->conf = atoi(text); g_free(text); }
static gboolean gdict_applet_draw (GdictApplet *applet) { GdictAppletPrivate *priv = applet->priv; GtkWidget *box; GtkWidget *hbox; gchar *text = NULL; if (priv->entry) text = gtk_editable_get_chars (GTK_EDITABLE (priv->entry), 0, -1); if (priv->box) gtk_widget_destroy (priv->box); #if GTK_CHECK_VERSION (3, 0, 0) box = gtk_box_new (priv->orient, 0); #else switch (priv->orient) { case GTK_ORIENTATION_VERTICAL: box = gtk_vbox_new (FALSE, 0); break; case GTK_ORIENTATION_HORIZONTAL: box = gtk_hbox_new (FALSE, 0); break; default: g_assert_not_reached (); break; } #endif gtk_container_add (GTK_CONTAINER (applet), box); gtk_widget_show (box); /* toggle button */ priv->toggle = gtk_toggle_button_new (); gtk_widget_set_tooltip_text (priv->toggle, _("Click to view the dictionary window")); set_atk_name_description (priv->toggle, _("Toggle dictionary window"), _("Show or hide the definition window")); gtk_button_set_relief (GTK_BUTTON (priv->toggle), GTK_RELIEF_NONE); g_signal_connect (priv->toggle, "toggled", G_CALLBACK (gdict_applet_icon_toggled_cb), applet); g_signal_connect (priv->toggle, "button-press-event", G_CALLBACK (gdict_applet_icon_button_press_event_cb), applet); gtk_box_pack_start (GTK_BOX (box), priv->toggle, FALSE, FALSE, 0); gtk_widget_show (priv->toggle); #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); #else hbox = gtk_hbox_new (FALSE, 0); #endif gtk_container_set_border_width (GTK_CONTAINER (hbox), 0); gtk_container_add (GTK_CONTAINER (priv->toggle), hbox); gtk_widget_show (hbox); if (priv->icon) { GdkPixbuf *scaled; priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); scaled = gdk_pixbuf_scale_simple (priv->icon, priv->size - 5, priv->size - 5, GDK_INTERP_BILINEAR); gtk_image_set_from_pixbuf (GTK_IMAGE (priv->image), scaled); g_object_unref (scaled); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } else { priv->image = gtk_image_new (); gtk_image_set_pixel_size (GTK_IMAGE (priv->image), priv->size - 10); gtk_image_set_from_icon_name (GTK_IMAGE (priv->image), "image-missing", -1); gtk_box_pack_start (GTK_BOX (hbox), priv->image, FALSE, FALSE, 0); gtk_widget_show (priv->image); } /* entry */ priv->entry = gtk_entry_new (); gtk_widget_set_tooltip_text (priv->entry, _("Type the word you want to look up")); set_atk_name_description (priv->entry, _("Dictionary entry"), _("Look up words in dictionaries")); gtk_editable_set_editable (GTK_EDITABLE (priv->entry), TRUE); gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 12); g_signal_connect (priv->entry, "activate", G_CALLBACK (gdict_applet_entry_activate_cb), applet); g_signal_connect (priv->entry, "button-press-event", G_CALLBACK (gdict_applet_entry_button_press_event_cb), applet); g_signal_connect (priv->entry, "key-press-event", G_CALLBACK (gdict_applet_entry_key_press_cb), applet); gtk_box_pack_end (GTK_BOX (box), priv->entry, FALSE, FALSE, 0); gtk_widget_show (priv->entry); if (text) { gtk_entry_set_text (GTK_ENTRY (priv->entry), text); g_free (text); } priv->box = box; #if 0 gtk_widget_grab_focus (priv->entry); #endif gtk_widget_show_all (GTK_WIDGET (applet)); return FALSE; }
static gboolean entry_event (GtkEditable *entry, GdkEventKey *event, PanelRunDialog *dialog) { GtkTreeSelection *selection; char *prefix; char *nospace_prefix; char *nprefix; char *temp; int pos, tmp; if (event->type != GDK_KEY_PRESS) return FALSE; /* if user typed something we're not using the list anymore */ dialog->use_program_list = FALSE; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->program_list)); gtk_tree_selection_unselect_all (selection); if (!panel_profile_get_enable_autocompletion ()) return FALSE; /* tab completion */ if (event->keyval == GDK_KEY_Tab) { gtk_editable_get_selection_bounds (entry, &pos, &tmp); if (dialog->completion_started && pos != tmp && pos != 1 && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { gtk_editable_select_region (entry, 0, 0); gtk_editable_set_position (entry, -1); return TRUE; } } else if (event->length > 0) { gtk_editable_get_selection_bounds (entry, &pos, &tmp); if (dialog->completion_started && pos != tmp && pos != 0 && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { temp = gtk_editable_get_chars (entry, 0, pos); prefix = g_strconcat (temp, event->string, NULL); g_free (temp); } else if (pos == tmp && tmp == strlen (gtk_entry_get_text (GTK_ENTRY (entry)))) { prefix = g_strconcat (gtk_entry_get_text (GTK_ENTRY (entry)), event->string, NULL); } else { return FALSE; } nospace_prefix = prefix; while (*nospace_prefix != '\0' && g_ascii_isspace (*nospace_prefix)) nospace_prefix++; if (*nospace_prefix == '\0') return FALSE; panel_run_dialog_update_completion (dialog, nospace_prefix); if (!dialog->completion) { g_free (prefix); return FALSE; } pos = strlen (prefix); nprefix = NULL; g_completion_complete_utf8 (dialog->completion, nospace_prefix, &nprefix); if (nprefix) { int insertpos; insertpos = 0; temp = g_strndup (prefix, nospace_prefix - prefix); g_free (prefix); prefix = g_strconcat (temp, nprefix, NULL); g_signal_handler_block (dialog->combobox, dialog->changed_id); gtk_editable_delete_text (entry, 0, -1); g_signal_handler_unblock (dialog->combobox, dialog->changed_id); gtk_editable_insert_text (entry, prefix, strlen (prefix), &insertpos); gtk_editable_set_position (entry, pos); gtk_editable_select_region (entry, pos, -1); dialog->completion_started = TRUE; g_free (temp); g_free (nprefix); g_free (prefix); return TRUE; } g_free (prefix); } return FALSE; }
/************************************************************************** Make a chat link at the current position or make the current selection clickable. **************************************************************************/ void inputline_make_chat_link(struct tile *ptile, bool unit) { char buf[MAX_LEN_MSG]; GtkWidget *entry = toolkit.entry; GtkEditable *editable = GTK_EDITABLE(entry); gint start_pos, end_pos; gchar *chars; struct unit *punit; /* Get the target. */ if (unit) { punit = find_visible_unit(ptile); if (!punit) { output_window_append(ftc_client, _("No visible unit on this tile.")); return; } } else { punit = NULL; } if (gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) { /* There is a selection, make it clickable. */ gpointer target; enum text_link_type type; chars = gtk_editable_get_chars(editable, start_pos, end_pos); if (punit) { type = TLT_UNIT; target = punit; } else if (tile_city(ptile)) { type = TLT_CITY; target = tile_city(ptile); } else { type = TLT_TILE; target = ptile; } if (0 != featured_text_apply_tag(chars, buf, sizeof(buf), TTT_LINK, 0, FT_OFFSET_UNSET, type, target)) { /* Replace the selection. */ gtk_editable_delete_text(editable, start_pos, end_pos); end_pos = start_pos; gtk_editable_insert_text(editable, buf, -1, &end_pos); gtk_widget_grab_focus(entry); gtk_editable_select_region(editable, start_pos, end_pos); } } else { /* Just insert the link at the current position. */ start_pos = gtk_editable_get_position(editable); end_pos = start_pos; chars = gtk_editable_get_chars(editable, MAX(start_pos - 1, 0), start_pos + 1); if (punit) { sz_strlcpy(buf, unit_link(punit)); } else if (tile_city(ptile)) { sz_strlcpy(buf, city_link(tile_city(ptile))); } else { sz_strlcpy(buf, tile_link(ptile)); } if (start_pos > 0 && strlen(chars) > 0 && chars[0] != ' ') { /* Maybe insert an extra space. */ gtk_editable_insert_text(editable, " ", 1, &end_pos); } gtk_editable_insert_text(editable, buf, -1, &end_pos); if (chars[start_pos > 0 ? 1 : 0] != '\0' && chars[start_pos > 0 ? 1 : 0] != ' ') { /* Maybe insert an extra space. */ gtk_editable_insert_text(editable, " ", 1, &end_pos); } gtk_widget_grab_focus(entry); gtk_editable_set_position(editable, end_pos); } g_free(chars); }
static void thunar_uca_editor_command_clicked (ThunarUcaEditor *uca_editor) { GtkFileFilter *filter; GtkWidget *chooser; gchar *filename; gchar **argv = NULL; gchar *s; gint argc; g_return_if_fail (THUNAR_UCA_IS_EDITOR (uca_editor)); chooser = gtk_file_chooser_dialog_new (_("Select an Application"), GTK_WINDOW (uca_editor), GTK_FILE_CHOOSER_ACTION_OPEN, _("_Cancel"), GTK_RESPONSE_CANCEL, _("_Open"), GTK_RESPONSE_ACCEPT, NULL); gtk_dialog_set_default_response (GTK_DIALOG (chooser), GTK_RESPONSE_ACCEPT); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (chooser), TRUE); /* add file chooser filters */ filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("All Files")); gtk_file_filter_add_pattern (filter, "*"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Executable Files")); gtk_file_filter_add_mime_type (filter, "application/x-csh"); gtk_file_filter_add_mime_type (filter, "application/x-executable"); gtk_file_filter_add_mime_type (filter, "application/x-perl"); gtk_file_filter_add_mime_type (filter, "application/x-python"); gtk_file_filter_add_mime_type (filter, "application/x-ruby"); gtk_file_filter_add_mime_type (filter, "application/x-shellscript"); gtk_file_filter_add_pattern (filter, "*.pl"); gtk_file_filter_add_pattern (filter, "*.py"); gtk_file_filter_add_pattern (filter, "*.rb"); gtk_file_filter_add_pattern (filter, "*.sh"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Perl Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-perl"); gtk_file_filter_add_pattern (filter, "*.pl"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Python Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-python"); gtk_file_filter_add_pattern (filter, "*.py"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Ruby Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-ruby"); gtk_file_filter_add_pattern (filter, "*.rb"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); filter = gtk_file_filter_new (); gtk_file_filter_set_name (filter, _("Shell Scripts")); gtk_file_filter_add_mime_type (filter, "application/x-csh"); gtk_file_filter_add_mime_type (filter, "application/x-shellscript"); gtk_file_filter_add_pattern (filter, "*.sh"); gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (chooser), filter); /* use the bindir as default folder */ gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (chooser), BINDIR); /* setup the currently selected file */ filename = gtk_editable_get_chars (GTK_EDITABLE (uca_editor->command_entry), 0, -1); if (G_LIKELY (filename != NULL)) { /* use only the first argument */ s = strchr (filename, ' '); if (G_UNLIKELY (s != NULL)) *s = '\0'; /* check if we have a file name */ if (G_LIKELY (*filename != '\0')) { /* check if the filename is not an absolute path */ if (G_LIKELY (!g_path_is_absolute (filename))) { /* try to lookup the filename in $PATH */ s = g_find_program_in_path (filename); if (G_LIKELY (s != NULL)) { /* use the absolute path instead */ g_free (filename); filename = s; } } /* check if we have an absolute path now */ if (G_LIKELY (g_path_is_absolute (filename))) gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (chooser), filename); } /* release the filename */ g_free (filename); } /* run the chooser dialog */ if (gtk_dialog_run (GTK_DIALOG (chooser)) == GTK_RESPONSE_ACCEPT) { /* determine the path to the selected file */ filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser)); /* check if we need to quote the filename */ if (!g_shell_parse_argv (filename, &argc, &argv, NULL) || argc > 1) { /* shell is unable to interpret properly without quoting */ s = g_shell_quote (filename); g_free (filename); filename = s; } g_strfreev (argv); /* append %f to filename, user may change that afterwards */ s = g_strconcat (filename, " %f", NULL); gtk_entry_set_text (GTK_ENTRY (uca_editor->command_entry), s); g_free (filename); g_free (s); } gtk_widget_destroy (chooser); }
G_MODULE_EXPORT gboolean create_tick_group_event(GtkWidget * widget, gpointer data) { GtkWidget *dialog = NULL; GtkWidget *dummy = NULL; MtxTickGroup *tgroup = NULL; gchar * filename = NULL; gfloat tmp1 = 0.0; gfloat tmp2 = 0.0; gint result = 0; MtxGaugeFace *g = NULL; GError *error = NULL; if (GTK_IS_WIDGET(gauge)) g = MTX_GAUGE_FACE(gauge); if (!GTK_IS_WIDGET(gauge)) return FALSE; filename = get_file(g_build_filename(GAUGEDESIGNER_GLADE_DIR,"tgroup.ui",NULL),NULL); if (filename) { tgroups = gtk_builder_new(); if(!gtk_builder_add_from_file(tgroups,filename, &error)) { g_warning ("Couldn't load builder file: %s", error->message); g_error_free(error); exit(-1); } g_free(filename); } else { printf("Can't locate primary ui file!!!!\n"); exit(-1); } gtk_builder_connect_signals(tgroups,NULL); dialog = GTK_WIDGET (gtk_builder_get_object(tgroups,"tgroup_dialog")); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&white); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&black); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&white); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&black); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&white); gtk_color_button_set_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&black); OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_lowpoint_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"high_angle",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_start_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_LOW_UNIT_PARTNER)); OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_highpoint_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"low_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")),"spin_handler", GINT_TO_POINTER(ADJ_HIGH_UNIT_PARTNER)); OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"lowpartner",gtk_builder_get_object(tgroups,"tg_start_angle_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_lowpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_START_ANGLE_PARTNER)); OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"highpartner",gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"start_angle",gtk_builder_get_object(tgroups,"tg_start_angle_spin")); OBJ_SET((gtk_builder_get_object(tgroups,"tg_highpoint_spin")),"spin_handler", GINT_TO_POINTER(ADJ_SWEEP_ANGLE_PARTNER)); if (MTX_IS_GAUGE_FACE(g)) { mtx_gauge_face_get_attribute(g,START_ANGLE,&tmp1); mtx_gauge_face_get_attribute(g,SWEEP_ANGLE,&tmp2); dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_start_angle_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp1); dummy = GTK_WIDGET(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin")); gtk_spin_button_set_value(GTK_SPIN_BUTTON(dummy),tmp2); } if (!GTK_IS_WIDGET(dialog)) { return FALSE; } result = gtk_dialog_run(GTK_DIALOG(dialog)); switch (result) { case GTK_RESPONSE_APPLY: tgroup = g_new0(MtxTickGroup, 1); tgroup->font = (gchar *)gtk_font_button_get_font_name (GTK_FONT_BUTTON(gtk_builder_get_object(tgroups,"tg_tick_fontbutton"))); tgroup->font = g_strchomp(g_strdelimit(tgroup->font,"0123456789",' ')); tgroup->text = gtk_editable_get_chars(GTK_EDITABLE(gtk_builder_get_object(tgroups,"tg_tick_textentry")),0,-1); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_day_colorbutton")),&tgroup->text_color[MTX_DAY]); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_text_nite_colorbutton")),&tgroup->text_color[MTX_NITE]); tgroup->font_scale = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_font_scale_spin"))); tgroup->text_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_text_inset_spin"))); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_day_colorbutton")),&tgroup->maj_tick_color[MTX_DAY]); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_nite_colorbutton")),&tgroup->maj_tick_color[MTX_NITE]); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_day_colorbutton")),&tgroup->min_tick_color[MTX_DAY]); gtk_color_button_get_color(GTK_COLOR_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_nite_colorbutton")),&tgroup->min_tick_color[MTX_NITE]); tgroup->maj_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_inset_spin"))); tgroup->min_tick_inset = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_inset_spin"))); tgroup->maj_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_width_spin"))); tgroup->min_tick_width = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_width_spin"))); tgroup->maj_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_maj_tick_length_spin"))); tgroup->min_tick_length = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_min_tick_length_spin"))); tgroup->start_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_start_angle_spin"))); tgroup->sweep_angle = gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_sweep_angle_spin"))); tgroup->num_maj_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_maj_ticks_spin"))); tgroup->num_min_ticks = (gint)gtk_spin_button_get_value(GTK_SPIN_BUTTON(gtk_builder_get_object(tgroups,"tg_num_min_ticks_spin"))); changed = TRUE; mtx_gauge_face_set_tick_group_struct(MTX_GAUGE_FACE(gauge),tgroup); g_free(tgroup->text); g_free(tgroup); update_onscreen_tgroups(); break; default: break; } if (GTK_IS_WIDGET(dialog)) gtk_widget_destroy(dialog); return (FALSE); }
uint8_t DIA_ass(ASSParams *param) { uint8_t r=0; GtkWidget *dialog=create_dialog1(); gtk_register_dialog(dialog); SPIN_SET(spinbuttonScale,font_scale); SPIN_SET(spinbuttonSpacing,line_spacing); SPIN_SET(spinbuttonTop,top_margin); SPIN_SET(spinbuttonBottom,bottom_margin); if(param->subfile) { int r; char *s=(char *)(param->subfile); gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1); gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), s, strlen(s), &r); } ASSOCIATE(button1,LOADSUB); /* Upload */ int x=0,d; while(!x) { d=gtk_dialog_run(GTK_DIALOG(dialog)); switch(d) { case LOADSUB: { char *name=NULL; GUI_FileSelRead("Select ASS/SSA file",&name); if(name) { int r; gtk_editable_delete_text(GTK_EDITABLE(WID(entrySub)), 0,-1); gtk_editable_insert_text(GTK_EDITABLE(WID(entrySub)), name, strlen(name), &r); ADM_dealloc(name); } } break; case GTK_RESPONSE_OK: case GTK_RESPONSE_APPLY: { SPIN_GET(spinbuttonScale,font_scale); SPIN_GET(spinbuttonSpacing,line_spacing); SPIN_GETI(spinbuttonTop,top_margin); SPIN_GETI(spinbuttonBottom,bottom_margin); char *n; if(param->subfile) { ADM_dealloc(param->subfile); param->subfile=NULL; } n=gtk_editable_get_chars(GTK_EDITABLE (WID(entrySub)), 0, -1); printf("Name :%s\n",n); param->subfile=(ADM_filename *)ADM_strdup(n); r=1; x=1; break; } default: r=0; x=1; break; } } gtk_unregister_dialog(dialog); gtk_widget_destroy(dialog); return r; }
void request_command_and_user (GksuContext *context) { GtkWidget *dialog; GtkWidget *hbox; GtkWidget *lvbox; GtkWidget *rvbox; GtkWidget *image; GtkWidget *label_cmd; GtkWidget *entry_cmd; GtkWidget *label_user; GtkWidget *combo_user; /* advanced stuff */ GtkWidget *advanced_button; gint response; gchar *tmp = NULL; dialog = gtk_dialog_new_with_buttons (_("Run program"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE); /* horizontal box */ hbox = gtk_hbox_new (FALSE, 4); gtk_container_set_border_width (GTK_CONTAINER(hbox), 5); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 2); /* left vertical box */ lvbox = gtk_vbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX(hbox), lvbox, TRUE, TRUE, 0); /* command */ label_cmd = gtk_label_new (_("Run:")); gtk_label_set_justify (GTK_LABEL(label_cmd), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(lvbox), label_cmd, TRUE, TRUE, 0); entry_cmd = gtk_entry_new (); gtk_signal_connect (GTK_OBJECT(entry_cmd), "activate", GTK_SIGNAL_FUNC(response_ok_cb), dialog); gtk_box_pack_start (GTK_BOX(lvbox), entry_cmd, TRUE, TRUE, 0); /* user name */ label_user = gtk_label_new (_("As user:"******"/pixmaps/gksu-icon.png"); gtk_box_pack_start (GTK_BOX(rvbox), image, TRUE, TRUE, 0); /* advanced button */ advanced_button = gtk_button_new_with_mnemonic (_("_Advanced")); g_signal_connect (G_OBJECT(advanced_button), "clicked", G_CALLBACK(show_hide_advanced), context); gtk_box_pack_start (GTK_BOX(rvbox), advanced_button, TRUE, FALSE, 0); /* let the magic begin! */ gtk_widget_show_all (dialog); while (TRUE) { response = gtk_dialog_run (GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_NONE: exit (0); } tmp = gtk_editable_get_chars (GTK_EDITABLE(entry_cmd), 0, -1); if (tmp) { gksu_context_set_command (context, tmp); g_free (tmp); } tmp = gtk_combo_box_get_active_text (GTK_COMBO_BOX(combo_user)); if (tmp) { gksu_context_set_user (context, tmp); g_free (tmp); } if (!strcmp (gksu_context_get_user (context), "")) { gk_dialog (GTK_MESSAGE_ERROR, _("Missing command to run.")); } else { gtk_widget_destroy (dialog); break; } } }
static getEndTuple sxftd_get_end_info(SXFromTransInfo *sxfti) { getEndTuple retval; GtkWidget *w; retval.type = BAD_END; g_date_clear( &(retval.end_date), 1 ); retval.n_occurrences = 0; w = glade_xml_get_widget(sxfti->gxml, SXFTD_NEVER_END_BUTTON); if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w))) { retval.type = NEVER_END; return retval; } w = glade_xml_get_widget(sxfti->gxml, SXFTD_END_ON_DATE_BUTTON); if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w))) { time_t end_tt; retval.type = END_ON_DATE; g_date_clear( &(retval.end_date), 1 ); end_tt = gnc_date_edit_get_date(sxfti->endDateGDE); g_date_set_time_t( &(retval.end_date), end_tt); return retval; } w = glade_xml_get_widget(sxfti->gxml, SXFTD_N_OCCURRENCES_BUTTON); if (gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(w) )) { gchar *text, *endptr; guint n_occs; w = glade_xml_get_widget(sxfti->gxml, SXFTD_N_OCCURRENCES_ENTRY); text = gtk_editable_get_chars(GTK_EDITABLE(w), 0, -1); if (text == NULL || strlen(text) == 0) { n_occs = 0; } else { n_occs = strtoul(text, &endptr, 10); if ( !endptr ) { n_occs = -1; } } g_free(text); if (n_occs > 0) { retval.type = END_AFTER_N_OCCS; retval.n_occurrences = n_occs; return retval; } } return retval; }
static void search_entry_insert_text (GtkEditable *editable, const gchar *text, gint length, gint *position, GeditViewFrame *frame) { if (frame->priv->search_mode == GOTO_LINE) { gunichar c; const gchar *p; const gchar *end; const gchar *next; p = text; end = text + length; if (p == end) return; c = g_utf8_get_char (p); if (((c == '-' || c == '+') && *position == 0) || (c == ':' && *position != 0)) { gchar *s = NULL; if (c == ':') { s = gtk_editable_get_chars (editable, 0, -1); s = g_utf8_strchr (s, -1, ':'); } if (s == NULL || s == p) { next = g_utf8_next_char (p); p = next; } g_free (s); } while (p != end) { next = g_utf8_next_char (p); c = g_utf8_get_char (p); if (!g_unichar_isdigit (c)) { g_signal_stop_emission_by_name (editable, "insert_text"); gtk_widget_error_bell (frame->priv->search_entry); break; } p = next; } } else { /* SEARCH mode */ static gboolean insert_text = FALSE; gchar *escaped_text; gint new_len; gedit_debug_message (DEBUG_SEARCH, "Text: %s", text); /* To avoid recursive behavior */ if (insert_text) return; escaped_text = gedit_utils_escape_search_text (text); gedit_debug_message (DEBUG_SEARCH, "Escaped Text: %s", escaped_text); new_len = strlen (escaped_text); if (new_len == length) { g_free (escaped_text); return; } insert_text = TRUE; g_signal_stop_emission_by_name (editable, "insert_text"); gtk_editable_insert_text (editable, escaped_text, new_len, position); insert_text = FALSE; g_free (escaped_text); } }