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;
}
