GtkWidget * about_widget_create_view_from_file(char * file, char * default_text)
{
GtkTextView * view = GTK_TEXT_VIEW(gtk_text_view_new());
gtk_text_view_set_editable(view, FALSE);
gtk_text_view_set_cursor_visible(view, FALSE);
gtk_text_view_set_wrap_mode(view, GTK_WRAP_WORD_CHAR);
char * file_path = vex_term_find_ressource(file);
if (file_path != NULL){
SrtParser * srt = srt_parser_new();
//TODO: need to free the SrtParser
GtkTextBuffer * buffer = srt_parser_parse_file(srt, file_path);
free(file_path);
if (buffer != NULL){
gtk_text_view_set_buffer(view, buffer);
return GTK_WIDGET(view);
}
}
GtkTextBuffer * buffer = gtk_text_buffer_new(NULL);
GtkTextIter iter;
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
gtk_text_view_set_buffer(view, buffer);
gtk_text_buffer_insert(buffer, &iter, default_text, -1);
return GTK_WIDGET(view);
}
GtkWidget *hview_get_message_window(HviewWidgetsT *w)
{
GtkWidget *window;
GtkWidget *log_view;
GtkTextBuffer *buf;
window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(GTK_WIDGET(window),
HVIEW_LOG_WINDOW_WIDTH,
HVIEW_LOG_WINDOW_HEIGHT);
log_view = gtk_text_view_new();
buf = gtk_text_buffer_new(NULL);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(log_view), buf);
gtk_text_view_set_editable(GTK_TEXT_VIEW(log_view), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(log_view), FALSE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(window),
log_view);
w->message_view = log_view;
return window;
}
static GObject*
_gcr_display_view_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GObject *obj = G_OBJECT_CLASS (_gcr_display_view_parent_class)->constructor (type, n_props, props);
GcrDisplayView *self = NULL;
GtkTextView *view = NULL;
GtkTextTagTable *tags;
g_return_val_if_fail (obj, NULL);
self = GCR_DISPLAY_VIEW (obj);
view = GTK_TEXT_VIEW (obj);
tags = create_tag_table (self);
self->pv->buffer = gtk_text_buffer_new (tags);
g_object_unref (tags);
gtk_text_view_set_buffer (view, self->pv->buffer);
gtk_text_view_set_editable (view, FALSE);
gtk_text_view_set_left_margin (view, NORMAL_MARGIN);
gtk_text_view_set_right_margin (view, NORMAL_MARGIN);
gtk_text_view_set_cursor_visible (view, FALSE);
return obj;
}
static GtkWidget *
create_text (GtkTextBuffer **buffer,
gboolean is_source)
{
GtkWidget *scrolled_window;
GtkWidget *text_view;
PangoFontDescription *font_desc;
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
text_view = gtk_text_view_new ();
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
*buffer = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), *buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
if (is_source)
{
font_desc = pango_font_description_from_string ("Courier 10");
gtk_widget_modify_font (text_view, font_desc);
pango_font_description_free (font_desc);
}
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view), !is_source);
return scrolled_window;
}
void ctk_help_set_page(CtkHelp *ctk_help, GtkTextBuffer *buffer)
{
GtkTextBuffer *b;
GtkTextIter iter;
GtkTextView *view;
GtkTextMark *mark;
if (buffer) {
b = buffer;
} else {
b = ctk_help->default_help;
}
view = GTK_TEXT_VIEW(ctk_help->text_viewer);
/* set the buffer in the TextView */
gtk_text_view_set_buffer(view, b);
/* ensure that the top of the buffer is displayed */
gtk_text_buffer_get_start_iter(b, &iter);
mark = gtk_text_buffer_create_mark(b, NULL, &iter, TRUE);
gtk_text_view_scroll_to_mark(view, mark, 0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_place_cursor(b, &iter);
}
/**
*显示文章具体内容
* filename 文件名
* selectIndex 在树中选中的位置索引，与树file层数据结构对应
*/
void init_main_view_content(const char *filename,const char *selectIndex) {
selectedTreeIndexStr = selectIndex;
fprintf(stderr,"开始显示文章:%s %s\n",filename,selectedTreeIndexStr);
if(modifyFileName!=NULL) {
free(modifyFileName);
}
modifyFileName = (char *)malloc(strlen(filename)+1);
memset(modifyFileName,0x00,strlen(filename)+1);//设置全局变量
strcpy(modifyFileName,filename);
FILE_CONTENT *filecontent = read_log_file(filename);
if(filecontent != NULL) {
gtk_widget_hide(saveButton);
gtk_entry_set_text(GTK_ENTRY(contentTitleEntry),filecontent->title); //设置标题
gtk_text_buffer_set_text(textBuffer,filecontent->content,strlen(filecontent->content));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(contentContentTextView),textBuffer);
gtk_widget_hide(saveButton);
gtk_widget_show(contentTitleEntry);
gtk_widget_show(contentContentTextView);
gtk_widget_show(modifyButton);
gtk_widget_show(deleteButton);
} else { //读文件出错
}
}
void
gui_window_switch_to_buffer (struct t_gui_window *window,
struct t_gui_buffer *buffer,
int set_last_read)
{
GtkTextIter start, end;
gui_buffer_add_value_num_displayed (window->buffer, -1);
if (window->buffer != buffer)
{
window->scroll->start_line = NULL;
window->scroll->start_line_pos = 0;
if (!gui_buffers_visited_frozen)
{
gui_buffer_visited_add (window->buffer);
gui_buffer_visited_add (buffer);
}
if (set_last_read)
{
if (window->buffer->num_displayed == 0)
{
window->buffer->lines->last_read_line = window->buffer->lines->last_line;
window->buffer->lines->first_line_not_read = 0;
}
if (buffer->lines->last_read_line == buffer->lines->last_line)
{
buffer->lines->last_read_line = NULL;
buffer->lines->first_line_not_read = 0;
}
}
}
window->buffer = buffer;
gui_window_calculate_pos_size (window);
if (!GUI_WINDOW_OBJECTS(window)->textview_chat)
{
GUI_WINDOW_OBJECTS(window)->textview_chat = gtk_text_view_new ();
gtk_widget_show (GUI_WINDOW_OBJECTS(window)->textview_chat);
gtk_container_add (GTK_CONTAINER (gui_gtk_scrolledwindow_chat), GUI_WINDOW_OBJECTS(window)->textview_chat);
gtk_widget_set_size_request (GUI_WINDOW_OBJECTS(window)->textview_chat, 300, -1);
gtk_text_view_set_editable (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), FALSE);
GUI_WINDOW_OBJECTS(window)->textbuffer_chat = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), GUI_WINDOW_OBJECTS(window)->textbuffer_chat);
/*GUI_WINDOW_OBJECTS(window)->texttag_chat = gtk_text_buffer_create_tag(GUI_WINDOW_OBJECTS(window)->textbuffer_chat, "courier", "font_family", "lucida");*/
gtk_text_buffer_get_bounds (GUI_WINDOW_OBJECTS(window)->textbuffer_chat, &start, &end);
gtk_text_buffer_apply_tag (GUI_WINDOW_OBJECTS(window)->textbuffer_chat, GUI_WINDOW_OBJECTS(window)->texttag_chat, &start, &end);
}
window->scroll->start_line = NULL;
window->scroll->start_line_pos = 0;
gui_buffer_add_value_num_displayed (buffer, 1);
gui_hotlist_remove_buffer (buffer);
}
static void
xfce_about_license (GtkBuilder *builder,
GObject *buffer)
{
GObject *dialog;
GObject *object;
static gboolean initial = TRUE;
g_return_if_fail (GTK_IS_BUILDER (builder));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
object = gtk_builder_get_object (builder, "license-textview");
gtk_text_view_set_buffer (GTK_TEXT_VIEW (object), GTK_TEXT_BUFFER (buffer));
dialog = gtk_builder_get_object (builder, "license-dialog");
if (initial)
{
g_signal_connect (G_OBJECT (dialog), "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
object = gtk_builder_get_object (builder, "license-close-button");
g_signal_connect_swapped (G_OBJECT (object), "clicked",
G_CALLBACK (gtk_widget_hide), dialog);
object = gtk_builder_get_object (builder, "window");
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (object));
initial = FALSE;
}
gtk_widget_show (GTK_WIDGET (dialog));
}
void
matedialog_text (MateDialogData *data, MateDialogTextData *text_data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GObject *text_view;
GtkTextBuffer *text_buffer;
zen_text_data = text_data;
builder = matedialog_util_load_ui_file ("matedialog_text_dialog",
"textbuffer1", NULL);
if (builder == NULL) {
data->exit_code = matedialog_util_return_exit_code (MATEDIALOG_ERROR);
return;
}
gtk_builder_connect_signals (builder, NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "matedialog_text_dialog"));
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (matedialog_text_dialog_response), data);
if (data->dialog_title)
gtk_window_set_title (GTK_WINDOW (dialog), data->dialog_title);
matedialog_util_set_window_icon (dialog, data->window_icon, MATEDIALOG_IMAGE_FULLPATH ("matedialog-text.png"));
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE);
text_buffer = gtk_text_buffer_new (NULL);
text_view = gtk_builder_get_object (builder, "matedialog_text_view");
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), text_buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW(text_view), text_data->editable);
if (text_data->uri)
matedialog_util_fill_file_buffer (text_buffer, text_data->uri);
else
matedialog_text_fill_entries_from_stdin (GTK_TEXT_BUFFER (text_buffer));
if (text_data->editable)
zen_text_data->buffer = text_buffer;
if (data->width > -1 || data->height > -1)
gtk_window_set_default_size (GTK_WINDOW (dialog), data->width, data->height);
else
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 400);
matedialog_util_show_dialog (dialog);
g_object_unref (builder);
if(data->timeout_delay > 0) {
g_timeout_add_seconds (data->timeout_delay, (GSourceFunc) matedialog_util_timeout_handle, NULL);
}
gtk_main ();
}
static void
filelist_sel_handler(ASGtkImageDir *id, gpointer user_data)
{
ASFileBrowserMainFrame *data = (ASFileBrowserMainFrame *)user_data;
if( data )
{
ASImageListEntry *le = asgtk_image_dir_get_selection( id );
if( le )
{
if( le->type != ASIT_XMLScript )
{
gtk_widget_hide( data->view_xml );
asgtk_xml_view_set_entry ( ASGTK_XML_VIEW(data->view_xml), NULL );
}else
{
gtk_widget_show( data->view_xml );
asgtk_xml_view_set_entry ( ASGTK_XML_VIEW(data->view_xml), le );
}
if( le->type == ASIT_Unknown )
{
gtk_widget_hide( data->view_image );
asgtk_image_view_set_entry ( ASGTK_IMAGE_VIEW(data->view_image), NULL);
}else
{
gtk_widget_show( data->view_image );
asgtk_image_view_set_entry ( ASGTK_IMAGE_VIEW(data->view_image), le);
}
load_asimage_list_entry_data( le, DEFAULT_MAX_TEXT_SIZE );
if( !get_flags( le->buffer->flags, ASILEB_Binary) )
{ /* use text view */
gtk_widget_show( data->view_text_win );
gtk_widget_hide( data->view_hex_win );
gtk_text_buffer_set_text( data->text_buffer, le->buffer->data, le->buffer->size );
gtk_text_view_set_buffer( GTK_TEXT_VIEW(data->view_text), data->text_buffer );
}else
{ /* use hex view */
gtk_widget_show( data->view_hex_win );
gtk_widget_hide( data->view_text_win );
gtk_text_view_set_buffer( GTK_TEXT_VIEW(data->view_hex), data->text_buffer );
}
unref_asimage_list_entry( le );
}
}
}
static VALUE
textview_set_buffer(VALUE self, VALUE buf)
{
G_CHILD_SET(self, id_buffer, buf);
gtk_text_view_set_buffer(_SELF(self),
NIL_P(buf) ? NULL : RVAL2BUFFER(buf));
return self;
}
void
on_clear_chat_contents_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
GtkWidget* view = (GtkWidget*)lookup_widget(main_window, "text_chat");
GtkTextBuffer* buffer = gtk_text_buffer_new(NULL);
gtk_text_view_set_buffer(GTK_TEXT_VIEW (view),buffer);
}
GTKTextView::GTKTextView(GTKWidget *Parent, int Width, int Height, bool NeedsParenting) : GTKContainer(gtk_text_view_new()), AutoScroll(false)
{
TextView = GTK_TEXT_VIEW(Container);
if (NeedsParenting != FALSE)
SetParent(Parent);
gtk_widget_set_size_request(Widget, Width, Height);
TextBuffer = new GTKTextBuffer();
gtk_text_view_set_buffer(TextView, TextBuffer->GetBuffer());
}
static void menu_new (GtkMenuItem *menuitem, gpointer data) {
if (save_if_modified()) {
// get all the current tag table and put them in the new buffer
editor_buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(editor_buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(editor_view), editor_buf);
g_object_unref(G_OBJECT(editor_buf));
// needed for freeing memory by the buffer when a new buffer is created
}
}
void bug_information_window_new(GtkWidget * window)
{
GtkWidget *dialog;
GtkTextBuffer *buffer;
GtkWidget *scrolled_window, *text_view;
PangoTabArray *tab_array;
/* Basic dialog with a close button */
dialog = gtk_dialog_new_with_buttons(_("Bug information"),
(window) ? (GtkWindow *) playlist3_get_window() : NULL,
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CLOSE, GTK_RESPONSE_YES, NULL);
/* Set default window size */
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 800);
/* The buffer that holds the "report" */
buffer = gtk_text_buffer_new(NULL);
bug_information_generate_message(buffer);
/* View to show the textbuffer */
text_view = gtk_text_view_new();
/* setup textview */
/* set tabarray */
tab_array = pango_tab_array_new_with_positions(1, TRUE, PANGO_TAB_LEFT, 500);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(text_view), TRUE);
gtk_text_view_set_tabs(GTK_TEXT_VIEW(text_view), tab_array);
pango_tab_array_free(tab_array);
/* not editable */
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), FALSE);
/* set margins */
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text_view), 12);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(text_view), 12);
/* Add the text buffer */
gtk_text_view_set_buffer(GTK_TEXT_VIEW(text_view), buffer);
/* scrolled window, this allows the text view to scroll */
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
/* setup scrolled window */
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* add text view to scrolled_window */
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
/* add scrolled_window to dialog */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolled_window, TRUE, TRUE, 0);
/* Add dialogs response handler */
g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(gtk_widget_destroy), NULL);
/* show dialog */
gtk_widget_show_all(dialog);
if (window == NULL)
{
gtk_dialog_run(GTK_DIALOG(dialog));
}
}
void gui_run() {
gtk_text_view_set_buffer(gui->txtResults,gui->txtBuffer);
gtk_builder_connect_signals (builder, NULL);
// g_object_unref (G_OBJECT (builder));
gtk_widget_show (gui->window);
gtk_main ();
}
static void menu_open (GtkMenuItem *menuitem, gpointer data) {
if (save_if_modified()) {
// call save if modified when user opens a new file
editor_buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(editor_buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(editor_view), editor_buf);
// needed for freeing memory by the buffer when a new buffer is created
g_object_unref(G_OBJECT(editor_buf));
load_file(NULL);
}
}
void
gui_chat_setup (GsClient *client)
{
if (client) {
gtk_widget_set_sensitive (page, TRUE);
GtkTextIter iter;
gtk_text_view_set_buffer (GTK_TEXT_VIEW (logview), client->chat_buffer);
gtk_text_buffer_get_end_iter (client->chat_buffer, &iter);
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);
} else {
gtk_widget_set_sensitive (page, FALSE);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (logview), NULL);
}
}
static void hview_print(const gchar *string)
{
GtkTextBuffer *buf;
GtkTextIter iter;
buf = GTK_TEXT_BUFFER(gtk_text_view_get_buffer(GTK_TEXT_VIEW(log_view)));
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, string, -1);
gtk_text_buffer_insert(buf, &iter, "\n", -1);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(log_view), buf);
}
void
cainteoir_document_view_set_document(CainteoirDocumentView *view, CainteoirDocument *doc)
{
CainteoirDocumentViewPrivate *priv = CAINTEOIR_DOCUMENT_VIEW_PRIVATE(view);
if (priv->doc) g_object_unref(priv->doc);
priv->doc = CAINTEOIR_DOCUMENT(g_object_ref(doc));
GtkTextBuffer *buffer = cainteoir_document_create_buffer(doc);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(priv->text_view), buffer);
}
/**
*在点击菜单新建项后，初始化界面
*/
void init_new_content_views(void) {
gtk_entry_set_text(GTK_ENTRY(contentTitleEntry),"");
gtk_text_buffer_set_text(textBuffer,"",0);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(contentContentTextView),textBuffer);
gtk_widget_show(contentTitleEntry);
gtk_widget_show(contentContentTextView);
gtk_widget_show(saveButton);
gtk_widget_hide(deleteButton);
gtk_widget_hide(modifyButton);
}
void hview_event_print(HviewWidgetsT *w, const gchar *string)
{
GtkTextBuffer *buf;
GtkTextIter iter;
buf = GTK_TEXT_BUFFER(gtk_text_view_get_buffer
(GTK_TEXT_VIEW(w->event_view)));
gtk_text_buffer_get_end_iter(buf, &iter);
gtk_text_buffer_insert(buf, &iter, string, -1);
gtk_text_buffer_insert(buf, &iter, "\n", -1);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(w->event_view), buf);
}
void
tasks_item_selected (GtkTreeSelection *selection, gpointer data) {
GtkTreeIter iter;
GtkTreeModel *model;
gchar *text;
GtkTextIter titer;
GtkTextBuffer *text_buffer;
GtkTextChildAnchor *anchor;
GtkWidget *hseparator;
guint32 start_date_julian;
gchar tmpbuf[BUFFER_SIZE];
GUI *appGUI = (GUI *)data;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gui_clear_text_buffer (text_buffer, &titer);
if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), TRUE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), TRUE);
gtk_tree_model_get (model, &iter, COLUMN_DESCRIPTION, &text,
COLUMN_START_DATE_JULIAN, &start_date_julian, -1);
sprintf(tmpbuf, "\n%s: %s\n", _("Started"), julian_to_str(start_date_julian, DATE_FULL));
if (text != NULL) {
gtk_text_buffer_insert_with_tags_by_name (text_buffer, &titer, text, -1,
"info_font", NULL);
gtk_text_buffer_insert(text_buffer, &titer, "\n", -1);
}
if (start_date_julian) {
gtk_text_buffer_insert(text_buffer, &titer, "\n", -1);
anchor = gtk_text_buffer_create_child_anchor (text_buffer, &titer);
gtk_text_buffer_insert_with_tags_by_name (text_buffer, &titer, tmpbuf, -1,
"italic", NULL);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), text_buffer);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_widget_set_size_request (hseparator, 240, -1);
gtk_text_view_add_child_at_anchor (GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), hseparator, anchor);
}
g_free(text);
} else {
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
}
}
void g_clicked(GtkWidget *widget, gpointer data) {
int fd;
char buf[100];
fd = open("add_app.txt",O_CREAT|O_RDWR,S_IRWXU);
perror("Status:");
read(fd,buf,20);
gtk_text_view_set_buffer(textview,(GtkTextBuffer*)buf);
g_print("clicked: %s\n",buf);
}
void ButtonClick(GtkButton *sender, gpointer user_data)
{
cout << gtk_button_get_label(sender) << endl;
if(gtk_button_get_label(sender) != "NONE"){
DestinationIP = gtk_button_get_label(sender);
gtk_text_view_set_buffer(ChatText, Buffer[IPtoBuffer[gtk_button_get_label(sender)]]);
gtk_editable_set_editable( (GtkEditable*) InputBar, true);
}
return;
}
void
jam_view_set_doc(JamView *view, JamDoc *doc) {
view->doc = doc;
undomgr_detach(view->undomgr, view->entry);
if (view->account != jam_doc_get_account(doc))
jam_view_account_changed(view);
g_signal_connect_swapped(G_OBJECT(doc), "notify::account",
G_CALLBACK(jam_view_account_changed), view);
g_signal_connect_swapped(G_OBJECT(doc), "update_doc",
G_CALLBACK(jam_view_store_doc), view);
g_signal_connect_swapped(G_OBJECT(doc), "entry_changed",
G_CALLBACK(jam_view_load_doc), view);
jam_view_load_conf(view);
jam_view_load_doc(view);
/* XXX: gtkspell gets confused if you detach its document,
* so we detach the spell checker completely, then reattach
* it at the end. */
#ifdef HAVE_GTKSPELL
if (conf.options.usespellcheck && view->entry) {
GtkSpell *spell;
spell = gtkspell_get_from_text_view(GTK_TEXT_VIEW(view->entry));
if (spell)
gtkspell_detach(spell);
}
#endif /* HAVE_GTKSPELL */
gtk_text_view_set_buffer(GTK_TEXT_VIEW(view->entry),
jam_doc_get_text_buffer(doc));
#ifdef HAVE_GTKSPELL
if (conf.options.usespellcheck) {
GError *err = NULL;
if (gtkspell_new_attach(GTK_TEXT_VIEW(view->entry),
conf.spell_language, &err) == NULL) {
GtkWindow *toplevel;
toplevel = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(view)));
jam_warning(toplevel,
_("GtkSpell error: %s"), err->message);
g_error_free(err);
}
}
#endif /* HAVE_GTKSPELL */
undomgr_attach(view->undomgr, view->entry);
}
static GtkWidget *
test_chase (void)
{
GtkWidget *win;
GtkWidget *overlay;
GtkWidget *sw;
GtkWidget *text;
GtkWidget *child;
GtkTextBuffer *buffer;
gchar *contents;
gsize len;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Chase");
overlay = gtk_overlay_new ();
gtk_widget_set_events (overlay, GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK);
gtk_container_add (GTK_CONTAINER (win), overlay);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (sw), 200);
gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 200);
gtk_container_add (GTK_CONTAINER (overlay), sw);
text = gtk_text_view_new ();
buffer = gtk_text_buffer_new (NULL);
if (!g_file_get_contents ("testoverlay.c", &contents, &len, NULL))
{
contents = g_strdup ("Text should go here...");
len = strlen (contents);
}
gtk_text_buffer_set_text (buffer, contents, len);
g_free (contents);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text), buffer);
gtk_widget_set_hexpand (text, TRUE);
gtk_widget_set_vexpand (text, TRUE);
gtk_container_add (GTK_CONTAINER (sw), text);
child = gtk_label_new ("Try to enter");
gtk_widget_set_halign (child, GTK_ALIGN_START);
gtk_widget_set_valign (child, GTK_ALIGN_END);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
g_object_set (child, "margin", 4, NULL);
g_signal_connect (overlay, "enter-notify-event",
G_CALLBACK (on_enter), child);
return win;
}
//Creates the main window
int main (int argc, char *argv[]) {
struct main_window mW;
mW.fio = malloc(sizeof(struct in_out));
gtk_init (&argc, &argv);
//Builds the interface elements
mW.builder = gtk_builder_new ();
gtk_builder_add_from_file (mW.builder, "form.glade", NULL);
mW.window = gtk_builder_get_object (mW.builder, "main_window");
g_signal_connect (mW.window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
mW.button_open = gtk_builder_get_object (mW.builder, "open_button");
g_signal_connect (mW.button_open, "activate", G_CALLBACK (openFileWindow),
&mW);
mW.textArea = gtk_builder_get_object (mW.builder, "textArea");
mW.text = gtk_text_buffer_new(NULL);
gtk_text_view_set_buffer((GtkTextView*) mW.textArea, mW.text);
setText(&mW, "Empty");
GdkPixbuf* logo_pixbuf = gdk_pixbuf_new_from_file("data/mediocr.png", NULL);
gdk_pixbuf_scale_simple(logo_pixbuf, 200, 200, GDK_INTERP_BILINEAR);
GtkImage* logo_image = (GtkImage*) gtk_builder_get_object (mW.builder, "logo_image");
GObject *process_button = gtk_builder_get_object (mW.builder, "logo_button");
g_signal_connect (process_button, "clicked", G_CALLBACK (process_file),
&mW);
gtk_image_set_from_pixbuf(logo_image, logo_pixbuf);
mW.imageArea = (GtkImage*)gtk_builder_get_object (mW.builder, "input");
//Connects the buttons to their respective functions
gtk_builder_connect_signals( mW.builder, NULL );
//Displays the main window
gtk_widget_show((GtkWidget*) mW.window);
g_signal_connect(G_OBJECT(mW.window), "configure-event",
G_CALLBACK(onResize), &mW);
gtk_main();
return 0;
}
static GtkWidget *
create_text (GtkTextBuffer **buffer,
gboolean is_source)
{
GtkWidget *scrolled_window;
GtkWidget *text_view;
PangoFontDescription *font_desc;
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
text_view = gtk_text_view_new ();
*buffer = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (text_view), *buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (text_view), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
if (is_source)
{
font_desc = pango_font_description_from_string ("monospace");
gtk_widget_modify_font (text_view, font_desc);
pango_font_description_free (font_desc);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view),
GTK_WRAP_NONE);
}
else
{
/* Make it a bit nicer for text. */
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (text_view),
GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines (GTK_TEXT_VIEW (text_view),
2);
gtk_text_view_set_pixels_below_lines (GTK_TEXT_VIEW (text_view),
2);
}
return scrolled_window;
}
void
on_ViewLog_clicked(GtkButton *button, gpointer user_data)
{
static GtkWidget *ViewLog = NULL;
GtkWidget *textview;
if (ViewLog)
gtk_window_present(GTK_WINDOW(ViewLog));
else {
ViewLog = create_ViewLog();
textview = lookup_widget(ViewLog, "ViewLogTextView");
gtk_text_view_set_buffer(GTK_TEXT_VIEW(textview), GTK_nhext_log);
gtk_window_set_default_size(GTK_WINDOW(ViewLog), 200, 300);
gtk_widget_show(ViewLog);
gtk_signal_connect(GTK_OBJECT(ViewLog), "destroy",
GTK_SIGNAL_FUNC(gtk_widget_destroyed), &ViewLog);
}
}
