wxTextPos wxTextCtrl::GetLastPosition() const { wxCHECK_MSG( m_text != NULL, 0, wxT("invalid text ctrl") ); int pos = 0; if (m_windowStyle & wxTE_MULTILINE) { pos = gtk_text_get_length( GTK_TEXT(m_text) ); } else { pos = GTK_ENTRY(m_text)->text_length; } return (long)pos; }
void gtkurl_uncheck_all(GtkText *gtktext) { gint origpos; gchar *text; gfloat adj_value; adj_value = gtktext->vadj->value; gtk_text_freeze(gtktext); origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); text = gtk_editable_get_chars(GTK_EDITABLE(gtktext), 0, -1); gtk_text_set_point(gtktext, 0); gtk_text_forward_delete(gtktext, gtk_text_get_length(gtktext)); gtk_text_insert(gtktext, NULL, NULL, NULL, text, strlen(text)); gtk_text_thaw(gtktext); gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); gtk_adjustment_set_value(gtktext->vadj, adj_value); }
static void set_text_buffer(GtkWidget *widget, const char *text) { GtkText *buffer; g_return_if_fail(widget); g_return_if_fail(text); buffer = GTK_TEXT(widget); g_return_if_fail(buffer); gtk_text_freeze(buffer); gtk_text_set_point(buffer, 0); gtk_text_forward_delete(buffer, gtk_text_get_length(buffer)); gtk_text_set_point(buffer, 0); gtk_text_insert(buffer, NULL, NULL, NULL, lazy_utf8_to_ui_string(text), (-1)); gtk_text_thaw(buffer); }
wxString wxTextCtrl::DoGetValue() const { wxCHECK_MSG( m_text != NULL, wxEmptyString, wxT("invalid text ctrl") ); wxString tmp; if (m_windowStyle & wxTE_MULTILINE) { gint len = gtk_text_get_length( GTK_TEXT(m_text) ); char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), 0, len ); tmp = text; g_free( text ); } else { tmp = wxGTK_CONV_BACK( gtk_entry_get_text( GTK_ENTRY(m_text) ) ); } return tmp; }
EXPORT void wTextClear( wText_p bt ) { #ifdef USE_TEXTVIEW GtkTextBuffer * tb; #endif if (bt->text == 0) abort(); #ifdef USE_TEXTVIEW tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(bt->text) ); gtk_text_buffer_set_text( tb, "", -1 ); if (bt->option & BO_READONLY) gtk_text_view_set_editable( GTK_TEXT_VIEW(bt->text), FALSE ); #else gtk_text_set_point( GTK_TEXT(bt->text), 0 ); gtk_text_forward_delete( GTK_TEXT(bt->text), gtk_text_get_length( GTK_TEXT(bt->text) ) ); if (bt->option & BO_READONLY) gtk_text_set_editable( GTK_TEXT(bt->text), FALSE ); #endif bt->changed = FALSE; }
void clearlog (gpointer data) { gint len; #if GTK_MAJOR_VERSION == 1 len = gtk_text_get_length (GTK_TEXT (logwdw)); gtk_text_set_point (GTK_TEXT (logwdw), len); gtk_text_backward_delete (GTK_TEXT (logwdw), len); #else GtkTextBuffer * textbuf; GtkTextIter iter, iter2; textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw)); len = gtk_text_buffer_get_char_count (textbuf); gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0); gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, len); gtk_text_buffer_delete (textbuf, &iter, &iter2); #endif }
void clear_text_page(gboolean add, gint *uncommitted) { guint len; gint ucm; ucm = *uncommitted; gtk_entry_set_text(GTK_ENTRY(sp->title_entry), ""); if (add == TRUE) { time_label_set_time(TIME_LABEL(sp->tlabel_created), time(NULL)); } else { time_label_set_time(TIME_LABEL(sp->tlabel_created), -1); } time_label_set_time(TIME_LABEL(sp->tlabel_changed), -1); if (add == TRUE) { gtk_label_set_text(GTK_LABEL(sp->label_changes), _("0")); } else { gtk_label_set_text(GTK_LABEL(sp->label_changes), ""); } time_label_set_time(TIME_LABEL(sp->tlabel_expire), -1); gtk_entry_set_text(GTK_ENTRY(sp->note_id_entry), ""); gnome_date_edit_set_time(GNOME_DATE_EDIT(sp->de_deadline), 0); gtk_entry_set_text(GTK_ENTRY(sp->prio_entry), ""); gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sp->todo_check), FALSE); gtk_adjustment_set_value(GTK_ADJUSTMENT(sp->ad_complete), 0); len = gtk_text_get_length(GTK_TEXT(sp->text_entry)); if (len) { gtk_text_freeze(GTK_TEXT(sp->text_entry)); gtk_text_set_point(GTK_TEXT(sp->text_entry), 0); gtk_text_forward_delete(GTK_TEXT(sp->text_entry), len); gtk_text_thaw(GTK_TEXT(sp->text_entry)); } *uncommitted = ucm; }
static void find_dialog_cb(GtkWidget *widget, gpointer data) { gchar *tmp_text; g_return_if_fail(widget != NULL); g_return_if_fail(GNOME_IS_FIND_DIALOG(widget)); tmp_text = gnome_find_dialog_get_find_text(GNOME_FIND_DIALOG(widget)); if(find_params.find_text != NULL) { if(strcmp(find_params.find_text, tmp_text) != 0) { line_cache_update = TRUE; } g_free(find_params.find_text); } if(find_params.regex != GNOME_FIND_DIALOG(widget)->params.regex) line_cache_update = TRUE; find_params = GNOME_FIND_DIALOG(widget)->params; find_params.find_text = tmp_text; switch(find_params.start_pos) { case GNOME_FIND_TOP: find_pos = 0; break; case GNOME_FIND_CURSOR: find_pos = gtk_editable_get_position(GTK_EDITABLE(R_gtk_terminal_text)); break; case GNOME_FIND_BOTTOM: find_pos = gtk_text_get_length(GTK_TEXT(R_gtk_terminal_text)) - 1; break; } find_pos_init = find_pos; search_wrapped = FALSE; R_gtk_terminal_find(GNOME_FIND_DIALOG(widget)); }
static gchar *get_word_from_pos(GtkText* gtktext, gint pos, gint *pstart, gint *pend) { GString *word = g_string_new(""); gint start, end; gchar ch; if (iswordsep(GTK_TEXT_INDEX(gtktext, pos))) return(NULL); /* Get start and end position from the word */ for (start = pos; start >= 0; --start) if (iswordsep(GTK_TEXT_INDEX(gtktext, start))) break; start++; for (end = pos; end < gtk_text_get_length(gtktext); end++) if (iswordsep(GTK_TEXT_INDEX(gtktext, end)) ) break; /* Be sure to not include punctation marks etc. */ for ( ;end>start; end-- ) { ch = GTK_TEXT_INDEX(gtktext, end-1); if( isalpha(ch) || isdigit(ch) || ch == ':' ) break; } /* Get the word (everyting between start and end */ for (pos = start; pos < end; pos++) g_string_append_c( word, GTK_TEXT_INDEX(gtktext, pos) ); if (pstart) *pstart = start; if (pend) *pend = end; return(word->str); }
EXPORT wBool_t wTextSave( wText_p bt, const char * fileName ) { #ifndef USE_TEXTVIEW int siz, pos, cnt; #endif FILE * f; char * cp; f = fopen( fileName, "w" ); if (f==NULL) { wNoticeEx( NT_ERROR, fileName, "Ok", NULL ); return FALSE; } #ifdef USE_TEXTVIEW cp = gtkGetText( bt ); fwrite( cp, 1, strlen(cp), f ); free(cp); #else siz = gtk_text_get_length( GTK_TEXT(bt->text) ); pos = 0; cnt = BUFSIZ; while (pos<siz) { if (pos+cnt>siz) cnt = siz-pos; cp = gtk_editable_get_chars( GTK_EDITABLE(bt->text), pos, pos+cnt ); if (cp == NULL) break; fwrite( cp, 1, cnt, f ); free(cp); pos += cnt; } #endif fclose(f); return TRUE; }
void gtkspell_check_all(GtkText *gtktext) { guint origpos; guint pos = 0; guint len; float adj_value; if (!gtkspell_running()) return; len = gtk_text_get_length(gtktext); adj_value = gtktext->vadj->value; gtk_text_freeze(gtktext); origpos = gtk_editable_get_position(GTK_EDITABLE(gtktext)); while (pos < len) { while (pos < len && iswordsep(GTK_TEXT_INDEX(gtktext, pos))) pos++; while (pos < len && !iswordsep(GTK_TEXT_INDEX(gtktext, pos))) pos++; if (pos > 0) check_at(gtktext, pos-1); } gtk_text_thaw(gtktext); gtk_editable_set_position(GTK_EDITABLE(gtktext), origpos); }
EXPORT wBool_t wTextPrint( wText_p bt ) { wPrinterStream_p f; #ifndef USE_TEXTVIEW int siz, pos, cnt; #endif char * cp; f = wPrinterOpen(); if (f==NULL) { return FALSE; } #ifdef USE_TEXTVIEW cp = gtkGetText( bt ); wPrinterWrite( f, cp, strlen(cp) ); free(cp); #else siz = gtk_text_get_length( GTK_TEXT(bt->text) ); pos = 0; cnt = BUFSIZ; while (pos<siz) { if (pos+cnt>siz) cnt = siz-pos; cp = gtk_editable_get_chars( GTK_EDITABLE(bt->text), pos, pos+cnt ); if (cp == NULL) break; wPrinterWrite( f, cp, cnt ); free(cp); pos += cnt; } #endif wPrinterClose(f); return TRUE; }
void file_info (gint CurrentPage) { GtkWidget *FileInfoWindow; GtkWidget *Button; GtkWidget *HBox; GtkWidget *FileInfoLabelLeft, *FileInfoLabelRight; gint BufferSize, FileSize, Difference; gboolean NewFile = FALSE; if (!OpenedFilesCnt) return; if (stat (FPROPS(CurrentPage, Name), &FPROPS(CurrentPage, Stats)) == -1) NewFile = TRUE; BufferSize = gtk_text_get_length (GTK_TEXT(FPROPS(CurrentPage, Text))); FileSize = NewFile ? 0 : (gint)FPROPS(CurrentPage, Stats).st_size; Difference = BufferSize - FileSize; FileInfoWindow = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW(FileInfoWindow), "File Information"); gtk_window_set_policy (GTK_WINDOW(FileInfoWindow), FALSE, FALSE, FALSE); gtk_signal_connect_object (GTK_OBJECT(FileInfoWindow), "delete_event", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(FileInfoWindow)); gtk_signal_connect_object (GTK_OBJECT (FileInfoWindow), "destroy", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(FileInfoWindow)); HBox = gtk_hbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER(HBox), 5); FileInfoLabelLeft = gtk_label_new ("Base name :" "\nFull name :" "\nLanguage :" "\n" "\nModified :" "\nReadonly :" "\n" "\nBuffer Size :" "\nFile Size :" "\nDifference :" #ifndef WIN32 "\n" "\nPermissions :" "\nOwner UID :" "\nOwner GID :" #endif ); gtk_label_set_justify (GTK_LABEL(FileInfoLabelLeft), GTK_JUSTIFY_LEFT); FileInfoLabelRight = gtk_label_new (g_strconcat (FPROPS(CurrentPage, BaseName), "\n", FPROPS(CurrentPage, Name), "\n", FPROPS(CurrentPage, WidgetInfo.Lg) == -1 ? UNKNOWN : Prefs.L[FPROPS(CurrentPage, WidgetInfo.Lg)].Description, "\n", "\n", FPROPS(CurrentPage, Changed[0]) ? "Yes" : "No", "\n", FPROPS(CurrentPage, ReadOnly) ? "Yes" : "No", "\n", "\n", g_strdup_printf ("%d", BufferSize), ((BufferSize == -1) || (BufferSize == 0) || (BufferSize == 1)) ? " Byte" : " Bytes", "\n", g_strdup_printf ("%d", FileSize), ((FileSize == -1) || (FileSize == 0) || (FileSize == 1)) ? " Byte" : " Bytes", "\n", g_strdup_printf ("%d", Difference), ((Difference == -1) || (Difference == 0) || (Difference == 1)) ? " Byte" : " Bytes", #ifndef WIN32 "\n", "\n", NewFile ? UNKNOWN : get_file_mode (FPROPS(CurrentPage, Stats)), "\n", NewFile ? UNKNOWN : g_strdup_printf ("%d", FPROPS(CurrentPage, Stats).st_uid), "\n", NewFile ? UNKNOWN : g_strdup_printf ("%d", FPROPS(CurrentPage, Stats).st_gid), #endif NULL)); gtk_label_set_justify (GTK_LABEL(FileInfoLabelRight), GTK_JUSTIFY_LEFT); gtk_box_pack_start (GTK_BOX(HBox), FileInfoLabelLeft, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX(HBox), FileInfoLabelRight, FALSE, FALSE, 5); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(FileInfoWindow) -> vbox), HBox, FALSE, FALSE, 5); Button = gtk_button_new_with_label (" Close "); gtk_signal_connect_object (GTK_OBJECT(Button), "clicked", (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT(FileInfoWindow)); GTK_WIDGET_SET_FLAGS (Button, GTK_CAN_DEFAULT); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(FileInfoWindow) -> action_area), Button, TRUE, TRUE, 0); gtk_widget_grab_default (Button); gtk_widget_show_all (FileInfoWindow); print_msg ("Display File Information window..."); }
static void dosavelog (GtkWidget * widget, GtkFileSelection * fs) { const char *filename; char *txt, *pos; gint textlen; ssize_t len; FILE *fd; int ok; #if GTK_MAJOR_VERSION > 1 GtkTextBuffer * textbuf; GtkTextIter iter, iter2; #endif filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)); if ((fd = fopen (filename, "w")) == NULL) { ftp_log (gftp_logging_error, NULL, _("Error: Cannot open %s for writing: %s\n"), filename, g_strerror (errno)); return; } #if GTK_MAJOR_VERSION == 1 textlen = gtk_text_get_length (GTK_TEXT (logwdw)); txt = gtk_editable_get_chars (GTK_EDITABLE (logwdw), 0, -1); #else textbuf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (logwdw)); textlen = gtk_text_buffer_get_char_count (textbuf); gtk_text_buffer_get_iter_at_offset (textbuf, &iter, 0); gtk_text_buffer_get_iter_at_offset (textbuf, &iter2, textlen); txt = gtk_text_buffer_get_text (textbuf, &iter, &iter2, 0); /* gtk_text_buffer_get_char_count() returns the number of characters, not bytes. So get the number of bytes that need to be written out */ textlen = strlen (txt); #endif ok = 1; pos = txt; do { if ((len = write (fileno (fd), pos, textlen)) == -1) { ok = 0; ftp_log (gftp_logging_error, NULL, _("Error: Error writing to %s: %s\n"), filename, g_strerror (errno)); break; } textlen -= len; pos += len; } while (textlen > 0); if (ok) ftp_log (gftp_logging_misc, NULL, _("Successfully wrote the log file to %s\n"), filename); fclose (fd); g_free (txt); }
static void handle_input(gpointer client_data, gint source, GdkInputCondition ic) { int message; gtk_pipe_int_read(&message); switch (message) { case REFRESH_MESSAGE: g_warning("REFRESH MESSAGE IS OBSOLETE !!!"); break; case TOTALTIME_MESSAGE: { int tt; int minutes,seconds; char local_string[20]; GtkObject *adj; gtk_pipe_int_read(&tt); seconds=max_sec=tt/play_mode->rate; minutes=seconds/60; seconds-=minutes*60; sprintf(local_string,"/ %i:%02i",minutes,seconds); gtk_label_set(GTK_LABEL(tot_lbl), local_string); /* Readjust the time scale */ adj = gtk_adjustment_new(0., 0., (gfloat)max_sec, 1., 10., 0.); gtk_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(generic_scale_cb), (gpointer)GTK_CHANGE_LOCATOR); gtk_range_set_adjustment(GTK_RANGE(locator), GTK_ADJUSTMENT(adj)); } break; case MASTERVOL_MESSAGE: { int volume; GtkAdjustment *adj; gtk_pipe_int_read(&volume); adj = gtk_range_get_adjustment(GTK_RANGE(vol_scale)); my_adjustment_set_value(adj, MAX_AMPLIFICATION - volume); } break; case FILENAME_MESSAGE: { char filename[255], title[255]; char *pc; gtk_pipe_string_read(filename); /* Extract basename of the file */ pc = strrchr(filename, '/'); if (pc == NULL) pc = filename; else pc++; sprintf(title, "Timidity %s - %s", timidity_version, pc); gtk_window_set_title(GTK_WINDOW(window), title); /* Clear the text area. */ #ifdef HAVE_GTK_2 textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text)); gtk_text_buffer_get_start_iter(textbuf, &start_iter); gtk_text_buffer_get_end_iter(textbuf, &end_iter); iter = start_iter; #else gtk_text_freeze(GTK_TEXT(text)); gtk_text_set_point(GTK_TEXT(text), 0); gtk_text_forward_delete(GTK_TEXT(text), gtk_text_get_length(GTK_TEXT(text))); gtk_text_thaw(GTK_TEXT(text)); #endif } break; case FILE_LIST_MESSAGE: { gchar filename[255], *fnames[2]; gint i, number_of_files; /* reset the playing list : play from the start */ file_number_to_play = -1; gtk_pipe_int_read(&number_of_files); for (i = 0; i < number_of_files; i++) { gtk_pipe_string_read(filename); fnames[0] = filename; fnames[1] = NULL; gtk_clist_append(GTK_CLIST(clist), fnames); } gtk_clist_columns_autosize(GTK_CLIST(clist)); } break; case NEXT_FILE_MESSAGE: case PREV_FILE_MESSAGE: case TUNE_END_MESSAGE: { int nbfile; /* When a file ends, launch next if auto_next toggle */ if ( (message==TUNE_END_MESSAGE) && !GTK_CHECK_MENU_ITEM(auto_next)->active ) return; /* Total number of file to play in the list */ nbfile = GTK_CLIST(clist)->rows; if (message == PREV_FILE_MESSAGE) file_number_to_play--; else file_number_to_play++; /* Do nothing if requested file is before first one */ if (file_number_to_play < 0) { file_number_to_play = 0; return; } /* Stop after playing the last file */ if (file_number_to_play >= nbfile) { file_number_to_play = nbfile - 1; return; } if(gtk_clist_row_is_visible(GTK_CLIST(clist), file_number_to_play) != GTK_VISIBILITY_FULL) { gtk_clist_moveto(GTK_CLIST(clist), file_number_to_play, -1, 1.0, 0.0); } gtk_clist_select_row(GTK_CLIST(clist), file_number_to_play, 0); } break; case CURTIME_MESSAGE: { int seconds, minutes; int nbvoice; char local_string[20]; gtk_pipe_int_read(&seconds); gtk_pipe_int_read(&nbvoice); if( is_quitting ) return; minutes=seconds/60; sprintf(local_string,"%2d:%02d", minutes, (int)(seconds % 60)); gtk_label_set(GTK_LABEL(cnt_lbl), local_string); /* Readjust the time scale if not dragging the scale */ if( !locating && (seconds <= max_sec)) { GtkAdjustment *adj; adj = gtk_range_get_adjustment(GTK_RANGE(locator)); my_adjustment_set_value(adj, (gfloat)seconds); } } break; case NOTE_MESSAGE: { int channel; int note; gtk_pipe_int_read(&channel); gtk_pipe_int_read(¬e); g_warning("NOTE chn%i %i", channel, note); } break; case PROGRAM_MESSAGE: { int channel; int pgm; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&pgm); g_warning("NOTE chn%i %i", channel, pgm); } break; case VOLUME_MESSAGE: { int channel; int volume; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&volume); g_warning("VOLUME= chn%i %i", channel, volume); } break; case EXPRESSION_MESSAGE: { int channel; int express; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&express); g_warning("EXPRESSION= chn%i %i", channel, express); } break; case PANNING_MESSAGE: { int channel; int pan; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&pan); g_warning("PANNING= chn%i %i", channel, pan); } break; case SUSTAIN_MESSAGE: { int channel; int sust; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&sust); g_warning("SUSTAIN= chn%i %i", channel, sust); } break; case PITCH_MESSAGE: { int channel; int bend; gtk_pipe_int_read(&channel); gtk_pipe_int_read(&bend); g_warning("PITCH BEND= chn%i %i", channel, bend); } break; case RESET_MESSAGE: g_warning("RESET_MESSAGE"); break; case CLOSE_MESSAGE: gtk_exit(0); break; case CMSG_MESSAGE: { int type; char message[1000]; #ifdef HAVE_GTK_2 gchar *message_u8; #endif gtk_pipe_int_read(&type); gtk_pipe_string_read(message); #ifdef HAVE_GTK_2 message_u8 = g_locale_to_utf8( message, -1, NULL, NULL, NULL ); gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter); gtk_text_buffer_insert(textbuf, &end_iter, message_u8, -1); gtk_text_buffer_insert(textbuf, &end_iter, "\n", 1); gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter); mark = gtk_text_buffer_create_mark(textbuf, NULL, &end_iter, 1); gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, 0, 0.0, 1.0); gtk_text_buffer_delete_mark(textbuf, mark); g_free( message_u8 ); #else gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL, message, -1); gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL, "\n", 1); #endif } break; case LYRIC_MESSAGE: { char message[1000]; #ifdef HAVE_GTK_2 gchar *message_u8; #endif gtk_pipe_string_read(message); #ifdef HAVE_GTK_2 message_u8 = g_locale_to_utf8( message, -1, NULL, NULL, NULL ); gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter); // mod JN iter -> end_iter gtk_text_buffer_insert(textbuf, &end_iter, message_u8, -1); gtk_text_buffer_get_bounds(textbuf, &start_iter, &end_iter); mark = gtk_text_buffer_create_mark(textbuf, NULL, &end_iter, 1); gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, 0, 0.0, 1.0); gtk_text_buffer_delete_mark(textbuf, mark); #else gtk_text_insert(GTK_TEXT(text), NULL, NULL, NULL, message, -1); #endif } break; default: g_warning("UNKNOWN Gtk+ MESSAGE %i", message); } }
static void cb_decrypt(GtkWidget *w, gpointer p) { GtkWidget *pass_entry; GtkWidget *warn_w; FILE *pgpin; FILE *pgpout; FILE *pgperr; static gchar sys_buf[] = "pgpv -qzd +batchmode +force -o - %s"; gchar tmpbuf[1024]; gchar *tmpfname; gchar *tmpcmd; note_data *note; pid_t pgp_pid; gint fd; g_return_if_fail(p != NULL); g_return_if_fail(GNOME_IS_DIALOG(p)); if (selected_node == NULL) { warn_w = gnome_warning_dialog_parented( _("Select a note first!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } ask_commit_changes(); note = (note_data *) gtk_ctree_node_get_row_data( GTK_CTREE(note_tree), GTK_CTREE_NODE(selected_node)); if (!note->text || !strlen(note->text)) { warn_w = gnome_warning_dialog_parented(_("Nothing to decrypt!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } tmpfname = tmpnam(NULL); if (tmpfname == NULL) { warn_w = gnome_warning_dialog_parented(_("Can't create tmp filename!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } fd = safe_open(tmpfname, O_CREAT | O_EXCL | O_WRONLY); if (fd == -1) { warn_w = gnome_warning_dialog_parented(_("Can't open tmp file!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } write(fd, note->text, strlen(note->text)); close(fd); tmpcmd = g_strdup_printf(sys_buf, tmpfname); pass_entry = gtk_object_get_user_data(GTK_OBJECT(p)); setenv("PGPPASSFD", "0", 1); pgp_pid = run_pgp(tmpcmd, &pgpin, &pgpout, &pgperr); if (pgp_pid == -1) { warn_w = gnome_warning_dialog_parented(_("Error while running pgp!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); unsetenv("PGPPASSFD"); unlink(tmpfname); g_free(tmpcmd); return; } if (pgpin && pgpout) { fprintf(pgpin, "%s\n", gtk_entry_get_text(GTK_ENTRY(pass_entry))); fwrite(note->text, sizeof (gchar), strlen(note->text), pgpin); fclose(pgpin); gtk_text_freeze(GTK_TEXT(text_entry)); gtk_editable_delete_text(GTK_EDITABLE(text_entry), 0, gtk_text_get_length(GTK_TEXT(text_entry))); do { fgets(tmpbuf, sizeof (tmpbuf), pgpout); if (!feof(pgpout)) { gtk_text_insert(GTK_TEXT(text_entry), NULL, NULL, NULL, tmpbuf, strlen(tmpbuf)); } } while (!feof(pgpout)); gtk_text_thaw(GTK_TEXT(text_entry)); fclose(pgpout); fclose(pgperr); if ((gtk_text_get_length(GTK_TEXT(text_entry)) == 0) && note->text) { warn_w = gnome_warning_dialog_parented(_("Pgp didn't return any\ text. Maybe your're using the wrong password?"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); gtk_text_insert(GTK_TEXT(text_entry), NULL, NULL, NULL, note->text, strlen(note->text)); }
static void cb_encrypt(GtkWidget *w, gpointer p) { GtkWidget *pass_entry; GtkWidget *warn_w; FILE *pgpin; FILE *pgpout; FILE *pgperr; static gchar sys_buf[] = "pgpe -catfq +batchmode"; gchar tmpbuf[1024]; note_data *note; g_return_if_fail(p != NULL); g_return_if_fail(GNOME_IS_DIALOG(p)); if (selected_node == NULL) { warn_w = gnome_warning_dialog_parented( _("Select a note first!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } ask_commit_changes(); note = (note_data *) gtk_ctree_node_get_row_data( GTK_CTREE(note_tree), GTK_CTREE_NODE(selected_node)); if (!note->text || !strlen(note->text)) { warn_w = gnome_warning_dialog_parented(_("Nothing to encrypt!"), yank_root_win(NULL)); gtk_window_set_modal(GTK_WINDOW(warn_w), TRUE); return; } pass_entry = gtk_object_get_user_data(GTK_OBJECT(p)); setenv("PGPPASSFD", "0", 1); run_pgp(sys_buf, &pgpin, &pgpout, &pgperr); /*Execute PGP*/ if(pgpin && pgpout) { fprintf(pgpin, "%s\n", gtk_entry_get_text(GTK_ENTRY(pass_entry))); /*Output buffer to PGP:*/ fwrite(note->text, sizeof(gchar), strlen(note->text), pgpin); fclose(pgpin); gtk_text_freeze(GTK_TEXT(text_entry)); gtk_editable_delete_text(GTK_EDITABLE(text_entry), 0, gtk_text_get_length(GTK_TEXT(text_entry))); /*Now, read the result back from PGP:*/ do { fgets(tmpbuf, sizeof(tmpbuf), pgpout); if (!feof(pgpout)) { gtk_text_insert(GTK_TEXT(text_entry), NULL, NULL, NULL, tmpbuf, strlen(tmpbuf)); } } while (!feof(pgpout)); gtk_text_thaw(GTK_TEXT(text_entry)); fclose(pgpout); } unsetenv("PGPPASSFD"); }
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); }
static void fdriverchooser_switch_page (GtkNotebook * notebook, GtkNotebookPage * page, gint page_num, TFDRIVERCHOOSER * choose_t) { guint len; char buff[1024]; char *dsn = {""}; char *drv = {""}; char *curr; if (choose_t) { switch (page_num) { case 0: if (choose_t->b_back) gtk_widget_set_sensitive (choose_t->b_back, FALSE); if (choose_t->b_continue) gtk_label_parse_uline(GTK_LABEL(GTK_BIN (choose_t->b_continue)->child), "Continue"); break; case 1: if (choose_t->driverlist && choose_t->tab_panel && GTK_CLIST (choose_t->driverlist)->selection == NULL) { _iodbcdm_messagebox(choose_t->mainwnd, NULL, "Driver wasn't selected!"); gtk_notebook_set_page (GTK_NOTEBOOK (choose_t->tab_panel), 0); break; } if (choose_t->b_back) gtk_widget_set_sensitive (choose_t->b_back, TRUE); if (choose_t->b_continue) gtk_label_parse_uline(GTK_LABEL(GTK_BIN (choose_t->b_continue)->child), "Co_ntinue"); break; case 2: if (choose_t->driverlist && choose_t->tab_panel && choose_t->dsn_entry) { if (GTK_CLIST (choose_t->driverlist)->selection != NULL) { gtk_clist_get_text (GTK_CLIST (choose_t->driverlist), GPOINTER_TO_INT(GTK_CLIST(choose_t->driverlist)->selection->data), 0, &drv); } else { _iodbcdm_messagebox(choose_t->mainwnd, NULL, "Driver wasn't selected!"); gtk_notebook_set_page (GTK_NOTEBOOK (choose_t->tab_panel), 0); break; } dsn = gtk_entry_get_text(GTK_ENTRY(choose_t->dsn_entry)); if (strlen(dsn) < 1) { _iodbcdm_messagebox(choose_t->mainwnd, NULL, "Enter File DSN Name..."); gtk_notebook_set_page (GTK_NOTEBOOK (choose_t->tab_panel), 1); break; } } if (choose_t->b_back) gtk_widget_set_sensitive (choose_t->b_back, TRUE); if (choose_t->b_continue) gtk_label_parse_uline(GTK_LABEL(GTK_BIN (choose_t->b_continue)->child), "_Finish"); if (choose_t->mess_entry) { #if GTK_CHECK_VERSION(2,0,0) GtkTextBuffer *gbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(choose_t->mess_entry)); GtkTextIter *iter; gtk_text_buffer_set_text(gbuf, "", 0); if (strchr(dsn, '/') != NULL) snprintf(buff, sizeof(buff), "Filename: %s\n", dsn); else snprintf(buff, sizeof(buff), "Filename: %s/%s\n", choose_t->curr_dir, dsn); gtk_text_buffer_insert_at_cursor(gbuf, buff, -1); snprintf(buff, sizeof(buff), "Driver: %s\n", drv); gtk_text_buffer_insert_at_cursor(gbuf, buff, -1); gtk_text_buffer_insert_at_cursor(gbuf, "Driver-specific Keywords:\n", -1); if (choose_t->attrs) { for (curr = choose_t->attrs; *curr; curr += (STRLEN (curr) + 1)) { if (!strncasecmp (curr, "PWD=", STRLEN ("PWD="))) continue; if (curr) gtk_text_buffer_insert_at_cursor(gbuf, curr, -1); gtk_text_buffer_insert_at_cursor(gbuf, "\n", -1); } } #else gtk_text_set_point(GTK_TEXT(choose_t->mess_entry), 0); len = gtk_text_get_length(GTK_TEXT(choose_t->mess_entry)); gtk_text_forward_delete(GTK_TEXT(choose_t->mess_entry), len); gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, "File Data Source\n", -1); if (strchr(dsn, '/') != NULL) snprintf(buff, sizeof(buff), "Filename: %s\n", dsn); else snprintf(buff, sizeof(buff), "Filename: %s/%s\n", choose_t->curr_dir, dsn); gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, buff, -1); snprintf(buff, sizeof(buff), "Driver: %s\n", drv); gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, buff, -1); gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, "Driver-specific Keywords:\n", -1); if (choose_t->attrs) { for (curr = choose_t->attrs; *curr; curr += (STRLEN (curr) + 1)) { if (!strncasecmp (curr, "PWD=", STRLEN ("PWD="))) { continue; } gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, curr, -1); gtk_text_insert(GTK_TEXT(choose_t->mess_entry), NULL, NULL, NULL, "\n", -1); } } #endif } break; } } }
static void logbox_reload_single(GtkWidget *window, GtkWidget *text, char *default_text) { FILE *handle; struct wave_logfile_lines_t *wlog_head=NULL, *wlog_curr=NULL; int wlog_size = 0; handle = fopen(default_text, "rb"); if(!handle) { char *buf = malloc_2(strlen(default_text)+128); sprintf(buf, "Could not open logfile '%s'\n", default_text); status_text(buf); free_2(buf); return; } #if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN) { GtkTextIter st_iter, en_iter; gtk_text_buffer_get_start_iter(GTK_TEXT_VIEW (text)->buffer, &st_iter); gtk_text_buffer_get_end_iter(GTK_TEXT_VIEW (text)->buffer, &en_iter); gtk_text_buffer_delete(GTK_TEXT_VIEW (text)->buffer, &st_iter, &en_iter); gtk_text_buffer_get_start_iter (GTK_TEXT_VIEW (text)->buffer, &GLOBALS->iter_logfile_c_2); } #else { guint len = gtk_text_get_length(GTK_TEXT(text)); gtk_text_set_point(GTK_TEXT(text), 0); gtk_text_freeze(GTK_TEXT(text)); gtk_text_forward_delete (GTK_TEXT(text), len); } #endif log_text_bold(text, NULL, "Click-select"); log_text(text, NULL, " on numbers to jump to that time value in the wave viewer.\n"); log_text(text, NULL, " \n"); while(!feof(handle)) { char *pnt = fgetmalloc(handle); if(pnt) { struct wave_logfile_lines_t *w = calloc_2(1, sizeof(struct wave_logfile_lines_t)); wlog_size += (GLOBALS->fgetmalloc_len+1); w->text = pnt; if(!wlog_curr) { wlog_head = wlog_curr = w; } else { wlog_curr->next = w; wlog_curr = w; } } } if(wlog_curr) { struct wave_logfile_lines_t *w = wlog_head; struct wave_logfile_lines_t *wt; char *pnt = malloc_2(wlog_size + 1); char *pnt2 = pnt; while(w) { int len = strlen(w->text); memcpy(pnt2, w->text, len); pnt2 += len; *pnt2 = '\n'; pnt2++; free_2(w->text); wt = w; w = w->next; free_2(wt); } /* wlog_head = */ wlog_curr = NULL; /* scan-build */ *pnt2 = 0; log_text(text, GLOBALS->font_logfile_c_1, pnt); free_2(pnt); } #if defined(WAVE_USE_GTK2) && !defined(GTK_ENABLE_BROKEN) #else gtk_text_thaw(GTK_TEXT(text)); #endif fclose(handle); }
void selection_received (GtkWidget *widget, GtkSelectionData *data) { int position; int i; SelType seltype; char *str; if (data->length < 0) { g_print("Error retrieving selection\n"); return; } seltype = SEL_TYPE_NONE; for (i=0; i<LAST_SEL_TYPE; i++) { if (seltypes[i] == data->type) { seltype = i; break; } } if (seltype == SEL_TYPE_NONE) { char *name = gdk_atom_name (data->type); g_print("Don't know how to handle type: %s\n", name?name:"<unknown>"); return; } if (selection_string != NULL) g_string_free (selection_string, TRUE); selection_string = g_string_new (NULL); gtk_text_freeze (GTK_TEXT (selection_text)); gtk_text_set_point (GTK_TEXT (selection_text), 0); gtk_text_forward_delete (GTK_TEXT (selection_text), gtk_text_get_length (GTK_TEXT (selection_text))); position = 0; while (position < data->length) { switch (seltype) { case ATOM: str = stringify_atom (data->data, &position); break; case COMPOUND_TEXT: case STRING: case TEXT: str = stringify_text (data->data, &position); break; case BITMAP: case DRAWABLE: case PIXMAP: case WINDOW: case COLORMAP: str = stringify_xid (data->data, &position); break; case INTEGER: case PIXEL: str = stringify_integer (data->data, &position); break; case SPAN: str = stringify_span (data->data, &position); break; default: { char *name = gdk_atom_name (data->type); g_print("Can't convert type %s to string\n", name?name:"<unknown>"); position = data->length; continue; } } gtk_text_insert (GTK_TEXT (selection_text), NULL, &selection_text->style->black, NULL, str, -1); gtk_text_insert (GTK_TEXT (selection_text), NULL, &selection_text->style->black, NULL, "\n", -1); g_string_append (selection_string, str); g_free (str); } gtk_text_thaw (GTK_TEXT (selection_text)); }
static void sfe_ui_TreeSelectionChanged( GtkWidget *tree ) { GList *itemlist; gchar *name; GtkBox *hbox; GtkLabel *label; GtkWidget *item; pStructInf infptr, subinf; gchar* annotation; int i; gchar* rowtext[2]; gchar intbuf[32]; char* strval; int intval; /** Get the hidden label which contains the pointer to the inf **/ if (!tree) return; itemlist = GTK_TREE_SELECTION(tree); if (!itemlist) return; item = GTK_WIDGET (itemlist->data); if (!item) return; hbox = GTK_BOX (GTK_BIN (item)->child); label = GTK_LABEL (((GtkBoxChild*)(hbox->children->next->next->data))->widget); gtk_label_get (label, &name); infptr = (pStructInf)(strtol(name, NULL, 16)); if (!infptr) return; /** Show the info on the right side of the window **/ gtk_entry_set_text(GTK_ENTRY(SFE_Globals.NameEdit), infptr->Name); gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(SFE_Globals.TypeCombo)->entry), infptr->UsrType); gtk_text_set_point(GTK_TEXT(SFE_Globals.AnnotText), 0); gtk_text_forward_delete(GTK_TEXT(SFE_Globals.AnnotText), gtk_text_get_length(GTK_TEXT(SFE_Globals.AnnotText))); annotation=""; stAttrValue(stLookup(infptr,"annotation"), NULL, &annotation, 0); gtk_text_insert(GTK_TEXT(SFE_Globals.AnnotText), NULL, NULL, NULL, annotation, strlen(annotation)); /** Build the attributes listing **/ gtk_clist_clear(GTK_CLIST(SFE_Globals.AttrsCList)); for(i=0;i<infptr->nSubInf;i++) { subinf = infptr->SubInf[i]; if (stStructType(subinf) == ST_T_ATTRIB) { strval = NULL; stAttrValue(subinf, &intval, &strval, 0); rowtext[0] = subinf->Name; if (strval) { rowtext[1] = strval; } else { snprintf(intbuf, 32, "%d", intval); rowtext[1] = intbuf; } gtk_clist_append(GTK_CLIST(SFE_Globals.AttrsCList), rowtext); } } return; }
void nh_message_putstr(const char *str) { int i; int len; char *buf; GtkText *t; #ifdef FROZEN_INSERT static int freeze_count=0; #endif if (!message_text) return; t = GTK_TEXT(message_text); len = strlen(str); buf = (char *)alloc(len + 2); sprintf(buf, "\n%s", str); #ifdef FROZEN_INSERT /* ALI: gimpwin 20001226 looks very bad if you update a text widget without * freezing it (the text is displayed half-scrolled, with lines overlapping * each other). This is not ideal (the text is redrawn each thaw), but it * is an improvement. Due to a bug in gimpwin we can't trim text if we've * frozen the widget, thus every so often we don't freeze but trim instead. */ if (++freeze_count >= 50) /* Trim text every 50 inserts */ freeze_count = 0; else gtk_text_freeze(t); #endif if (nh_status_in_trouble()) i = CLR_RED; else i = MAP_BLACK; gtk_text_insert(t, NULL, &nh_color[i], &nh_color[MAP_WHITE], buf, len + 1); len = gtk_text_get_length(t); #ifdef FROZEN_INSERT if (!freeze_count && len > NH_TEXT_REMEMBER) { #else if (len > NH_TEXT_REMEMBER) { #endif gtk_text_freeze(t); for(i = 0; i < len && len > NH_TEXT_REMEMBER; i++) if (GTK_TEXT_INDEX(t, i) == '\n') { i++; gtk_text_set_point(t, i); gtk_text_backward_delete(t, i); len -= i; } gtk_text_set_point(t, len); gtk_text_thaw(t); } #ifdef FROZEN_INSERT /* ALI: t->vadj->upper would be more correct, but causes gimpwin to crash */ if (freeze_count) { gtk_adjustment_set_value(t->vadj, t->vadj->upper - 1); gtk_text_thaw(t); } #endif free(buf); } #endif /* USE_TEXTVIEW */ int GTK_doprev_message() { return 0; } void nh_message_destroy(void) { message_text = NULL; }