/**
* entry_properties_set_dn:
* @eprop: a #EntryProperties widget
* @dn: a DN to display information for
*
* Adjusts the display to show @dn's properties
*/
void
entry_properties_set_dn (EntryProperties *eprop, const gchar *dn)
{
g_return_if_fail (IS_ENTRY_PROPERTIES (eprop));
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
tbuffer = eprop->priv->text;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
if (dn && *dn) {
GdaLdapEntry *entry;
entry = t_connection_ldap_describe_entry (eprop->priv->tcnc, dn, NULL);
if (entry)
entry_info_fetched_done (eprop, entry);
else
ui_show_message (GTK_WINDOW (gtk_widget_get_toplevel ((GtkWidget*) eprop)),
"%s", _("Could not get information about LDAP entry"));
}
}
void gTextArea::selSelect(int pos, int length)
{
GtkTextIter start, end;
gtk_text_buffer_get_end_iter(_buffer, &start);
if (gtk_text_iter_get_offset(&start) < pos)
pos = gtk_text_iter_get_offset(&start);
if (pos < 0)
{
length -= pos;
pos = 0;
}
if ((pos + length) < 0)
length = (-pos);
gtk_text_buffer_get_selection_bounds(_buffer, &start, &end);
gtk_text_iter_set_offset(&start, pos);
gtk_text_iter_set_offset(&end, pos + length);
gtk_text_buffer_select_range(_buffer, &start, &end);
}
//закрытие и сохранение данных
void closeApp ( GtkWidget *window, gpointer)
{
GtkTextBuffer *buffer;
//получение GtkTextBuffer
GtkWidget* view = mainWindow->messageEdit;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
//получение строки из GtkTextBuffer
GtkTextIter *start = new GtkTextIter(),*end = new GtkTextIter();
gtk_text_buffer_get_start_iter(buffer, start);
gtk_text_buffer_get_end_iter(buffer, end);
data->message = gtk_text_buffer_get_text (buffer,start, end, 1);
////////////////////////////////////
data->theme = gtk_entry_get_text(GTK_ENTRY(mainWindow->themeEdit));
//сохранение данных
data->serial();
//выход
gtk_main_quit();
}
void search_in_doc(GtkTextBuffer* buf, const gchar* search_text, SearchTools* self) {
GString* url = self->app->doc_get_url(buf);
GtkTextIter ps, pe;
gchar* content;
gsize len;
if( !url )
return;
gtk_text_buffer_get_start_iter(buf, &ps);
gtk_text_buffer_get_end_iter(buf, &pe);
content = gtk_text_buffer_get_text(buf, &ps, &pe, TRUE);
if( !content )
return;
len = g_utf8_strlen(content, -1);
search_in_file_content( url->str
, content
, len
, search_text
, self );
g_free(content);
}
static void
calendar_details_changed (GtkTextBuffer *buffer,
CalendarData *data)
{
GtkTextIter start, end;
guint year, month, day;
gchar *detail;
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_calendar_get_date (GTK_CALENDAR (data->calendar_widget), &year, &month, &day);
detail = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
if (!detail[0])
{
g_free (detail);
detail = NULL;
}
calendar_set_detail (data, year, month, day, detail);
gtk_widget_queue_resize (data->calendar_widget);
}
/**************************************************************************
Appends the string to the chat output window. The string should be
inserted on its own line, although it will have no newline.
**************************************************************************/
void real_output_window_append(const char *astring,
const struct text_tag_list *tags,
int conn_id)
{
GtkTextBuffer *buf;
GtkTextIter iter;
GtkTextMark *mark;
ft_offset_t text_start_offset;
buf = message_buffer;
if (buf == NULL) {
log_error("Output when no message buffer: %s", astring);
return;
}
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, "\n", -1);
mark = gtk_text_buffer_create_mark(buf, NULL, &iter, TRUE);
if (gui_gtk2_show_chat_message_time) {
char timebuf[64];
time_t now;
struct tm *now_tm;
now = time(NULL);
now_tm = localtime(&now);
strftime(timebuf, sizeof(timebuf), "[%H:%M:%S] ", now_tm);
gtk_text_buffer_insert(buf, &iter, timebuf, -1);
}
text_start_offset = gtk_text_iter_get_offset(&iter);
gtk_text_buffer_insert(buf, &iter, astring, -1);
text_tag_list_iterate(tags, ptag) {
apply_text_tag(ptag, buf, text_start_offset, astring);
} text_tag_list_iterate_end;
static GWENHYWFAR_CB
int Gtk2Gui_WTextEdit_SetCharProperty(GWEN_WIDGET *w,
GWEN_DIALOG_PROPERTY prop,
int index,
const char *value,
int doSignal)
{
GtkWidget *g;
g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK2_DIALOG_WIDGET_REAL));
assert(g);
switch (prop) {
case GWEN_DialogProperty_Value: {
GtkTextBuffer *tb;
GtkTextIter endIter;
tb=gtk_text_view_get_buffer(GTK_TEXT_VIEW(g));
assert(tb);
if (value && *value)
gtk_text_buffer_set_text(tb, value, -1);
else
gtk_text_buffer_set_text(tb, "", -1);
gtk_text_buffer_get_end_iter(tb, &endIter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(g), &endIter, 0.5, FALSE, 0.0, 0.0);
return 0;
}
default:
break;
}
DBG_WARN(GWEN_LOGDOMAIN,
"Function is not appropriate for this type of widget (%s)",
GWEN_Widget_Type_toString(GWEN_Widget_GetType(w)));
return GWEN_ERROR_INVALID;
}
static void
chat_text_view_append_event (EmpathyChatView *view,
const gchar *str)
{
EmpathyChatTextView *text_view = EMPATHY_CHAT_TEXT_VIEW (view);
EmpathyChatTextViewPriv *priv = GET_PRIV (text_view);
gboolean bottom;
GtkTextIter iter;
gchar *msg;
g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view));
g_return_if_fail (!EMP_STR_EMPTY (str));
bottom = chat_text_view_is_scrolled_down (text_view);
chat_text_view_maybe_trim_buffer (EMPATHY_CHAT_TEXT_VIEW (view));
chat_text_maybe_append_date_and_time (text_view,
empathy_time_get_current ());
gtk_text_buffer_get_end_iter (priv->buffer, &iter);
msg = g_strdup_printf (" - %s\n", str);
gtk_text_buffer_insert_with_tags_by_name (priv->buffer, &iter,
msg, -1,
EMPATHY_CHAT_TEXT_VIEW_TAG_EVENT,
NULL);
g_free (msg);
if (bottom) {
chat_text_view_scroll_down (view);
}
if (priv->last_contact) {
g_object_unref (priv->last_contact);
priv->last_contact = NULL;
g_object_notify (G_OBJECT (view), "last-contact");
}
}
///////////////////////////////////////////////////////////////////////////////////////////
//
// 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.
#ifndef USE_GTK12
GtkTextIter start;
GtkTextIter end;
GtkTextBuffer *buffer;
#endif
/*** Parameters end ***/
widget = lookupWidget(pWidgetName);
#ifdef USE_GTK12
gtk_editable_delete_text(GTK_EDITABLE(widget), 0, -1);
#else
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
#endif
return;
}// End clearTextArea
bool SourceEditor::setup()
{
if (!TextEditor::setup(s_sharedTagTable))
return false;
const PropertyTree &prefs =
Application::instance().preferences().child(TEXT_EDITOR);
if (prefs.get<bool>(FOLD_STRUCTURED_TEXT))
{
// Need to remove the invisible tag that may be copied from the source
// buffer.
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(gtkSourceView()));
GtkTextIter begin, end;
gtk_text_buffer_get_start_iter(buffer, &begin);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_remove_tag(buffer, tagInvisible, &begin, &end);
enableFolding();
if (static_cast<SourceFile &>(file()).structureUpdated())
onFileStructureUpdated();
}
return true;
}
void afficher_findchar()
{
/*
int in_size = 256;
int ou_size = 88;
char *chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+=/%()[]éèàùëêç.,;:?!&@$€";
int layers = 4;
int layers_Size[] = {in_size, 2*in_size, in_size, ou_size};
struct neuron **net = load_network(layers_Size, layers);
*/
open_image("image3.bmp",p_hBox);
GtkWidget *pWindow, *pVBox,*view;
pWindow= gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_move(GTK_WINDOW(pWindow), 50, 80);
g_signal_connect(G_OBJECT(pWindow), "delete-event",
G_CALLBACK(gtk_widget_hide_on_delete),G_OBJECT(pWindow));
view = gtk_text_view_new();
GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
GtkTextIter end;
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert(buffer, &end, "La chaine est affichée en console !", -1);
pVBox = gtk_vbox_new(TRUE, 0);
gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
gtk_box_pack_start(GTK_BOX(pVBox), view, TRUE, TRUE, 0);
gtk_window_set_default_size(GTK_WINDOW(pWindow), 700, 450);
gtk_widget_show_all(pWindow);
}
void XAttGtk::activate_cmd_scrolled_ok(GtkWidget* w, gpointer data)
{
XAttGtk* xatt = (XAttGtk*)data;
gchar *text, *textutf8;
int sts;
if (xatt->input_open) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(xatt->cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(xatt->cmd_scrolled_buffer, &end_iter);
textutf8 = gtk_text_buffer_get_text(
xatt->cmd_scrolled_buffer, &start_iter, &end_iter, FALSE);
text = g_convert(textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free(textutf8);
if (text)
sts = xatt->xattnav->set_attr_value(
xatt->input_node, xatt->input_name, text);
else
xatt->message('E', "Input error, invalid character");
g_object_set(xatt->cmd_scrolledinput, "visible", FALSE, NULL);
xatt->set_prompt("");
xatt->input_open = 0;
int w, h;
gdk_drawable_get_size(xatt->pane->window, &w, &h);
gtk_paned_set_position(GTK_PANED(xatt->pane), h - 50);
xatt->xattnav->redraw();
xatt->xattnav->set_inputfocus();
if (text)
g_free(text);
}
}
static void
script_fu_console_response (GtkWidget *widget,
gint response_id,
ConsoleInterface *console)
{
GtkTextIter start, end;
switch (response_id)
{
case RESPONSE_CLEAR:
gtk_text_buffer_get_start_iter (console->console, &start);
gtk_text_buffer_get_end_iter (console->console, &end);
gtk_text_buffer_delete (console->console, &start, &end);
break;
case RESPONSE_SAVE:
script_fu_console_save_dialog (console);
break;
default:
gtk_main_quit ();
break;
}
}
VISIBLE void removeAllBookmarks(GtkWidget *widget,GtkTextIter *titer)
{
ERRDATA
pageStruct *page=NULL;
int numpages;
GtkTextIter startiter;
GtkTextIter enditer;
numpages=gtk_notebook_get_n_pages(mainNotebook);
for(int j=0; j<numpages; j++)
{
page=getPageStructByIDFromPage(j);
if(page!=NULL)
{
gtk_text_buffer_get_start_iter((GtkTextBuffer*)page->buffer,&startiter);
gtk_text_buffer_get_end_iter((GtkTextBuffer*)page->buffer,&enditer);
gtk_source_buffer_remove_source_marks(page->buffer,&startiter,&enditer,NULL);
}
}
g_list_free_full(newBookMarksList,destroyBMData);
newBookMarksList=NULL;
rebuildBookMarkMenu();
gtk_widget_show_all(bookMarkMenu);
}
/* Set `text_buffer's text. This is a convenient function. If `text'
* doesn't end in a newline, it silently appends one, to ease editing.
* If `text' is NULL, then it sets text buffer's text to be empty
* string. Finally, it resets text buffer's `modified' flag.
*/
void
gtk_utils_set_text_buffer_text (GtkTextBuffer *text_buffer, const gchar *text)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (text_buffer));
if (text && *text) {
gint length = strlen (text);
GtkTextIter start_iterator;
gtk_text_buffer_set_text (text_buffer, text, length);
gtk_text_buffer_get_start_iter (text_buffer, &start_iterator);
gtk_text_buffer_place_cursor (text_buffer, &start_iterator);
if (text[length - 1] != '\n') {
GtkTextIter end_iterator;
gtk_text_buffer_get_end_iter (text_buffer, &end_iterator);
gtk_text_buffer_insert (text_buffer, &end_iterator, "\n", 1);
}
}
else
gtk_text_buffer_set_text (text_buffer, "", 0);
}
void result_item_print_rule_diff(result_item_t * item, GtkTextBuffer * tb, poldiff_form_e form)
{
GtkTextIter iter;
const apol_vector_t *v;
size_t i;
void *elem;
char *s = NULL;
gtk_text_buffer_get_end_iter(tb, &iter);
v = result_item_get_vector(item);
for (i = 0; i < apol_vector_get_size(v); i++) {
elem = apol_vector_get_element(v, i);
if (result_item_get_form(item, elem) == form) {
s = result_item_get_string(item, elem);
if (form != POLDIFF_FORM_MODIFIED) {
result_item_print_string(tb, &iter, s, 1);
} else {
result_item_print_string_inline(tb, &iter, s, 1);
}
free(s);
gtk_text_buffer_insert(tb, &iter, "\n", -1);
}
}
}
int read_window_text (GtkWidget *listbox,
GtkWidget *text,
int role,
gpointer data,
const DATASET *dset,
int (*should_stop)())
{
int err = 0;
if (dset == NULL) {
return read_listbox_content(listbox, should_stop);
}
if (role == SUMMARY ||
role == VAR_SUMMARY ||
role == CORR ||
role == COVAR ||
role == COEFFINT ||
role == VIEW_MODEL) {
err = audio_print_special(role, data, dset, should_stop);
} else {
GtkTextBuffer *tbuf;
GtkTextIter start, end;
gchar *window_text;
tbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_start_iter(tbuf, &start);
gtk_text_buffer_get_end_iter(tbuf, &end);
window_text = gtk_text_buffer_get_text(tbuf, &start, &end, FALSE);
err = speak_buffer(window_text, should_stop);
g_free(window_text);
}
return err;
}
static guint
setup_scroll (GtkTextView *textview,
gboolean to_end)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
buffer = gtk_text_view_get_buffer (textview);
gtk_text_buffer_get_end_iter (buffer, &iter);
if (to_end)
{
/* If we want to scroll to the end, including horizontal scrolling,
* then we just create a mark with right gravity at the end of the
* buffer. It will stay at the end unless explicitely moved with
* gtk_text_buffer_move_mark.
*/
gtk_text_buffer_create_mark (buffer, "end", &iter, FALSE);
/* Add scrolling timeout. */
return g_timeout_add (50, (GSourceFunc) scroll_to_end, textview);
}
else
{
/* If we want to scroll to the bottom, but not scroll horizontally,
* then an end mark won't do the job. Just create a mark so we can
* use it with gtk_text_view_scroll_mark_onscreen, we'll position it
* explicitely when needed. Use left gravity so the mark stays where
* we put it after inserting new text.
*/
gtk_text_buffer_create_mark (buffer, "scroll", &iter, TRUE);
/* Add scrolling timeout. */
return g_timeout_add (100, (GSourceFunc) scroll_to_bottom, textview);
}
}
static void
show_parsing_error (GtkCssProvider *provider,
const gchar *path,
guint line,
guint position,
const GError *error,
GtkTextBuffer *buffer)
{
GtkTextIter start, end;
const char *tag_name;
gtk_text_buffer_get_iter_at_line (buffer, &start, line - 1);
if (gtk_text_buffer_get_line_count (buffer) <= line)
gtk_text_buffer_get_end_iter (buffer, &end);
else
gtk_text_buffer_get_iter_at_line (buffer, &end, line);
if (g_error_matches (error, GTK_CSS_PROVIDER_ERROR, GTK_CSS_PROVIDER_ERROR_DEPRECATED))
tag_name = "warning";
else
tag_name = "error";
gtk_text_buffer_apply_tag_by_name (buffer, tag_name, &start, &end);
}
/* [gtk thread] */
static gboolean do_append_native_text_log(gpointer data)
{
ALLEGRO_NATIVE_DIALOG *textlog = data;
al_lock_mutex(textlog->tl_text_mutex);
GtkTextView *tv = GTK_TEXT_VIEW(textlog->tl_textview);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(tv);
GtkTextIter iter;
GtkTextMark *mark;
gtk_text_buffer_get_end_iter(buffer, &iter);
gtk_text_buffer_insert(buffer, &iter, al_cstr(textlog->tl_pending_text), -1);
mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, FALSE);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textlog->tl_textview), mark);
gtk_text_buffer_delete_mark(buffer, mark);
al_ustr_truncate(textlog->tl_pending_text, 0);
textlog->tl_have_pending = false;
al_unlock_mutex(textlog->tl_text_mutex);
return FALSE;
}
static gboolean
append_text(MarkdownTextView * self,
const gchar * text)
{
GtkTextIter iter;
GtkTextBuffer *text_buffer;
gchar *line;
g_return_val_if_fail(IS_MARKDOWN_TEXTVIEW(self), FALSE);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(self));
gtk_text_buffer_get_end_iter(text_buffer, &iter);
line = egg_markdown_parse(self->markdown, text);
if (line && *line) {
gtk_text_buffer_insert_markup(text_buffer, &iter, line);
gtk_text_buffer_insert(text_buffer, &iter, "\n", 1);
g_free(line);
return TRUE;
}
return FALSE;
}
static void
text_read_callback (GnomeVFSAsyncHandle *handle,
GnomeVFSResult result,
gpointer buffer,
GnomeVFSFileSize bytes_requested,
GnomeVFSFileSize bytes_read,
gpointer cdata)
{
GtkTextIter iter;
GtkTextBuffer *text_buffer;
g_return_if_fail (buffer != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER(cdata));
text_buffer = GTK_TEXT_BUFFER(cdata);
if (result != GNOME_VFS_OK) {
gchar *message;
message = g_strdup_printf ("\n<<Error: %s>>", gnome_vfs_result_to_string (result));
g_return_if_fail (message != NULL);
gtk_text_buffer_set_text (text_buffer, message, -1);
g_free (message);
}
gtk_text_buffer_get_end_iter (text_buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (text_buffer, &iter, (gchar *)buffer, bytes_read, "default-tag", NULL);
if (bytes_requested == bytes_read)
gnome_vfs_async_read (handle, buffer, TEXT_BUFFER_SIZE, text_read_callback, cdata);
else {
g_free (buffer);
gnome_vfs_async_close (handle, text_close_callback, cdata);
}
}
static void
combochange_log (const char *fmt,
...)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
GtkTextIter iter;
va_list vap;
char *msg;
GString *order_string;
GtkTextMark *tmp_mark;
int i;
va_start (vap, fmt);
msg = g_strdup_vprintf (fmt, vap);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, msg, -1);
order_string = g_string_new ("\n ");
for (i = 0; i < contents->len; i++)
{
if (i)
g_string_append_c (order_string, ' ');
g_string_append_c (order_string, g_array_index (contents, char, i));
}
g_string_append_c (order_string, '\n');
gtk_text_buffer_insert (buffer, &iter, order_string->str, -1);
g_string_free (order_string, TRUE);
tmp_mark = gtk_text_buffer_create_mark (buffer, NULL, &iter, FALSE);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (text_view), tmp_mark);
gtk_text_buffer_delete_mark (buffer, tmp_mark);
g_free (msg);
}
void
gui_chat_log (GsClient *client, const gchar *name, gint team, const gchar *msg)
{
GtkTextIter iter;
gtk_text_buffer_get_end_iter (client->chat_buffer, &iter);
if (gtk_text_buffer_get_char_count (client->chat_buffer) > 0)
gtk_text_buffer_insert (client->chat_buffer, &iter, "\n", -1);
gtk_text_buffer_insert_with_tags (client->chat_buffer, &iter,
name, -1, tags[team], NULL);
gtk_text_buffer_insert (client->chat_buffer, &iter, ": ", -1);
gtk_text_buffer_insert (client->chat_buffer, &iter, msg, -1);
if (gui_slist_get_selected () == client) {
GtkAdjustment *adj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (logview));
gdouble upper, value, page_size;
g_object_get (adj, "value", &value, "upper", &upper, "page-size", &page_size, NULL);
if (value + page_size >= upper) {
GtkTextMark *mark = gtk_text_buffer_create_mark (
client->chat_buffer, NULL, &iter, TRUE);
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (logview), mark);
gtk_text_buffer_delete_mark (client->chat_buffer, mark);
}
}
}
static GValue *
real_get_value (GdauiEntryWrapper *mgwrap)
{
GValue *value;
GdauiEntryString *mgstr;
GdaDataHandler *dh;
g_return_val_if_fail (GDAUI_IS_ENTRY_STRING (mgwrap), NULL);
mgstr = GDAUI_ENTRY_STRING (mgwrap);
GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr);
dh = gdaui_data_entry_get_handler (GDAUI_DATA_ENTRY (mgwrap));
if (! priv->multiline) {
gchar *cstr;
cstr = gdaui_entry_get_text (GDAUI_ENTRY (priv->entry));
value = gda_data_handler_get_value_from_str (dh, cstr, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap)));
g_free (cstr);
}
else {
GtkTextIter start, end;
gchar *str;
gtk_text_buffer_get_start_iter (priv->buffer, &start);
gtk_text_buffer_get_end_iter (priv->buffer, &end);
str = gtk_text_buffer_get_text (priv->buffer, &start, &end, FALSE);
value = gda_data_handler_get_value_from_str (dh, str, gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (mgwrap)));
g_free (str);
}
if (!value) {
/* in case the gda_data_handler_get_value_from_str() returned an error because
the contents of the GtkEntry cannot be interpreted as a GValue */
value = gda_value_new_null ();
}
return value;
}
int XAttOneGtk::change_value(int set_focus)
{
int sts;
GtkWidget* text_w;
char* value = 0;
int input_size;
char aval[1024];
char buf[1024];
int len;
sts = gdh_GetAttributeCharAttrref(&aref, &atype, &asize, &aoffs, &aelem);
if (EVEN(sts))
return sts;
switch (atype) {
case pwr_eType_String:
case pwr_eType_Text:
input_size = asize;
break;
default:
input_size = 80;
}
sts = gdh_GetObjectInfoAttrref(&aref, aval, sizeof(aval));
if (EVEN(sts))
return sts;
if (atype == pwr_eType_Text)
value = aval;
else {
XNav::attrvalue_to_string(
atype, atype, &aval, buf, sizeof(buf), &len, NULL, 0);
value = buf;
}
if (!access_rw) {
gtk_label_set_text(GTK_LABEL(cmd_label), buf);
} else {
if (atype == pwr_eType_Text) {
text_w = cmd_scrolledinput;
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", TRUE, NULL);
// int w, h;
// gdk_drawable_get_size( pane->window, &w, &h);
// gtk_paned_set_position( GTK_PANED(pane), h - 170);
if (set_focus)
gtk_widget_grab_focus(cmd_scrolledtextview);
input_multiline = 1;
if (value) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_insert(cmd_scrolled_buffer, &start_iter, value, -1);
} else {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
}
} else {
text_w = cmd_input;
g_object_set(cmd_input, "visible", TRUE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
if (set_focus)
gtk_widget_grab_focus(cmd_input);
input_multiline = 0;
gtk_entry_set_max_length(GTK_ENTRY(text_w), input_size - 1);
gint pos = 0;
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
if (value) {
gtk_editable_insert_text(
GTK_EDITABLE(text_w), value, strlen(value), &pos);
// Select the text
gtk_editable_set_position(GTK_EDITABLE(cmd_input), -1);
gtk_editable_select_region(GTK_EDITABLE(cmd_input), 0, -1);
}
}
message(' ', "");
set_prompt(Lng::translate("value >"));
input_open = 1;
}
return XATT__SUCCESS;
}
static void
gb_vim_do_search_and_replace (GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end,
const gchar *search_text,
const gchar *replace_text,
gboolean is_global)
{
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
GtkTextMark *mark;
GtkTextIter tmp1;
GtkTextIter tmp2;
GtkTextIter match_begin;
GtkTextIter match_end;
gboolean has_wrapped = FALSE;
GError *error = NULL;
g_assert (search_text);
g_assert (replace_text);
g_assert ((!begin && !end) || (begin && end));
search_settings = gtk_source_search_settings_new ();
search_context = gtk_source_search_context_new (GTK_SOURCE_BUFFER (buffer), search_settings);
if (!begin)
{
gtk_text_buffer_get_start_iter (buffer, &tmp1);
begin = &tmp1;
}
if (!end)
{
gtk_text_buffer_get_end_iter (buffer, &tmp2);
end = &tmp2;
}
mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);
gtk_source_search_settings_set_search_text (search_settings, search_text);
gtk_source_search_settings_set_case_sensitive (search_settings, TRUE);
while (gtk_source_search_context_forward2 (search_context,
begin,
&match_begin,
&match_end,
&has_wrapped) && !has_wrapped)
{
if (is_global || gb_vim_match_is_selected (buffer, &match_begin, &match_end))
{
if (!gtk_source_search_context_replace2 (search_context, &match_begin, &match_end,
replace_text, -1, &error))
{
g_warning ("%s", error->message);
g_clear_error (&error);
break;
}
}
*begin = match_end;
gtk_text_buffer_get_iter_at_mark (buffer, end, mark);
}
gtk_text_buffer_delete_mark (buffer, mark);
g_clear_object (&search_settings);
g_clear_object (&search_context);
}
/**
*修改日志
*/
void modify_log(void) {
gchar *title = gtk_entry_get_text(GTK_ENTRY(contentTitleEntry)); //获取标题
GtkTextBuffer *gtb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(contentContentTextView));
GtkTextIter start;
GtkTextIter end;
SAVE_LOG_FILE_SUCCESS_RETURN_TYPE *saveSuccess = NULL;//是否保存成功
gtk_text_buffer_get_start_iter(gtb,&start);
gtk_text_buffer_get_end_iter(gtb,&end);
gchar *content = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(gtb),&start,&end,TRUE); //获取内容
saveSuccess = save_log_file(SAVE_MODIFY_LOG_FILE,title,content,modifyFileName);
fprintf(stderr,"要修改的文件为%s 标题%s 内容%s 是否保存成功%s\n",modifyFileName,title,content,(saveSuccess==NULL?"否":"是"));
if(saveSuccess!=NULL) {
int i = 0;
int k = 0;
short hasDoublePoint = 0;//是否有冒号，用于判断是否点击第二层目录
int first = 0;//第一层
int second = 0;//第二层
int temp = 0; //计算当前权数
int nums = 0;//当前数的位数-1
char *catalogFileStr = NULL; //目录文件字符串
for(i=0 ; i<strlen(selectedTreeIndexStr) ; i++) {
if(selectedTreeIndexStr[i] == ':') {
hasDoublePoint = 1;
nums = 0;
} else {
if(!hasDoublePoint) { //正在读一级目录序
temp = 0;
for(k=0 ; k<nums ; k++) {
temp = temp*10;
}
if(temp==0)
first += selectedTreeIndexStr[i]-48;
else
first += ((selectedTreeIndexStr[i]-48)*temp);
nums++;
} else { //正在读二级目录序
temp = 0;
for(k=0 ; k<nums ; k++) {
temp = temp*10;
}
if(temp==0)
second += selectedTreeIndexStr[i]-48;
else
second += ((selectedTreeIndexStr[i]-48)*temp);
nums++;
}
}
}
FILE_CATALOG *tempfc = fileCatalogInUi;
for(i=0 ; i<first ; i++)
tempfc = tempfc->brother;
FILE_DETAIL_CATALOG *tempdc = tempfc->headChild;
for(i=0 ; i<second ; i++)
tempdc = tempdc->brother;
if(tempdc->title!=NULL)
free(tempdc->title);
tempdc->title = (char *)malloc(strlen(title)+1);
memset(tempdc->title,0x00,strlen(title)+1);
strcpy(tempdc->title,title);
catalogFileStr = convert_file_to_str_catalog(fileCatalogInUi,NULL,NULL);
fprintf(stderr,"劲哥你好:%s\n",catalogFileStr);
fprintf(stderr,"修改目录文件%d\n",save_or_modify_catalog_file(catalogFileStr));
fprintf(stderr,"点击的 first:%d second:%d 原标题为：%s\n",first,second,tempdc->title);
init_right_main_view_hide_all("修改成功");
init_tree_view_catalog();//刷新树目录
} else {
init_right_main_view_hide_all("修改失败");
}
free(saveSuccess);
}
static void
insert_text (GtkTextBuffer *buffer, const gchar *text)
{
GtkTextMark *emph_point = NULL;
GtkTextMark *bold_point = NULL;
while (*text)
{
GtkTextIter here;
gchar *next;
gtk_text_buffer_get_end_iter (buffer, &here);
if ((*text == '\'') && (text[1] == '\'') && (text[2] == '\''))
{
if (!bold_point)
{
bold_point = gtk_text_buffer_create_mark (buffer, "bold",
&here, TRUE);
}
else
{
GtkTextIter past;
gtk_text_buffer_get_iter_at_mark (buffer, &past, bold_point);
gtk_text_buffer_apply_tag_by_name (buffer, "bold", &past, &here);
gtk_text_buffer_delete_mark (buffer, bold_point);
bold_point = NULL;
}
text += 3;
continue;
}
if ((*text == '\'') && (text[1] == '\''))
{
if (!emph_point)
{
emph_point = gtk_text_buffer_create_mark (buffer, "emph",
&here, TRUE);
}
else
{
GtkTextIter past;
gtk_text_buffer_get_iter_at_mark (buffer, &past, emph_point);
gtk_text_buffer_apply_tag_by_name (buffer, "emph", &past, &here);
gtk_text_buffer_delete_mark (buffer, emph_point);
emph_point = NULL;
}
text += 2;
continue;
}
for (next = g_utf8_next_char (text);
*next && (*next != '\'');
next = g_utf8_next_char (next));
gtk_text_buffer_insert (buffer, &here, text, next - text);
text = next;
}
}
static void
theme_boxes_maybe_append_header (EmpathyThemeBoxes *theme,
EmpathyMessage *msg)
{
EmpathyChatTextView *view = EMPATHY_CHAT_TEXT_VIEW (theme);
EmpathyThemeBoxesPriv*priv = GET_PRIV (theme);
EmpathyContact *contact;
EmpathyContact *last_contact;
GdkPixbuf *avatar = NULL;
GtkTextBuffer *buffer;
const gchar *name;
GtkTextIter iter;
GtkWidget *label1, *label2;
GtkTextChildAnchor *anchor;
GtkWidget *box;
gchar *str;
time_t time_;
gchar *tmp;
GtkTextIter start;
gboolean color_set;
GtkTextTagTable *table;
GtkTextTag *tag;
GString *str_obj;
gboolean consecutive;
contact = empathy_message_get_sender (msg);
name = empathy_contact_get_alias (contact);
last_contact = empathy_chat_text_view_get_last_contact (view);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (theme));
time_ = empathy_message_get_timestamp (msg);
consecutive = (time_ - empathy_chat_text_view_get_last_timestamp (view)
< MESSAGE_JOIN_PERIOD);
DEBUG ("Maybe add fancy header");
/* Only insert a header if
* - the previously inserted block is not the same as this one.
* - the delay between two messages is lower then MESSAGE_JOIN_PERIOD
*/
if (empathy_contact_equal (last_contact, contact) && consecutive) {
return;
}
empathy_chat_text_view_append_spacing (view);
/* Insert header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
/* Create a hbox for the header and resize it when the view allocation
* changes */
box = gtk_hbox_new (FALSE, 0);
g_signal_connect_object (view, "size-allocate",
G_CALLBACK (table_size_allocate_cb),
box, 0);
/* Add avatar to the box if needed */
if (priv->show_avatars) {
avatar = theme_boxes_get_avatar_pixbuf_with_cache (contact);
if (avatar) {
GtkWidget *image;
image = gtk_image_new_from_pixbuf (avatar);
gtk_box_pack_start (GTK_BOX (box), image,
FALSE, TRUE, 2);
}
}
/* Add contact alias */
str = g_markup_printf_escaped ("<b>%s</b>", name);
label1 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 0.0,
NULL);
g_free (str);
/* Add the message receive time */
tmp = empathy_time_to_string_local (time_,
EMPATHY_TIME_FORMAT_DISPLAY_SHORT);
str = g_strdup_printf ("<i>%s</i>", tmp);
label2 = g_object_new (GTK_TYPE_LABEL,
"label", str,
"use-markup", TRUE,
"xalign", 1.0,
NULL);
str_obj = g_string_new ("\n- ");
g_string_append (str_obj, name);
g_string_append (str_obj, ", ");
g_string_append (str_obj, tmp);
g_string_append (str_obj, " -");
g_free (tmp);
g_free (str);
/* Set foreground color of labels to the same color than the header tag. */
table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_THEME_BOXES_TAG_HEADER);
g_object_get (tag, "foreground-set", &color_set, NULL);
if (color_set) {
GdkColor *color;
g_object_get (tag, "foreground-gdk", &color, NULL);
gtk_widget_modify_fg (label1, GTK_STATE_NORMAL, color);
gtk_widget_modify_fg (label2, GTK_STATE_NORMAL, color);
gdk_color_free (color);
}
/* Pack labels into the box */
gtk_misc_set_alignment (GTK_MISC (label1), 0.0, 0.5);
gtk_misc_set_alignment (GTK_MISC (label2), 1.0, 0.5);
gtk_box_pack_start (GTK_BOX (box), label1, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (box), label2, TRUE, TRUE, 0);
/* Add the header box to the text view */
g_object_set_data_full (G_OBJECT (box),
"str_obj",
g_string_free (str_obj, FALSE),
g_free);
gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW (view),
box,
anchor);
gtk_widget_show_all (box);
/* Insert a header line */
gtk_text_buffer_get_end_iter (buffer, &iter);
start = iter;
gtk_text_iter_backward_char (&start);
gtk_text_buffer_apply_tag_by_name (buffer,
EMPATHY_THEME_BOXES_TAG_HEADER,
&start, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER,
NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags_by_name (buffer,
&iter,
"\n",
-1,
EMPATHY_THEME_BOXES_TAG_HEADER_LINE,
NULL);
}
