static GObject*
gcr_certificate_details_widget_constructor (GType type, guint n_props, GObjectConstructParam *props)
{
GObject *obj = G_OBJECT_CLASS (gcr_certificate_details_widget_parent_class)->constructor (type, n_props, props);
GcrCertificateDetailsWidget *self = NULL;
GtkTextTagTable *tags;
GtkWidget *widget;
GtkWidget *scroll;
g_return_val_if_fail (obj, NULL);
self = GCR_CERTIFICATE_DETAILS_WIDGET (obj);
tags = create_tag_table (self);
self->pv->buffer = gtk_text_buffer_new (tags);
g_object_unref (tags);
widget = gtk_text_view_new_with_buffer (self->pv->buffer);
self->pv->view = GTK_TEXT_VIEW (widget);
gtk_text_view_set_editable (self->pv->view, FALSE);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scroll), widget);
gtk_container_add (GTK_CONTAINER (self), scroll);
gtk_widget_show_all (scroll);
return obj;
}
/*****************************************************************************
Initilialize a lua console.
*****************************************************************************/
static void luaconsole_dialog_create(struct luaconsole_data *pdialog)
{
GtkWidget *entry, *box, *vbox, *sw, *text, *notebook;
fc_assert_ret(NULL != pdialog);
if (gui_gtk2_message_chat_location == GUI_GTK_MSGCHAT_SPLIT) {
notebook = right_notebook;
} else {
notebook = bottom_notebook;
}
gui_dialog_new(&pdialog->shell, GTK_NOTEBOOK(notebook), pdialog, TRUE);
gui_dialog_set_title(pdialog->shell, _("Client Lua Console"));
box = GTK_WIDGET(pdialog->shell->vbox);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), vbox, TRUE, TRUE, 0);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
text = gtk_text_view_new_with_buffer(pdialog->message_buffer);
set_message_buffer_view_link_handlers(text);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
gtk_container_add(GTK_CONTAINER(sw), text);
g_signal_connect(text, "size-allocate",
G_CALLBACK(luaconsole_dialog_area_size_allocate), NULL);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD);
gtk_widget_realize(text);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5);
pdialog->message_area = GTK_TEXT_VIEW(text);
/* The lua console input line. */
entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, TRUE, 2);
g_signal_connect(entry, "activate", G_CALLBACK(luaconsole_input_return),
NULL);
g_signal_connect(entry, "key_press_event",
G_CALLBACK(luaconsole_input_handler), NULL);
pdialog->entry = entry;
/* Load lua script command button. */
gui_dialog_add_stockbutton(pdialog->shell, GTK_STOCK_OPEN,
_("Load Lua Script"), LUACONSOLE_RES_OPEN);
gui_dialog_add_button(pdialog->shell, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gui_dialog_response_set_callback(pdialog->shell,
luaconsole_response_callback);
luaconsole_dialog_refresh(pdialog);
gui_dialog_show_all(pdialog->shell);
}
//
// Constructor
//
CPreview::CPreview():m_Path(NULL), m_Data(NULL), m_FileType(TYPE_UNKNOWN),
m_MinX(0.0), m_MaxX(0.0), m_EpsX(0.0), m_MinY(0.0), m_MaxY(0.0), m_EpsY(0.0),
m_ReverseY(FALSE)
{
GtkWidget *vbox;
m_Buffer = gtk_text_buffer_new(NULL);
// Frame
m_Widget = gtk_frame_new(NULL);
vbox = gtk_vbox_new(FALSE, 4);
gtk_container_add(GTK_CONTAINER(m_Widget), vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
// Image area
m_Preview = cmpack_preview_new();
gtk_widget_set_size_request(m_Preview, 160, 160);
gtk_box_pack_start(GTK_BOX(vbox), m_Preview, FALSE, TRUE, 0);
gtk_widget_set_events(m_Preview, GDK_BUTTON_PRESS_MASK);
gtk_widget_set_tooltip_text(m_Preview, "Double click to enlarge the preview");
g_signal_connect(G_OBJECT(m_Preview), "button_press_event", G_CALLBACK(button_press_event), this);
// Text area
m_View = gtk_text_view_new_with_buffer(m_Buffer);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(m_View), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW(m_View), false);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(m_View), false);
gtk_text_view_set_justification(GTK_TEXT_VIEW(m_View), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(vbox), m_View, TRUE, TRUE, 0);
gtk_widget_show_all(m_Widget);
}
static void
recursive_attach_view (int depth,
GtkTextView *view,
GtkTextChildAnchor *anchor)
{
GtkWidget *child_view;
GtkWidget *event_box;
GdkColor color;
GtkWidget *align;
if (depth > 4)
return;
child_view = gtk_text_view_new_with_buffer (gtk_text_view_get_buffer (view));
/* Event box is to add a black border around each child view */
event_box = gtk_event_box_new ();
gdk_color_parse ("black", &color);
gtk_widget_modify_bg (event_box, GTK_STATE_NORMAL, &color);
align = gtk_alignment_new (0.5, 0.5, 1.0, 1.0);
gtk_container_set_border_width (GTK_CONTAINER (align), 1);
gtk_container_add (GTK_CONTAINER (event_box), align);
gtk_container_add (GTK_CONTAINER (align), child_view);
gtk_text_view_add_child_at_anchor (view, event_box, anchor);
recursive_attach_view (depth + 1, GTK_TEXT_VIEW (child_view), anchor);
}
static GtkWidget *
gimp_profile_view_new (GtkTextBuffer *buffer)
{
GtkWidget *frame;
GtkWidget *scrolled_window;
GtkWidget *text_view;
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
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_container_add (GTK_CONTAINER (frame), scrolled_window);
gtk_widget_show (scrolled_window);
text_view = gtk_text_view_new_with_buffer (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
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_left_margin (GTK_TEXT_VIEW (text_view), 2);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (text_view), 2);
gtk_container_add (GTK_CONTAINER (scrolled_window), text_view);
gtk_widget_show (text_view);
gtk_widget_set_size_request (scrolled_window, 200, -1);
return frame;
}
static void
recursive_attach_view (int depth,
GtkTextView *view,
GtkTextChildAnchor *anchor)
{
GtkWidget *child_view;
GtkWidget *event_box;
GdkRGBA color;
if (depth > 4)
return;
child_view = gtk_text_view_new_with_buffer (gtk_text_view_get_buffer (view));
/* Event box is to add a black border around each child view */
event_box = gtk_event_box_new ();
gdk_rgba_parse (&color, "black");
gtk_widget_override_background_color (event_box, 0, &color);
gtk_widget_set_halign (child_view, GTK_ALIGN_FILL);
gtk_widget_set_valign (child_view, GTK_ALIGN_FILL);
gtk_container_add (GTK_CONTAINER (event_box), child_view);
gtk_text_view_add_child_at_anchor (view, event_box, anchor);
recursive_attach_view (depth + 1, GTK_TEXT_VIEW (child_view), anchor);
}
static GtkWidget * create_credits_notebook (const char * const * credits,
const char * const * translators)
{
const char * titles[2] = {_("Credits"), _("Translators")};
const char * const * lists[2] = {credits, translators};
GtkWidget * notebook = gtk_notebook_new ();
for (int i = 0; i < 2; i ++)
{
GtkWidget * label = gtk_label_new (titles[i]);
GtkWidget * scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type ((GtkScrolledWindow *) scrolled,
GTK_SHADOW_IN);
gtk_widget_set_size_request (scrolled, -1, 200);
GtkWidget * text = gtk_text_view_new_with_buffer (create_text_buffer (lists[i]));
gtk_text_view_set_editable ((GtkTextView *) text, FALSE);
gtk_text_view_set_cursor_visible ((GtkTextView *) text, FALSE);
gtk_text_view_set_left_margin ((GtkTextView *) text, 6);
gtk_text_view_set_right_margin ((GtkTextView *) text, 6);
gtk_container_add ((GtkContainer *) scrolled, text);
gtk_notebook_append_page ((GtkNotebook *) notebook, scrolled, label);
}
return notebook;
}
void CGTKBase::CreateAbout()
{
const int windoww = 350, windowh = 350;
m_pAboutDialog = gtk_dialog_new_with_buttons(GetTranslation("About"), GTK_WINDOW(m_pMainWindow),
GtkDialogFlags(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
gtk_window_set_default_size(GTK_WINDOW(m_pAboutDialog), windoww, windowh);
GtkTextBuffer *buffer = gtk_text_buffer_new(NULL);
GtkTextIter iter;
std::string buf;
std::ifstream aboutfile(GetAboutFName());
char c;
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
while (aboutfile.get(c))
buf += c;
gtk_text_buffer_insert(buffer, &iter, buf.c_str(), -1);
GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkWidget *textview = gtk_text_view_new_with_buffer(GTK_TEXT_BUFFER(buffer));
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), FALSE);
gtk_container_add(GTK_CONTAINER(scrolled), textview);
gtk_widget_show(textview);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(m_pAboutDialog)->vbox), scrolled);
gtk_widget_show(scrolled);
}
bg_gtk_textview_t * bg_gtk_textview_create()
{
bg_gtk_textview_t * t;
t = calloc(1, sizeof(*t));
if(!tag_table)
{
tag_table = gtk_text_tag_table_new();
text_tag = gtk_text_tag_new("Font");
g_object_set(text_tag, "editable", 0, NULL);
gtk_text_tag_table_add(tag_table,
text_tag);
}
t->buffer = gtk_text_buffer_new(tag_table);
t->textview = gtk_text_view_new_with_buffer(t->buffer);
g_signal_connect(G_OBJECT(t->textview), "realize",
G_CALLBACK(set_bg), NULL);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(t->textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(t->textview), GTK_WRAP_NONE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(t->textview), 0);
gtk_widget_show(t->textview);
return t;
}
/**
* 创建好友信息区域.
* @return 主窗体
*/
GtkWidget *DialogPeer::CreateInfoArea()
{
GtkWidget *frame, *sw;
GtkWidget *widget;
GtkTextBuffer *buffer;
frame = gtk_frame_new(_("Info."));
g_datalist_set_data(&widset, "info-frame", frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(frame), sw);
buffer = gtk_text_buffer_new(progdt.table);
if (grpinf->member)
FillPalInfoToBuffer(buffer, (PalInfo *)grpinf->member->data);
widget = gtk_text_view_new_with_buffer(buffer);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(widget), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(widget), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(widget), GTK_WRAP_NONE);
gtk_container_add(GTK_CONTAINER(sw), widget);
g_datalist_set_data(&widset, "info-textview-widget", widget);
return frame;
}
void entries_vis_init (void){
/*GtkTreeViewColumn *c1, *c2, *c3;
GtkCellRenderer *cr1, *cr2, *cr3;
*/
clip = gtk_clipboard_get (GDK_NONE);
if (clip) //why shouldn't it?
isThereAClip = TRUE;
entryBuf = gtk_text_buffer_new (NULL);
simpleSheet = gtk_text_view_new_with_buffer (entryBuf);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (simpleSheet), GTK_WRAP_WORD);
simpleSigID = g_signal_connect (G_OBJECT (entryBuf), "changed",
G_CALLBACK (meta_saveable), GINT_TO_POINTER (GRG_SAVE_ACTIVE));
/*
mdl = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
structSheet = gtk_tree_view_new_with_model (GTK_TREE_MODEL (mdl));
g_object_unref (G_OBJECT (mdl));
cr1=gtk_cell_renderer_text_new ();
cr2=gtk_cell_renderer_text_new ();
cr3=gtk_cell_renderer_text_new ();
c1=gtk_tree_view_column_new_with_attributes ("URL", cr1, "text", 0, NULL);
c2=gtk_tree_view_column_new_with_attributes ("UserID", cr2, "text", 1, NULL);
c3=gtk_tree_view_column_new_with_attributes ("Password", cr3, "text", 2, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c1);
gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c2);
gtk_tree_view_append_column (GTK_TREE_VIEW (structSheet), c3);*/
}
void MultilineOptionView::_createItem() {
myTextBuffer = GTK_TEXT_BUFFER(gtk_text_buffer_new(0));
g_signal_connect(myTextBuffer, "changed", G_CALLBACK(_onValueChanged), this);
myTextView = GTK_TEXT_VIEW(gtk_text_view_new_with_buffer(myTextBuffer));
gtk_text_view_set_wrap_mode(myTextView, GTK_WRAP_WORD);
myHolder.attachWidget(*this, GTK_WIDGET(myTextView));
reset();
}
void EditorActionCreateNoteParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// Horizontal box to store the note.
hbox = gtk_hbox_new (false, 0);
gtk_widget_show (hbox);
gtk_box_pack_start(GTK_BOX(parent_vbox), hbox, false, false, 0);
// Eventbox to catch a few events on the caller of the note.
eventbox = gtk_event_box_new ();
gtk_widget_show (eventbox);
gtk_box_pack_start(GTK_BOX(hbox), eventbox, false, false, 0);
g_signal_connect ((gpointer) eventbox, "enter_notify_event", G_CALLBACK (on_caller_enter_notify_event), gpointer (this));
g_signal_connect ((gpointer) eventbox, "leave_notify_event", G_CALLBACK (on_caller_leave_notify_event), gpointer (this));
// The background of the caller is going to be grey.
// Courier font is chosen to make the spacing of the callers equal so they line up nicely.
label = gtk_label_new ("");
gtk_widget_show (label);
char *markup = g_markup_printf_escaped("<span background=\"grey\" size=\"x-small\"> </span><span background=\"grey\" face=\"Courier\">%s</span><span background=\"grey\" size=\"x-small\"> </span>", caller_text.c_str());
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
gtk_container_add (GTK_CONTAINER (eventbox), label);
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// Text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
gtk_box_pack_start(GTK_BOX(hbox), textview, true, true, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position. To be calculated.
/*
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
*/
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
GtkWidget *
do_css_basics (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "CSS Basics");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_basics/css_basics.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
gint
main (gint argc,
gchar *argv[])
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *view;
GtkTextBuffer *buffer;
GdkAtom atom;
guint i, broken = 0;
gtk_init (&argc, &argv);
/* initialize random numbers, disable this for deterministic testing */
if (1)
quick_rand32_accu = g_random_int();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window, 400, 300);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (window), sw);
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event),
NULL);
buffer = gtk_text_buffer_new (NULL);
view = gtk_text_view_new_with_buffer (buffer);
g_object_unref (buffer);
gtk_container_add (GTK_CONTAINER (sw), view);
gtk_widget_show_all (window);
if (0)
gtk_main ();
for (i = 0; i < 250; i++)
{
GError *error = NULL;
g_printerr ("creating randomly tagged text buffer with accu=0x%x...\n", quick_rand32_accu);
atom = setup_buffer (buffer);
if (test_serialize_deserialize (buffer, atom, &error))
g_printerr ("ok.\n");
else
{
g_printerr ("FAIL: serialization/deserialization failed:\n %s\n", error->message);
broken += 1;
}
g_clear_error (&error);
}
return broken > 0;
}
void read_old_notes()
{
Note *note;
GtkTextBuffer *text_buffer;
GtkTextIter iter;
DIR *dir = opendir(".");
FILE *file;
struct dirent *entry;
int reserved1;
int reserved2;
int i;
char buffer[256];
rewinddir(dir);
while((entry = readdir(dir)) != NULL) {
/* Check if it is a valid note name */
for(i=0; entry->d_name[i]; i++) {
if(entry->d_name[i] < '0' || entry->d_name[i] > '9') break;
}
if(i < strlen(entry->d_name)) continue;
file = fopen(entry->d_name, "r");
note = malloc(sizeof(Note));
note->id = atoi(entry->d_name);
if(note->id > highest_note_id) highest_note_id = note->id;
fscanf(file, "%d,%d,%d,%d,%d,%d,",
&(note->x), &(note->y), &(note->width), &(note->height),
&reserved1, &reserved2);
/* Get color name */
fgets(buffer, 256, file);
/* Replace the newline with a null char */
buffer[strlen(buffer) - 1] = '\0';
for(i=num_color_schemes; i > 0; i--) {
if(!strcmp(color_schemes[i].name, buffer)) break;
}
note->scheme = &color_schemes[i];
text_buffer = gtk_text_buffer_new(NULL);
while(fgets(buffer, 256, file)) {
gtk_text_buffer_get_end_iter(text_buffer, &iter);
gtk_text_buffer_insert(text_buffer, &iter, buffer, -1);
}
note->text_widget = gtk_text_view_new_with_buffer(text_buffer);
create_note(note, note->scheme);
fclose(file);
}
closedir(dir);
}
GtkWidget * sqchat_buffer_view_new(GtkTextBuffer * text_buffer) {
GtkWidget * buffer_view;
buffer_view = gtk_text_view_new_with_buffer(text_buffer);
gtk_text_view_set_editable(GTK_TEXT_VIEW(buffer_view), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(buffer_view), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(buffer_view),
GTK_WRAP_WORD_CHAR);
return buffer_view;
}
static GtkWidget *
create_window (GtkTextBuffer *buffer)
{
GtkWidget *window;
GtkWidget *scrolledwin;
GtkWidget *box;
GtkWidget *terminal;
GtkWidget *bbox;
GtkWidget *close_button;
PangoTabArray *tabs;
int width, height;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (window), _("Boot messages"));
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
width = MIN (800, 0.75 * gdk_screen_get_width (gdk_screen_get_default ()));
height = MIN (600, 0.75 * gdk_screen_get_height (gdk_screen_get_default ()));
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
box = gtk_vbox_new (FALSE, 0);
scrolledwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwin),
GTK_SHADOW_IN);
terminal = gtk_text_view_new_with_buffer (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (terminal), FALSE);
tabs = pango_tab_array_new_with_positions (1, TRUE, PANGO_TAB_LEFT, width - 130);
gtk_text_view_set_tabs (GTK_TEXT_VIEW (terminal), tabs);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (terminal), 12);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (terminal), 12);
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
close_button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_box_pack_start (GTK_BOX (box), scrolledwin, TRUE, TRUE, 6);
gtk_container_add (GTK_CONTAINER (scrolledwin), terminal);
gtk_box_pack_start (GTK_BOX (box), bbox, FALSE, TRUE, 6);
gtk_box_pack_start (GTK_BOX (bbox), close_button, FALSE, TRUE, 6);
g_signal_connect (window, "delete-event",
G_CALLBACK (close_window), NULL);
g_signal_connect_swapped (close_button, "clicked",
G_CALLBACK (close_window), window);
gtk_widget_show_all (box);
return window;
}
static void
easter_egg_callback (GtkWidget *button,
gpointer data)
{
static GtkWidget *window = NULL;
gpointer window_ptr;
GtkTextBuffer *buffer;
GtkWidget *view;
GtkTextIter iter;
GtkTextChildAnchor *anchor;
GtkWidget *sw;
if (window)
{
gtk_window_present (GTK_WINDOW (window));
return;
}
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_start_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter,
"This buffer is shared by a set of nested text views.\n Nested view:\n", -1);
anchor = gtk_text_buffer_create_child_anchor (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter,
"\nDon't do this in real applications, please.\n", -1);
view = gtk_text_view_new_with_buffer (buffer);
recursive_attach_view (0, GTK_TEXT_VIEW (view), anchor);
g_object_unref (buffer);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), sw);
gtk_container_add (GTK_CONTAINER (sw), view);
window_ptr = &window;
g_object_add_weak_pointer (G_OBJECT (window), window_ptr);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 400);
gtk_widget_show_all (window);
}
static void
gdaui_cloud_init (GdauiCloud *cloud)
{
cloud->priv = g_new0 (GdauiCloudPriv, 1);
cloud->priv->min_scale = .8;
cloud->priv->max_scale = 2.;
cloud->priv->selected_tags = NULL;
cloud->priv->selection_mode = GTK_SELECTION_SINGLE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (cloud), GTK_ORIENTATION_VERTICAL);
/* text buffer */
cloud->priv->tbuffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (cloud->priv->tbuffer, "section",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "blue", NULL);
/* text view */
GtkWidget *sw, *vbox, *vp;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (cloud), sw, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vp = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (vp), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (sw), vp);
gtk_container_add (GTK_CONTAINER (vp), vbox);
cloud->priv->tview = gtk_text_view_new_with_buffer (cloud->priv->tbuffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (cloud->priv->tview), GTK_WRAP_WORD);
gtk_text_view_set_editable (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), cloud->priv->tview, TRUE, TRUE, 0);
gtk_widget_show_all (sw);
g_signal_connect (cloud->priv->tview, "key-press-event",
G_CALLBACK (key_press_event), cloud);
g_signal_connect (cloud->priv->tview, "event-after",
G_CALLBACK (event_after), cloud);
g_signal_connect (cloud->priv->tview, "motion-notify-event",
G_CALLBACK (motion_notify_event), cloud);
g_signal_connect (cloud->priv->tview, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), cloud);
}
static VALUE
textview_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE buffer;
GtkWidget* widget;
rb_scan_args(argc, argv, "01", &buffer);
if (NIL_P(buffer))
widget = gtk_text_view_new();
else {
G_CHILD_SET(self, id_buffer, buffer);
widget = gtk_text_view_new_with_buffer(RVAL2BUFFER(buffer));
}
RBGTK_INITIALIZE(self, widget);
return self;
}
static void
caja_notes_viewer_init (CajaNotesViewer *sidebar)
{
CajaNotesViewerDetails *details;
CajaIconInfo *info;
gint scale;
details = g_new0 (CajaNotesViewerDetails, 1);
sidebar->details = details;
details->uri = g_strdup ("");
scale = gdk_window_get_scale_factor (gdk_get_default_root_window ());
info = caja_icon_info_lookup_from_name ("emblem-note", 16, scale);
details->icon = caja_icon_info_get_pixbuf (info);
/* create the text container */
details->text_buffer = gtk_text_buffer_new (NULL);
details->note_text_field = gtk_text_view_new_with_buffer (details->text_buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (details->note_text_field), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (details->note_text_field),
GTK_WRAP_WORD);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sidebar),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sidebar),
GTK_SHADOW_IN);
gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (sidebar), NULL);
gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (sidebar), NULL);
gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (sidebar), FALSE);
gtk_container_add (GTK_CONTAINER (sidebar), details->note_text_field);
g_signal_connect (details->note_text_field, "focus_out_event",
G_CALLBACK (on_text_field_focus_out_event), sidebar);
g_signal_connect (details->text_buffer, "changed",
G_CALLBACK (on_changed), sidebar);
gtk_widget_show_all (GTK_WIDGET (sidebar));
}
static void
freetuxtv_player_error_dialog_init (FreetuxTVPlayerErrorDialog *object)
{
FreetuxTVPlayerErrorDialogPrivate *priv;
priv = FREETUXTV_PLAYER_ERROR_PRIVATE (object);
priv->app = NULL;
priv->pTextBuffer = gtk_text_buffer_new (NULL);
GtkWidget* pTextView;
pTextView = gtk_text_view_new_with_buffer (priv->pTextBuffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(pTextView), GTK_WRAP_WORD);
GtkWidget* pScroll;
pScroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScroll), pTextView);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(pScroll), GTK_SHADOW_IN);
//gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(pScroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkWidget* vbox;
#if GTK_API_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
#else
vbox = gtk_vbox_new(FALSE, 5);
#endif
gtk_box_pack_start (GTK_BOX (vbox),
GTK_WIDGET(pScroll), TRUE, TRUE, 5);
GtkWidget* area;
area = gtk_dialog_get_content_area (GTK_DIALOG(object));
gtk_box_pack_start (GTK_BOX (area),
GTK_WIDGET(vbox), TRUE, TRUE, 5);
gtk_widget_show_all(vbox);
gtk_dialog_add_button (GTK_DIALOG(object), "gtk-close", GTK_RESPONSE_CLOSE);
gtk_window_set_default_size (GTK_WINDOW(object), 400, 200);
g_signal_connect(G_OBJECT(object), "response",
G_CALLBACK(on_response), NULL);
}
static void
recursive_attach_view (int depth,
GtkTextView *view,
GtkTextChildAnchor *anchor)
{
GtkWidget *child_view, *frame;
if (depth > 4)
return;
child_view = gtk_text_view_new_with_buffer (gtk_text_view_get_buffer (view));
/* Frame is to add a black border around each child view */
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (frame), child_view);
gtk_text_view_add_child_at_anchor (view, frame, anchor);
recursive_attach_view (depth + 1, GTK_TEXT_VIEW (child_view), anchor);
}
static GtkWidget *dlg_text_edit_new (int *hsize, gboolean s)
{
GtkTextBuffer *tbuf;
GtkWidget *tview;
tbuf = gtk_text_buffer_new(NULL);
tview = gtk_text_view_new_with_buffer(tbuf);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(tview), GTK_WRAP_WORD);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(tview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(tview), 4);
gtk_widget_modify_font(GTK_WIDGET(tview), fixed_font);
*hsize *= get_char_width(tview);
*hsize += 48;
gtk_text_view_set_editable(GTK_TEXT_VIEW(tview), s);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(tview), s);
return tview;
}
CMessagesDlg::CMessagesDlg(GtkWindow *pParent)
{
GtkWidget *text_view, *scrolled_window;
GdkRectangle rc;
// Dialog with buttons
m_pDlg = gtk_dialog_new_with_buttons("Message log", pParent,
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
// Dialog size
GdkScreen *scr = gtk_window_get_screen(pParent);
int mon = gdk_screen_get_monitor_at_window(scr, GTK_WIDGET(pParent)->window);
gdk_screen_get_monitor_geometry(scr, mon, &rc);
if (rc.width>0 && rc.height>0)
gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.7*rc.width), RoundToInt(0.7*rc.height));
// Dialog icon
gchar *icon = get_icon_file("messagelog");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// List box
text_view = gtk_text_view_new_with_buffer(ms_Buffer);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text_view), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW(text_view), false);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(text_view), false);
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_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scrolled_window), text_view);
gtk_widget_set_size_request(scrolled_window, 640, 480);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
void ug_banner_init (struct UgBanner* banner)
{
GtkStyleContext* style_context;
GdkRGBA rgba;
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
banner->self = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
banner->buffer = gtk_text_buffer_new (NULL);
banner->tag_link = gtk_text_buffer_create_tag (banner->buffer, NULL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
banner->text_view = (GtkTextView*) gtk_text_view_new_with_buffer (banner->buffer);
gtk_text_view_set_cursor_visible (banner->text_view, FALSE);
gtk_text_view_set_editable (banner->text_view, FALSE);
gtk_box_pack_start (GTK_BOX (banner->self),
GTK_WIDGET (banner->text_view), TRUE, TRUE, 0);
g_signal_connect (banner->text_view, "event-after",
G_CALLBACK (event_after), banner);
g_signal_connect (banner->text_view, "motion-notify-event",
G_CALLBACK (motion_notify_event), banner);
// style: color
style_context = gtk_widget_get_style_context (GTK_WIDGET (banner->text_view));
gtk_style_context_get_background_color (style_context,
GTK_STATE_FLAG_SELECTED, &rgba);
gtk_widget_override_background_color (
GTK_WIDGET (banner->text_view), GTK_STATE_FLAG_NORMAL, &rgba);
gtk_style_context_get_color (style_context,
GTK_STATE_FLAG_SELECTED, &rgba);
gtk_widget_override_color (
GTK_WIDGET (banner->text_view), GTK_STATE_FLAG_NORMAL, &rgba);
// close button
gtk_box_pack_end (GTK_BOX (banner->self),
create_x_button (banner), FALSE, FALSE, 0);
ug_banner_show_donation (banner);
}
void EditorActionCreateParagraph::apply (GtkTextTagTable * texttagtable, bool editable, EditorActionCreateParagraph * focused_paragraph, GtkWidget *& to_focus)
{
// The textbuffer uses the text tag table.
textbuffer = gtk_text_buffer_new(texttagtable);
// New text view to view the text buffer.
textview = gtk_text_view_new_with_buffer(textbuffer);
gtk_widget_show(textview);
// Add text view to the GUI.
gtk_box_pack_start(GTK_BOX(parent_vbox), textview, false, false, 0);
// Set some parameters of the view.
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(textview), editable);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(textview), 5);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(textview), 5);
// Move the widget to the right position,
// which is next to the currently focused paragraph.
// This move is important since a new paragraph can be created anywhere among the current ones.
vector <GtkWidget *> widgets = editor_get_widgets (parent_vbox);
gint new_paragraph_offset = 0;
if (focused_paragraph) {
for (unsigned int i = 0; i < widgets.size(); i++) {
if (focused_paragraph->textview == widgets[i]) {
new_paragraph_offset = i + 1;
break;
}
}
}
gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, new_paragraph_offset);
// Let the newly created textview be earmarked to grab focus
// so that the user can type in it,
// and the internal Editor logic knows about it.
to_focus = textview;
}
static void add_page (GtkNotebook * notebook, const gchar * name, const gchar * buf,gboolean hscrolling)
{
GtkTextBuffer *textbuffer;
GtkWidget *textview;
GtkWidget *label;
GtkWidget *view;
GtkWidget *sw;
label = gtk_label_new (name);
gtk_widget_show (label);
view = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (view), BORDER);
gtk_frame_set_shadow_type (GTK_FRAME (view), GTK_SHADOW_IN);
gtk_widget_show (view);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
hscrolling ? GTK_POLICY_AUTOMATIC :
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (sw);
gtk_container_add (GTK_CONTAINER (view), sw);
textbuffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_set_text (textbuffer, buf, strlen(buf));
textview = gtk_text_view_new_with_buffer (textbuffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE);
gtk_text_view_set_left_margin (GTK_TEXT_VIEW (textview), BORDER);
gtk_text_view_set_right_margin (GTK_TEXT_VIEW (textview), BORDER);
gtk_widget_show (textview);
gtk_container_add (GTK_CONTAINER (sw), textview);
gtk_notebook_append_page (notebook, view, label);
}
static void
gimp_error_console_init (GimpErrorConsole *console)
{
GtkWidget *scrolled_window;
console->text_buffer = GTK_TEXT_BUFFER (gimp_text_buffer_new ());
gtk_text_buffer_create_tag (console->text_buffer, "title",
"scale", PANGO_SCALE_LARGE,
"weight", PANGO_WEIGHT_BOLD,
NULL);
gtk_text_buffer_create_tag (console->text_buffer, "message",
NULL);
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_box_pack_start (GTK_BOX (console), scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
console->text_view = gtk_text_view_new_with_buffer (console->text_buffer);
g_object_unref (console->text_buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (console->text_view), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (console->text_view),
GTK_WRAP_WORD);
gtk_container_add (GTK_CONTAINER (scrolled_window), console->text_view);
gtk_widget_show (console->text_view);
g_signal_connect (console->text_view, "button-press-event",
G_CALLBACK (gimp_error_console_button_press),
console);
console->file_dialog = NULL;
}
