static void
submit_cb(GtkWidget *w, ConsoleUI *cui) {
char *command;
command = gtk_editable_get_chars(GTK_EDITABLE(cui->entry), 0, -1);
if (run_console_command(cui, command))
gtk_editable_delete_text(GTK_EDITABLE(cui->entry), 0, -1);
g_free(command);
}
static void
gdaui_numeric_entry_assume_delete (GdauiEntry *entry, gint virt_start_pos, gint virt_end_pos, gint offset)
{
GdauiNumericEntry *fentry;
GString *string;
gchar *otext, *ntext = NULL;
gint i, nlen, ndel, olen = 0;
gint cursor_pos;
fentry = (GdauiNumericEntry*) entry;
ndel = virt_end_pos - virt_start_pos;
otext = gdaui_entry_get_text (GDAUI_ENTRY (entry));
cursor_pos = gtk_editable_get_position (GTK_EDITABLE (entry));
if (otext) {
if ((ndel == 1) && (otext[virt_start_pos] == fentry->priv->decimal_sep) &&
(fentry->priv->nb_decimals != G_MAXUINT16)) {
gtk_editable_set_position (GTK_EDITABLE (entry), cursor_pos - 1);
g_free (otext);
return;
}
string = g_string_new (otext);
olen = g_utf8_strlen (otext, -1);
g_free (otext);
g_string_erase (string, virt_start_pos, ndel);
}
else
string = g_string_new (NULL);
cursor_pos -= (virt_end_pos - virt_start_pos);
/*g_print ("RAW: [%s]", string->str);*/
text_unformat (fentry, string->str, &cursor_pos);
/*g_print ("SANITIZED: [%s]", string->str);*/
if (!test_text_validity (fentry, string->str)) {
if ((string->str[0] == fentry->priv->decimal_sep) &&
string->str[1] == 0)
ntext = g_strdup ("");
g_string_free (string, TRUE);
if (!ntext) {
/*g_print ("ERROR!\n");*/
return;
}
}
else {
ntext = text_reformat (fentry, string->str, &cursor_pos, FALSE);
g_string_free (string, TRUE);
}
/*g_print ("NEW: [%s]\n", ntext);*/
i = offset;
nlen = strlen (ntext);
gtk_editable_delete_text ((GtkEditable*) entry, offset, olen + offset);
gtk_editable_insert_text ((GtkEditable*) entry, ntext, nlen, &i);
g_free (ntext);
gtk_editable_set_position (GTK_EDITABLE (entry), cursor_pos);
}
void GeCurveGtk::export_file_selected_cb( void *ctx, char *filename, wow_eFileSelType file_type)
{
GeCurve *curve = (GeCurve *)ctx;
gint pos = 0;
gtk_editable_delete_text( GTK_EDITABLE(((GeCurveGtk *)curve)->export_filename_widget), 0, -1);
gtk_editable_insert_text( GTK_EDITABLE(((GeCurveGtk *)curve)->export_filename_widget),
filename, strlen(filename), &pos);
}
void
gl_object_editor_set_data (glObjectEditor *editor,
gboolean merge_flag,
glTextNode *text_node)
{
gint pos;
gl_debug (DEBUG_EDITOR, "START");
editor->priv->stop_signals = TRUE;
gtk_widget_set_sensitive (editor->priv->data_key_radio, merge_flag);
if (!text_node->field_flag || !merge_flag) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(editor->priv->data_literal_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->data_text_entry, TRUE);
gtk_widget_set_sensitive (editor->priv->data_key_combo, FALSE);
gtk_widget_set_sensitive (editor->priv->data_format_label, FALSE);
gtk_widget_set_sensitive (editor->priv->data_ex_label, FALSE);
gtk_widget_set_sensitive (editor->priv->data_digits_spin, FALSE);
gtk_widget_set_sensitive (editor->priv->data_digits_label, FALSE);
gtk_editable_delete_text (GTK_EDITABLE (editor->priv->data_text_entry), 0, -1);
pos = 0;
if (text_node->data != NULL ) {
gtk_editable_insert_text (GTK_EDITABLE (editor->priv->data_text_entry),
text_node->data,
strlen (text_node->data),
&pos);
}
} else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON
(editor->priv->data_key_radio), TRUE);
gtk_widget_set_sensitive (editor->priv->data_text_entry, FALSE);
gtk_widget_set_sensitive (editor->priv->data_key_combo, TRUE);
gtk_widget_set_sensitive (editor->priv->data_format_label, TRUE);
gtk_widget_set_sensitive (editor->priv->data_ex_label, TRUE);
gtk_widget_set_sensitive (editor->priv->data_digits_label,
!editor->priv->data_format_fixed_flag);
gtk_widget_set_sensitive (editor->priv->data_digits_spin,
!editor->priv->data_format_fixed_flag);
gl_field_button_set_key (GL_FIELD_BUTTON (editor->priv->data_key_combo),
text_node->data);
}
editor->priv->stop_signals = FALSE;
gl_debug (DEBUG_EDITOR, "END");
}
void gtk_write_entry_float(GtkWidget *entry, float value)
{
gint r;
char string[400];
sprintf(string,"%f",value);
gtk_editable_delete_text(GTK_EDITABLE(entry), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(entry), string, strlen(string), &r);
}
void gtk_write_entry_string(GtkWidget *entry, char *value)
{
gint r;
if(!value) return;
gtk_editable_delete_text(GTK_EDITABLE(entry), 0,-1);
gtk_editable_insert_text(GTK_EDITABLE(entry), value, strlen(value), &r);
}
static void
editable_undo_delete_text (GObject *object,
gint position_start,
gint position_end)
{
g_return_if_fail (GTK_IS_EDITABLE (object));
gtk_editable_delete_text (GTK_EDITABLE (object), position_start, position_end);
}
void
names_entry_insert(GtkEditable * editable,
gchar * new_text,
gint new_text_length, gint * position,
gpointer user_data)
{
gint pos = *position;
gchar c;
if (new_text_length > 1) {
g_signal_handlers_block_by_func(editable,
(gpointer) names_entry_insert,
user_data);
gtk_editable_delete_text(editable, pos, pos + strlen(new_text));
g_signal_handlers_unblock_by_func(editable,
(gpointer) names_entry_insert,
user_data);
g_signal_stop_emission_by_name(editable, "insert_text");
} else {
if (strcmp(new_text, " ") == 0) {
g_signal_handlers_block_by_func(editable,
(gpointer) names_entry_insert,
user_data);
gtk_editable_delete_text(editable, pos, pos + 1);
g_signal_handlers_unblock_by_func(editable, (gpointer)
names_entry_insert,
user_data);
g_signal_stop_emission_by_name(editable, "insert_text");
} else {
gchar *cad;
g_signal_handlers_block_by_func(editable,
(gpointer) names_entry_insert,
user_data);
gtk_editable_delete_text(editable, pos, pos + 1);
cad = g_ascii_strdown(new_text, strlen(new_text));
gtk_editable_insert_text(editable, cad, strlen(cad), position);
g_signal_handlers_unblock_by_func(editable, (gpointer)
names_entry_insert,
user_data);
g_signal_stop_emission_by_name(editable, "insert_text");
g_free(cad);
}
}
}
/**
* gtk_editable_delete_selection:
* @editable: a #GtkEditable
*
* Deletes the currently selected text of the editable.
* This call doesn’t do anything if there is no selected text.
*/
void
gtk_editable_delete_selection (GtkEditable *editable)
{
gint start, end;
g_return_if_fail (GTK_IS_EDITABLE (editable));
if (gtk_editable_get_selection_bounds (editable, &start, &end))
gtk_editable_delete_text (editable, start, end);
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// PRIVATE void clearTextArea(const gchar *pWidgetName)
// IN : const gchar *pWidgetName : Widget name.
// OUT : None.
// RETURN : None.
//
PRIVATE void clearTextArea(const gchar *pWidgetName)
{
/*** Parameters start ***/
GtkWidget *widget = NULL; // Temporary pointer to widget.
/*** Parameters end ***/
widget = lookupWidget(pWidgetName);
gtk_editable_delete_text(GTK_EDITABLE(widget), 0, -1);
return;
}// End clearTextArea
/* entry_focus() {{{*/
void
entry_focus()
{
if (! (dwb.state.bar_visible & BAR_VIS_STATUS))
gtk_widget_show_all(dwb.gui.bottombox);
gtk_widget_show(dwb.gui.entry);
gtk_widget_grab_focus(dwb.gui.entry);
gtk_widget_set_can_focus(CURRENT_WEBVIEW_WIDGET(), false);
gtk_editable_delete_text(GTK_EDITABLE(dwb.gui.entry), 0, -1);
}/*}}}*/
bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr& style )
{
if ( m_windowStyle & wxTE_MULTILINE )
{
if ( style.IsDefault() )
{
// nothing to do
return true;
}
// VERY dirty way to do that - removes the required text and re-adds it
// with styling (FIXME)
gint l = gtk_text_get_length( GTK_TEXT(m_text) );
wxCHECK_MSG( start >= 0 && end <= l, false,
wxT("invalid range in wxTextCtrl::SetStyle") );
gint old_pos = gtk_editable_get_position( GTK_EDITABLE(m_text) );
char *text = gtk_editable_get_chars( GTK_EDITABLE(m_text), start, end );
wxString tmp(text,*wxConvCurrent);
g_free( text );
gtk_editable_delete_text( GTK_EDITABLE(m_text), start, end );
gtk_editable_set_position( GTK_EDITABLE(m_text), start );
#if wxUSE_UNICODE
wxWX2MBbuf buf = tmp.mbc_str();
const char *txt = buf;
size_t txtlen = strlen(buf);
#else
const char *txt = tmp;
size_t txtlen = tmp.length();
#endif
// use the attributes from style which are set in it and fall back
// first to the default style and then to the text control default
// colours for the others
wxGtkTextInsert(m_text,
wxTextAttr::Combine(style, m_defaultStyle, this),
txt,
txtlen);
/* does not seem to help under GTK+ 1.2 !!!
gtk_editable_set_position( GTK_EDITABLE(m_text), old_pos ); */
SetInsertionPoint( old_pos );
return true;
}
// else single line
// cannot do this for GTK+'s Entry widget
return false;
}
static gboolean on_display_editable_map(GtkWidget *widget, gchar *display)
{
gint position = 0;
GtkEditable *editable = GTK_EDITABLE(widget);
gtk_editable_delete_text(editable, 0, -1);
gtk_editable_insert_text(editable, display ? display : "", -1, &position);
gtk_editable_select_region(editable, -1, 0);
g_free(display);
return FALSE;
}
void key_custom_toggled(GtkToggleButton *togglebutton, gpointer user_data)
{
struct GPGAccountPage *page = (struct GPGAccountPage *) user_data;
gboolean active;
active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(page->key_custom));
gtk_widget_set_sensitive(GTK_WIDGET(page->keyid_label), active);
gtk_widget_set_sensitive(GTK_WIDGET(page->keyid), active);
if (!active)
gtk_editable_delete_text(GTK_EDITABLE(page->keyid), 0, -1);
}
static PyObject* ComposeWindow_save_message_to(clawsmail_ComposeWindowObject *self, PyObject *args)
{
PyObject *arg;
if(!PyArg_ParseTuple(args, "O", &arg))
return NULL;
if(PyString_Check(arg)) {
GtkEditable *editable;
gint pos;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->compose->savemsg_checkbtn), TRUE);
editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(self->compose->savemsg_combo)));
gtk_editable_delete_text(editable, 0, -1);
gtk_editable_insert_text(editable, PyString_AsString(arg), -1, &pos);
}
else if(clawsmail_folder_check(arg)) {
GtkEditable *editable;
gint pos;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->compose->savemsg_checkbtn), TRUE);
editable = GTK_EDITABLE(gtk_bin_get_child(GTK_BIN(self->compose->savemsg_combo)));
gtk_editable_delete_text(editable, 0, -1);
gtk_editable_insert_text(editable, folder_item_get_identifier(clawsmail_folder_get_item(arg)), -1, &pos);
}
else if (arg == Py_None){
/* turn off checkbutton */
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->compose->savemsg_checkbtn), FALSE);
}
else {
PyErr_SetString(PyExc_TypeError, "function takes exactly one argument which may be a folder object, a string, or None");
return NULL;
}
flush_gtk_queue();
Py_INCREF(Py_None);
return Py_None;
}
/**
\fn glyphUpdate
\brief Update all fields in the dialog wrt currentGlyph
*/
void glyphUpdate(void )
{
if(!currentGlyph) return;
gtk_widget_set_usize(WID(drawingarea1), currentGlyph->width+4, currentGlyph->height+4);
glyphDraw();
gtk_editable_delete_text(GTK_EDITABLE(WID(entry1)), 0,-1);
if(currentGlyph->code)
{
// Set our text
gtk_entry_set_text (GTK_ENTRY (WID(entry1)), currentGlyph->code);
}
}
static void location_cb (GtkMozEmbed *embed, WebBrowserObject *browser)
{
browser->FireEvent("OnLocationChange");
char *location = gtk_moz_embed_get_location(embed);
if (location) {
int pos = 0;
systemObject->Log(0, "location: %s", location);
gtk_editable_delete_text(GTK_EDITABLE(browser->urlEntry), 0, -1);
gtk_editable_insert_text(GTK_EDITABLE(browser->urlEntry), location, strlen(location), &pos);
g_free(location);
}
browser->BrowserButtons();
}
/**
* e_dialog_editable_set:
* @widget: A #GtkEditable widget.
* @value: String value.
*
* Sets the string value inside a #GtkEditable-derived widget.
**/
void
e_dialog_editable_set (GtkWidget *widget,
const gchar *value)
{
gint pos = 0;
g_return_if_fail (GTK_IS_EDITABLE (widget));
gtk_editable_delete_text (GTK_EDITABLE (widget), 0, -1);
if (value)
gtk_editable_insert_text (GTK_EDITABLE (widget), value, strlen (value), &pos);
}
void
button2_clicked_cb() {
gtk_editable_delete_text((GtkEditable *) entry, 0, -1);
gtk_text_buffer_set_text(text1,"",-1);
gtk_text_buffer_set_text(text2,"",-1);
/*set focus to entry*/
gtk_widget_grab_focus(entry);
gtk_widget_hide(textview1);
gtk_widget_hide(hboxmain);
gtk_widget_hide(GTK_WIDGET(status));
gtk_widget_hide(button2);
gtk_window_resize((GtkWindow *)window, 500, 20);
}
static void foldersel_cb(GtkWidget *widget, gpointer data)
{
GtkWidget *entry = (GtkWidget *) data;
FolderItem *item;
gchar *item_id;
gint newpos = 0;
item = foldersel_folder_sel(NULL, FOLDER_SEL_MOVE, NULL, FALSE);
if (item && (item_id = folder_item_get_identifier(item)) != NULL) {
gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1);
gtk_editable_insert_text(GTK_EDITABLE(entry), item_id, strlen(item_id), &newpos);
g_free(item_id);
}
}
/**
* Called when the user selects an entry from the autocomplete list.
*
* @param[in] widget
* @param[in] model Data structure containing autocomplete strings.
* @param[in] iter Pointer into data structure.
* @param[in] user_data unused here
*
* @return Currently always true
*/
static gboolean
on_match_select(GtkEntryCompletion *widget,
GtkTreeModel *model,
GtkTreeIter *iter,
gpointer user_data)
{
const gchar *varname;
GtkEditable *e = (GtkEditable*) gtk_entry_completion_get_entry(widget);
gchar *s = gtk_editable_get_chars(e, 0, -1);
gint cur_pos = gtk_editable_get_position(e);
gint p = cur_pos;
gchar *end;
gint del_end_pos = -1;
GValue value = {0, };
gtk_tree_model_get_value(model, iter, COMPL_VARNAME, &value);
varname = g_value_get_string(&value);
for (p = cur_pos; p - 2 > 0; p--)
{
if (strncmp(s + p - 2, "$(", 2) == 0)
{
break;
}
}
end = s + cur_pos;
if (end)
{
del_end_pos = end - s + 1;
}
else
{
del_end_pos = cur_pos;
}
size_t text_len = strlen(varname) + 2;
gchar *addtext = (gchar*) g_malloc(text_len);
snprintf(addtext, text_len, "%s)", varname);
gtk_editable_delete_text(e, p, del_end_pos);
gtk_editable_insert_text(e, addtext, -1, &p);
gtk_editable_set_position(e, p);
g_value_unset(&value);
g_free(addtext);
return TRUE;
}
void SetCursolPosition(const gchar *entry_name, const gint position)
{
GtkWidget *entry = NULL;
entry = glade_xml_get_widget(g_cngplp_xml, entry_name);
if(entry != NULL){
if(-1 == position){
const gint num = GTK_ENTRY(entry)->text_length;
gtk_editable_set_position(GTK_EDITABLE(entry), num);
}else{
gtk_editable_delete_text(GTK_EDITABLE(entry), position, -1);
gtk_editable_set_position(GTK_EDITABLE(entry), position);
}
}
}
void GeCurveGtk::open_minmax( int idx)
{
char min_value_str[80];
char max_value_str[80];
gint pos = 0;
create_minmax_dialog();
if ( idx < cd->cols) {
sprintf( min_value_str, "%f", cd->y_min_value_axis[idx]);
sprintf( max_value_str, "%f", cd->y_max_value_axis[idx]);
}
else {
sprintf( min_value_str, "%f", cd->x_min_value_axis[idx - cd->cols]);
sprintf( max_value_str, "%f", cd->x_max_value_axis[idx - cd->cols]);
}
gtk_editable_delete_text( GTK_EDITABLE(minmax_textmin_widget), 0, -1);
gtk_editable_insert_text( GTK_EDITABLE(minmax_textmin_widget),
min_value_str, strlen(min_value_str), &pos);
gtk_editable_delete_text( GTK_EDITABLE(minmax_textmax_widget), 0, -1);
gtk_editable_insert_text( GTK_EDITABLE(minmax_textmax_widget),
max_value_str, strlen(max_value_str), &pos);
minmax_idx = idx;
}
static gboolean midorator_entry_key_press_event_cb (MidoratorEntry* e, GdkEventKey* event) {
if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_a) {
gtk_editable_set_position(GTK_EDITABLE(e), 0);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_e) {
gtk_editable_set_position(GTK_EDITABLE(e), -1);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_f) {
gtk_editable_set_position(GTK_EDITABLE(e), gtk_editable_get_position(GTK_EDITABLE(e)) + 1);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_b) {
gtk_editable_set_position(GTK_EDITABLE(e), gtk_editable_get_position(GTK_EDITABLE(e)) - 1);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_p) {
gtk_editable_set_position(GTK_EDITABLE(e), 0);
midorator_entry_history_up(e);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_n) {
gtk_editable_set_position(GTK_EDITABLE(e), 0);
midorator_entry_history_down(e);
} else if ((event->state & GDK_CONTROL_MASK) && event->keyval == GDK_w) {
const char *t = gtk_entry_get_text(GTK_ENTRY(e));
int pos = gtk_editable_get_position(GTK_EDITABLE(e));
char *i;
for (i = g_utf8_offset_to_pointer(t, pos) - 1; i >= t && *i == ' '; i--);
for (; i >= t && *i != ' '; i--);
i++;
int newpos = g_utf8_pointer_to_offset(t, i);
gtk_editable_delete_text(GTK_EDITABLE(e), newpos, pos);
gtk_editable_set_position(GTK_EDITABLE(e), newpos);
} else if (event->keyval == GDK_Escape) {
g_signal_emit(e, signals[SIG_CANCEL], 0);
} else if (event->keyval == GDK_Tab) {
midorator_entry_perform_completion(e);
} else if (event->keyval == GDK_Up) {
midorator_entry_history_up(e);
} else if (event->keyval == GDK_Down) {
midorator_entry_history_down(e);
} else if (event->keyval == GDK_Page_Up) {
gtk_editable_set_position(GTK_EDITABLE(e), 0);
midorator_entry_history_up(e);
} else if (event->keyval == GDK_Page_Down) {
gtk_editable_set_position(GTK_EDITABLE(e), 0);
midorator_entry_history_down(e);
} else if (event->keyval == GDK_Return) {
char *t = g_strdup(gtk_entry_get_text(GTK_ENTRY(e)));
g_signal_emit(e, signals[SIG_EXECUTE], 0, t);
midorator_entry_history_add(e, t);
g_free(t);
} else
return false;
return true;
}
void wxComboBox::Replace( long from, long to, const wxString& value )
{
wxCHECK_RET( m_widget != NULL, wxT("invalid combobox") );
GtkWidget *entry = GTK_COMBO(m_widget)->entry;
gtk_editable_delete_text( GTK_EDITABLE(entry), (gint)from, (gint)to );
if (value.IsNull()) return;
gint pos = (gint)to;
#if wxUSE_UNICODE
wxCharBuffer buffer = wxConvUTF8.cWX2MB( value );
gtk_editable_insert_text( GTK_EDITABLE(entry), (const char*) buffer, strlen( (const char*) buffer ), &pos );
#else
gtk_editable_insert_text( GTK_EDITABLE(entry), value.c_str(), value.length(), &pos );
#endif
}
void my_int_listener (PluginParam *param) {
GtkEditable *editable;
if (sdlGoom->config_win == 0) return;
editable = GTK_EDITABLE(param->user_data);
if (editable) {
int pos = 0;
char str[256];
sprintf (str, "%d", IVAL(*param));
if (strcmp(str,gtk_editable_get_chars(editable,0,-1))) {
gtk_editable_delete_text (editable,0,-1);
gtk_editable_insert_text (editable,str,strlen(str),&pos);
}
}
}
/**************************************************************************
Make a text tag for the selected text.
**************************************************************************/
void inputline_make_tag(GtkEntry *entry, enum text_tag_type type)
{
char buf[MAX_LEN_MSG];
GtkEditable *editable = GTK_EDITABLE(entry);
gint start_pos, end_pos;
gchar *selection;
if (!gtk_editable_get_selection_bounds(editable, &start_pos, &end_pos)) {
/* Let's say the selection starts and ends at the current position. */
start_pos = end_pos = gtk_editable_get_position(editable);
}
selection = gtk_editable_get_chars(editable, start_pos, end_pos);
if (type == TTT_COLOR) {
/* Get the color arguments. */
char fg_color_text[32], bg_color_text[32];
GdkColor *fg_color = g_object_get_data(G_OBJECT(entry), "fg_color");
GdkColor *bg_color = g_object_get_data(G_OBJECT(entry), "bg_color");
if (!fg_color && !bg_color) {
goto CLEAN_UP;
}
color_to_string(fg_color, fg_color_text, sizeof(fg_color_text));
color_to_string(bg_color, bg_color_text, sizeof(bg_color_text));
if (0 == featured_text_apply_tag(selection, buf, sizeof(buf),
TTT_COLOR, 0, FT_OFFSET_UNSET,
ft_color(fg_color_text,
bg_color_text))) {
goto CLEAN_UP;
}
} else if (0 == featured_text_apply_tag(selection, buf, sizeof(buf),
type, 0, FT_OFFSET_UNSET)) {
goto CLEAN_UP;
}
/* 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_editable_select_region(editable, start_pos, end_pos);
CLEAN_UP:
g_free(selection);
}
//
// Hide all qualifiers.
//
void WUtedGtk::reset_qual()
{
int i;
for( i = 0; i < UTED_QUALS; i++) {
g_object_set( widgets.qualifier[i], "visible", FALSE, NULL);
g_object_set( widgets.value[i], "visible", FALSE, NULL);
g_object_set( widgets.present[i], "visible", FALSE, NULL);
present_sts[i] = 0;
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( widgets.present[i]), FALSE);
gtk_editable_delete_text( GTK_EDITABLE(widgets.value[i]), 0, -1);
}
gtk_label_set_label( GTK_LABEL(widgets.commandlabel), UTED_TEXT_NOCOMMAND);
current_index = UTED_INDEX_NOCOMMAND;
}
void
ghack_menu_window_clear(GtkWidget *menuWin, gpointer data)
{
MenuWinType isMenu;
int i, numRows;
menuItem* item;
isMenu = (MenuWinType) GPOINTER_TO_INT
(gtk_object_get_data (GTK_OBJECT (menuWin), "isMenu"));
if (isMenu == MenuMenu) {
GtkWidget *clist;
clist = GTK_WIDGET (gtk_object_get_data (GTK_OBJECT (menuWin), "clist"));
g_assert (clist != NULL);
/* destroy existing menu data, if any */
if (clist) {
/* destroy all the row_data we stored in the clist */
numRows = GPOINTER_TO_INT( gtk_object_get_data(
GTK_OBJECT(clist), "numRows") );
for( i=0; i<numRows; i++) {
item = (menuItem*) gtk_clist_get_row_data(
GTK_CLIST (clist), i);
if (item != NULL) {
g_free( item);
gtk_clist_set_row_data (GTK_CLIST (clist), i,
(gpointer) NULL);
}
}
gtk_object_set_data (GTK_OBJECT (clist), "numItems",
GINT_TO_POINTER (-1));
gtk_clist_clear (GTK_CLIST (clist));
}
}
else if (isMenu == MenuText) {
GnomeLess *gless;
gless = GNOME_LESS (gtk_object_get_data (GTK_OBJECT (menuWin), "gless"));
g_assert (gless != NULL);
gtk_editable_delete_text (GTK_EDITABLE (gless->text), 0, 0);
}
}
static void
gdaui_numeric_entry_assume_insert (GdauiEntry *entry, const gchar *text, gint text_length,
gint *virt_pos, gint offset)
{
GdauiNumericEntry *fentry;
gchar *otext, *ptr, *ntext;
gchar tmp;
gint i;
GString *string;
gint olen, nlen;
fentry = (GdauiNumericEntry*) entry;
otext = gdaui_entry_get_text (GDAUI_ENTRY (entry));
olen = strlen (otext);
for (ptr = otext, i = 0; (i < *virt_pos) && *ptr; ptr = g_utf8_next_char (ptr), i++);
if (i != *virt_pos)
return;
tmp = *ptr;
*ptr = 0;
string = g_string_new ("");
g_string_append (string, otext);
*ptr = tmp;
g_string_append (string, text);
g_string_append (string, ptr);
g_free (otext);
/*g_print ("RAW: [%s]", string->str);*/
*virt_pos += text_length;
text_unformat (fentry, string->str, virt_pos);
/*g_print ("SANITIZED: [%s]", string->str);*/
if (!test_text_validity (fentry, string->str)) {
g_string_free (string, TRUE);
/*g_print ("ERROR!\n");*/
return;
}
ntext = text_reformat (fentry, string->str, virt_pos, (text[text_length-1] == fentry->priv->decimal_sep));
g_string_free (string, TRUE);
/*g_print ("NEW: [%s]\n", ntext);*/
i = offset;
nlen = strlen (ntext);
gtk_editable_delete_text ((GtkEditable*) entry, offset, olen + offset);
gtk_editable_insert_text ((GtkEditable*) entry, ntext, nlen, &i);
g_free (ntext);
}
