NetlistEditor *
netlist_editor_new_from_file (gchar * filename)
{
GtkSourceBuffer *buffer;
gchar *content;
gsize length;
GError *error = NULL;
NetlistEditor *editor;
if (!filename)
return NULL;
if (!(g_file_test (filename, G_FILE_TEST_EXISTS))) {
gchar *msg;
// gettext support
msg = g_strdup_printf (_("The file %s could not be found."), filename);
oregano_error_with_title (_("Could not find the required file"), msg);
g_free (msg);
return NULL;
}
buffer = gtk_source_buffer_new (NULL);
g_file_get_contents (filename, &content, &length, &error);
gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), content, -1);
editor = netlist_editor_new (buffer);
return editor;
}
src_view___::src_view___(GtkWidget* scrolled2, void* window):view___(scrolled2, window) {
buf_ = GTK_SOURCE_BUFFER (gtk_source_buffer_new (NULL));
widget_ = gtk_source_view_new_with_buffer(buf_);
gtk_container_add (GTK_CONTAINER (scrolled2), widget_);
GtkSourceView* sv = handle__();
gtk_source_view_set_show_line_numbers(sv, true);
gtk_source_view_set_tab_width(sv, 4);
gtk_source_view_set_auto_indent (sv, true);
gtk_source_view_set_smart_home_end(sv, GTK_SOURCE_SMART_HOME_END_ALWAYS);
gtk_source_view_set_draw_spaces (sv, GTK_SOURCE_DRAW_SPACES_ALL);
gtk_widget_set_can_focus(widget_, true);
}
gint
main (gint argc,
gchar **argv)
{
GtkSourceBuffer *source_buffer;
GtkTextBuffer *text_buffer;
GtkTextIter iter;
GTimer *timer;
gint nb_actions;
gint i;
gtk_init (&argc, &argv);
source_buffer = gtk_source_buffer_new (NULL);
text_buffer = GTK_TEXT_BUFFER (source_buffer);
gtk_text_buffer_get_start_iter (text_buffer, &iter);
for (i = 0; i < NB_LINES; i++)
{
gtk_text_buffer_begin_user_action (text_buffer);
gtk_text_buffer_insert (text_buffer,
&iter,
"A line of text to fill the text buffer. Is it long enough?\n",
-1);
gtk_text_buffer_end_user_action (text_buffer);
}
timer = g_timer_new ();
nb_actions = test_undo_redo (source_buffer, NB_LINES / 10);
g_timer_stop (timer);
g_print ("Undo/Redo %d actions: %lf seconds.\n",
nb_actions,
g_timer_elapsed (timer, NULL));
g_timer_start (timer);
nb_actions = test_undo_redo (source_buffer, NB_LINES);
g_timer_stop (timer);
g_print ("Undo/Redo %d actions: %lf seconds.\n",
nb_actions,
g_timer_elapsed (timer, NULL));
g_object_unref (source_buffer);
g_timer_destroy (timer);
return 0;
}
static void
wikipad_document_init (WikipadDocument *document)
{
GtkTargetList *target_list;
/* private structure */
document->priv = WIKIPAD_DOCUMENT_GET_PRIVATE (document);
/* initialize the variables */
document->priv->utf8_filename = NULL;
document->priv->utf8_basename = NULL;
document->priv->label = NULL;
/* setup the scolled window */
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (document), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (document), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_hadjustment (GTK_SCROLLED_WINDOW (document), NULL);
gtk_scrolled_window_set_vadjustment (GTK_SCROLLED_WINDOW (document), NULL);
/* create a textbuffer */
document->buffer = GTK_TEXT_BUFFER (gtk_source_buffer_new (NULL));
/* initialize the file */
document->file = wikipad_file_new (document->buffer);
/* connect signals to the file */
g_signal_connect_swapped (G_OBJECT (document->file), "filename-changed", G_CALLBACK (wikipad_document_filename_changed), document);
/* create the highlight tag */
document->tag = gtk_text_buffer_create_tag (document->buffer, NULL, "background", "#ffff78", NULL);
/* setup the textview */
document->textview = g_object_new (WIKIPAD_TYPE_VIEW, "buffer", document->buffer, NULL);
gtk_container_add (GTK_CONTAINER (document), GTK_WIDGET (document->textview));
gtk_widget_show (GTK_WIDGET (document->textview));
/* also allow dropping of uris and tabs in the textview */
target_list = gtk_drag_dest_get_target_list (GTK_WIDGET (document->textview));
gtk_target_list_add_table (target_list, drop_targets, G_N_ELEMENTS (drop_targets));
/* attach signals to the text view and buffer */
g_signal_connect (G_OBJECT (document->buffer), "notify::cursor-position", G_CALLBACK (wikipad_document_notify_cursor_position), document);
g_signal_connect (G_OBJECT (document->buffer), "notify::has-selection", G_CALLBACK (wikipad_document_notify_has_selection), document);
g_signal_connect_swapped (G_OBJECT (document->buffer), "modified-changed", G_CALLBACK (wikipad_document_label_color), document);
g_signal_connect_swapped (G_OBJECT (document->file), "readonly-changed", G_CALLBACK (wikipad_document_label_color), document);
g_signal_connect (G_OBJECT (document->textview), "notify::overwrite", G_CALLBACK (wikipad_document_notify_overwrite), document);
g_signal_connect (G_OBJECT (document->textview), "drag-data-received", G_CALLBACK (wikipad_document_drag_data_received), document);
g_signal_connect (G_OBJECT (document->buffer), "notify::language", G_CALLBACK (wikipad_document_notify_language), document);
}
static void
test_buffer_ref (void)
{
GtkSourcePrintCompositor *compositor;
GtkSourceBuffer *buffer = NULL;
GtkSourceBuffer *buffer_original = NULL;
buffer_original = gtk_source_buffer_new (NULL);
compositor = gtk_source_print_compositor_new (buffer_original);
buffer = gtk_source_print_compositor_get_buffer (compositor);
g_assert (GTK_SOURCE_IS_BUFFER (buffer));
g_object_unref (G_OBJECT (buffer_original));
buffer = gtk_source_print_compositor_get_buffer (compositor);
g_assert (GTK_SOURCE_IS_BUFFER (buffer));
}
GtkSourceBuffer *
init_buffer(FileContainer *file_container) {
GtkSourceBuffer *source_buffer = gtk_source_buffer_new(NULL);
gtk_source_buffer_set_highlight_matching_brackets(source_buffer, FALSE);
GtkTextBuffer *text_buffer = GTK_TEXT_BUFFER(source_buffer);
gtk_text_buffer_set_text(
text_buffer,
file_container->data,
file_container->size
);
GtkTextIter start_of_buffer;
gtk_text_buffer_get_start_iter(text_buffer, &start_of_buffer);
gtk_text_buffer_place_cursor(text_buffer, &start_of_buffer);
gtk_text_buffer_set_modified(text_buffer, FALSE);
return source_buffer;
}
void init_editor(GtkWidget *box)
{
//エディタ部分の外観の設定
GtkWidget *notebook = gtk_notebook_new();
scroll_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
buffer = gtk_source_buffer_new(NULL);
view = gtk_source_view_new_with_buffer(buffer);
set_file_name("");
name_label = gtk_label_new("編集中のファイル");
gtk_container_add(GTK_CONTAINER(scroll_window), view);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scroll_window, name_label);
gtk_widget_set_has_tooltip(view, TRUE);
gtk_widget_grab_focus(view);
set_style();
gtk_box_pack_start(GTK_BOX(box), notebook, TRUE, TRUE, 0);
//エディタ部分の動作の初期設定
gtk_source_buffer_set_highlight_matching_brackets(buffer, FALSE);
gtk_widget_modify_font(view, pango_font_description_from_string(font_name));
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(view), state & width_mask);
if (state & wrap_mask) {
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_CHAR);
} else {
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_NONE);
}
if (state & line_mask) {
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), TRUE);
} else {
gtk_source_view_set_show_line_numbers(GTK_SOURCE_VIEW(view), FALSE);
}
if (state & highlight_mask) {
gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), TRUE);
} else {
gtk_source_view_set_highlight_current_line(GTK_SOURCE_VIEW(view), FALSE);
}
if (state & space_mask) {
gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), TRUE);
} else {
gtk_source_view_set_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW(view), FALSE);
}
}
/* Helper function: search one documentation page */
static void
search_documentation(DocText *doctext, I7SearchWindow *self)
{
I7_SEARCH_WINDOW_USE_PRIVATE(self, priv);
GtkTreeIter result;
GtkTextIter search_from, match_start, match_end;
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL));
gtk_text_buffer_set_text(buffer, doctext->body, -1);
gtk_text_buffer_get_start_iter(buffer, &search_from);
while(find_no_wrap(&search_from, priv->text, TRUE,
GTK_SOURCE_SEARCH_TEXT_ONLY | (priv->ignore_case? GTK_SOURCE_SEARCH_CASE_INSENSITIVE : 0),
priv->algorithm, &match_start, &match_end))
{
while(gtk_events_pending())
gtk_main_iteration();
search_from = match_end;
gchar *context = extract_context(buffer, &match_start, &match_end);
gchar *location = g_strconcat(doctext->section, ": ", doctext->title, NULL);
gtk_list_store_append(priv->results, &result);
gtk_list_store_set(priv->results, &result,
I7_RESULT_CONTEXT_COLUMN, context,
I7_RESULT_SORT_STRING_COLUMN, doctext->sort,
I7_RESULT_FILE_COLUMN, doctext->file,
I7_RESULT_ANCHOR_COLUMN, doctext->anchor,
I7_RESULT_RESULT_TYPE_COLUMN, doctext->is_recipebook?
I7_RESULT_TYPE_RECIPE_BOOK : I7_RESULT_TYPE_DOCUMENTATION,
I7_RESULT_LOCATION_COLUMN, location,
I7_RESULT_EXAMPLE_TITLE_COLUMN, doctext->example_title,
I7_RESULT_BACKGROUND_COLOR_COLUMN, doctext->is_recipebook?
"#ffffe0" : "#ffffff",
-1);
g_free(context);
g_free(location);
}
g_object_unref(buffer);
}
static module_t *add_module(const char *Name) {
// printf("Adding module: %s\n", Name);
gdk_threads_enter();
module_t *Module = new(module_t);
Module->Name = Name;
Module->Source = gtk_source_buffer_new(SourceTags);
gtk_source_buffer_set_language(Module->Source, SourceLanguage);
gtk_source_buffer_set_style_scheme(Module->Source, StyleScheme);
gtk_text_view_set_buffer(SourceView, Module->Source);
GtkTreeIter Iter;
gtk_list_store_append(Modules, &Iter);
gtk_list_store_set(Modules, &Iter, 0, Name, 1, Module, -1);
Module->ModulePath = gtk_tree_model_get_path(Modules, &Iter);
DisplayedModule = Module;
gtk_tree_store_append(Globals, &Iter, 0);
gtk_tree_store_set(Globals, &Iter, 0, Module->Name, 1, 0, 2, 0, 3, 0, 5, -1, -1);
Module->GlobalsPath = gtk_tree_model_get_path(Globals, &Iter);
//Module->Breakpoints = Riva$Memory$alloc_atomic(1);
//Module->Breakpoints[0] = BreakOnNewModule;
//Module->MaxBreakpoint = 1;
gdk_threads_leave();
return Module;
};
void Gobby::OperationOpen::start()
{
m_iconv.reset(new Glib::IConv("UTF-8", m_encoding));
try
{
m_file->read_async(sigc::mem_fun(
*this, &OperationOpen::on_file_read));
m_message_handle = get_status_bar().add_info_message(
Glib::ustring::compose(
_("Opening document \"%1\"..."), m_file->get_uri()));
m_parent.signal_node_removed().connect(
sigc::mem_fun(
*this, &OperationOpen::on_node_removed));
m_content = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL));
}
catch(const Gio::Error& err)
{
error(err.what());
}
}
void GUI::add_program_file(gchar * filepath){
if (this->is_empty_notebook){
this->is_empty_notebook = false;
gtk_notebook_remove_page(GTK_NOTEBOOK(this->programs_notebook), this->empty_notebook_index);
}
GuiNotebookItem notebook_item;
notebook_item.vmachine = NULL;
notebook_item.filepath = filepath;
// netobook label
notebook_item.notebook_label_text = this->extract_file_name(notebook_item.filepath);
notebook_item.notebook_label = gtk_label_new (notebook_item.notebook_label_text);
// create inner notebook vbox
notebook_item.notebook_vbox = gtk_vbox_new(FALSE, 0);
// create scrolled_window
notebook_item.notebook_scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (notebook_item.notebook_scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_vbox),
notebook_item.notebook_scrolled_window,
TRUE, // vbox gives widget all remaining space
TRUE, // widget expands to fill given space
0); // pixel of padding around the widget
// create notebook_source_view
notebook_item.source_buffer = gtk_source_buffer_new (NULL);
notebook_item.source_view = gtk_source_view_new_with_buffer(notebook_item.source_buffer);
gtk_container_add (GTK_CONTAINER (notebook_item.notebook_scrolled_window), notebook_item.source_view);
gtk_source_view_set_auto_indent ( GTK_SOURCE_VIEW (notebook_item.source_view),
TRUE);
// make a tab be two spaces
gtk_source_view_set_indent_width (GTK_SOURCE_VIEW (notebook_item.source_view),
2);
gtk_source_view_set_highlight_current_line (GTK_SOURCE_VIEW (notebook_item.source_view),
TRUE);
gtk_source_view_set_show_line_numbers ( GTK_SOURCE_VIEW (notebook_item.source_view),
TRUE);
gtk_source_view_set_right_margin_position ( GTK_SOURCE_VIEW (notebook_item.source_view),
80); // default is 70 chars
gtk_source_view_set_show_right_margin ( GTK_SOURCE_VIEW (notebook_item.source_view),
TRUE);
gtk_text_view_set_wrap_mode ( GTK_TEXT_VIEW (notebook_item.source_view),
GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable ( GTK_TEXT_VIEW (notebook_item.source_view),
FALSE);
gtk_text_view_set_cursor_visible ( GTK_TEXT_VIEW (notebook_item.source_view),
FALSE);
/* setup view */
PangoFontDescription * font_desc = NULL;
font_desc = pango_font_description_from_string ("monospace");
if (font_desc != NULL){
gtk_widget_modify_font (notebook_item.source_view, font_desc);
pango_font_description_free (font_desc);
}
// get file content
gchar * buffer;
GError * error_here = NULL;
if (g_file_get_contents (notebook_item.filepath, &buffer, NULL, &error_here)){
gtk_source_buffer_begin_not_undoable_action (notebook_item.source_buffer);
gtk_source_buffer_begin_not_undoable_action (notebook_item.source_buffer);
gtk_text_buffer_set_text (GTK_TEXT_BUFFER (notebook_item.source_buffer), buffer, -1);
gtk_source_buffer_end_not_undoable_action (notebook_item.source_buffer);
gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (notebook_item.source_buffer), FALSE);
/* move cursor to the beginning */
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (notebook_item.source_buffer), ¬ebook_item.iter);
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (notebook_item.source_buffer), ¬ebook_item.iter);
{
GtkTextIter start, end;
char *text;
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (notebook_item.source_buffer), &start, &end);
text = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (notebook_item.source_buffer), &start, &end, TRUE);
g_assert (!strcmp (text, buffer));
g_free (text);
}
g_free (buffer);
GtkWidget * vm_frame;
vm_frame = gtk_frame_new ("VM operations");
// create buttons
notebook_item.notebook_button_hbox = gtk_hbox_new (FALSE, 0);
notebook_item.run_step_button = gtk_button_new_with_label ("Run Step");
notebook_item.run_button = gtk_button_new_with_label ("Run");
notebook_item.view_vm_mem = gtk_button_new_with_label ("View Vm memory");
// create time out input
notebook_item.timeout_field = gtk_entry_new_with_max_length(10);
GtkWidget * timeout_label;
timeout_label = gtk_label_new("Timeout:");
g_signal_connect (notebook_item.run_step_button, "clicked", G_CALLBACK (GUI::run_step_button_clicked), gpointer(this));
g_signal_connect (notebook_item.run_button, "clicked", G_CALLBACK (GUI::run_button_clicked), gpointer(this));
g_signal_connect (notebook_item.view_vm_mem, "clicked", G_CALLBACK (GUI::view_vm_mem_clicked), gpointer(this));
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox),
notebook_item.view_vm_mem,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5); // pixel of padding around the widget
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox),
notebook_item.run_step_button,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5); // pixel of padding around the widget
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox),
timeout_label,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5); // pixel of padding around the widget
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox),
notebook_item.timeout_field,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5); // pixel of padding around the widget
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_button_hbox),
notebook_item.run_button,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5); // pixel of padding around the widget
gtk_container_add(GTK_CONTAINER (vm_frame), notebook_item.notebook_button_hbox);
gtk_box_pack_start (GTK_BOX (notebook_item.notebook_vbox),
vm_frame,
FALSE, // vbox gives widget all remaining space
FALSE, // widget expands to fill given space
5);
gtk_notebook_append_page( GTK_NOTEBOOK(this->programs_notebook),
notebook_item.notebook_vbox,
notebook_item.notebook_label);
this->gui_notebook_item_list.push_back(notebook_item);
gtk_widget_show_all(this->programs_notebook);
} else {
g_print("WRONG \n");
}
}
static void
extension_search_result(GFile *parent, GFileInfo *info, gpointer unused, I7SearchWindow *self)
{
I7_SEARCH_WINDOW_USE_PRIVATE(self, priv);
GError *err = NULL;
const char *basename = g_file_info_get_name(info);
GFile *file = g_file_get_child(parent, basename);
char *contents;
GtkTextBuffer *buffer;
GtkTreeIter result;
GtkTextIter search_from, match_start, match_end;
if(!g_file_load_contents(file, NULL, &contents, NULL, NULL, &err)) {
char *author_display_name = file_get_display_name(parent);
const char *ext_display_name = g_file_info_get_display_name(info);
error_dialog_file_operation(GTK_WINDOW(self), file, err, I7_FILE_ERROR_OTHER,
/* TRANSLATORS: Error opening EXTENSION_NAME by AUTHOR_NAME */
_("Error opening extension '%s' by '%s':"), author_display_name, ext_display_name);
g_free(author_display_name);
g_object_unref(file);
return;
}
buffer = GTK_TEXT_BUFFER(gtk_source_buffer_new(NULL));
gtk_text_buffer_set_text(buffer, contents, -1);
g_free(contents);
gtk_text_buffer_get_start_iter(buffer, &search_from);
start_spinner(self);
while(find_no_wrap(&search_from, priv->text, TRUE,
GTK_SOURCE_SEARCH_TEXT_ONLY | (priv->ignore_case? GTK_SOURCE_SEARCH_CASE_INSENSITIVE : 0),
priv->algorithm, &match_start, &match_end))
{
unsigned lineno;
char *sort, *context;
while(gtk_events_pending())
gtk_main_iteration();
search_from = match_end;
/* Get the line number (counted from 0) */
lineno = gtk_text_iter_get_line(&match_start) + 1;
context = extract_context(buffer, &match_start, &match_end);
/* Make a sort string */
sort = g_strdup_printf("%s %04i", basename, lineno);
gtk_list_store_append(priv->results, &result);
gtk_list_store_set(priv->results, &result,
I7_RESULT_CONTEXT_COLUMN, context,
I7_RESULT_SORT_STRING_COLUMN, sort,
I7_RESULT_FILE_COLUMN, file,
I7_RESULT_RESULT_TYPE_COLUMN, I7_RESULT_TYPE_EXTENSION,
I7_RESULT_LINE_NUMBER_COLUMN, lineno,
-1);
g_free(context);
g_free(sort);
}
stop_spinner(self);
g_object_unref(buffer);
g_object_unref(file);
}
SourceView::SourceView(const std::string& language, bool readOnly)
{
// Set the search path to the language and style files
gchar* directories[2];
#if defined(POSIX) && defined(PKGDATADIR)
std::string langFilesDir = std::string(PKGDATADIR) + "/sourceviewer/";
#else
std::string langFilesDir = GlobalRegistry().get(RKEY_APP_PATH) + "sourceviewer/";
#endif
directories[0] = const_cast<gchar*>(langFilesDir.c_str()); // stupid GtkSourceLanguageManager is expecting non-const gchar* pointer...
directories[1] = NULL;
GtkSourceStyleSchemeManager* styleSchemeManager = gtk_source_style_scheme_manager_get_default();
gtk_source_style_scheme_manager_set_search_path(styleSchemeManager, directories);
gtk_source_style_scheme_manager_force_rescan(styleSchemeManager);
_langManager = gtk_source_language_manager_new();
gtk_source_language_manager_set_search_path(_langManager, directories);
GtkSourceLanguage* lang = gtk_source_language_manager_get_language(_langManager, language.c_str());
if (lang == NULL)
{
globalErrorStream() << "SourceView: Cannot find language " << language << " in " << langFilesDir << std::endl;
}
// Remember the pointers to the textbuffers
if (lang != NULL)
{
_buffer = gtk_source_buffer_new_with_language(lang);
gtk_source_buffer_set_highlight_syntax(_buffer, TRUE);
}
else
{
_buffer = gtk_source_buffer_new(NULL);
gtk_source_buffer_set_highlight_syntax(_buffer, FALSE);
}
_view = GTK_SOURCE_VIEW(gtk_source_view_new_with_buffer(_buffer));
gtk_widget_set_size_request(GTK_WIDGET(_view), 0, -1); // allow shrinking
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(_view), GTK_WRAP_WORD);
gtk_text_view_set_editable(GTK_TEXT_VIEW(_view), readOnly ? FALSE : TRUE);
gtk_source_view_set_show_line_numbers(_view, TRUE);
gtk_source_view_set_auto_indent(_view, TRUE);
// Use a fixed width font
PangoFontDescription* fontDesc = pango_font_description_from_string("Monospace");
if (fontDesc != NULL)
{
gtk_widget_modify_font(GTK_WIDGET(_view), fontDesc);
}
// Use a tab size of 4
gtk_source_view_set_tab_width(GTK_SOURCE_VIEW(_view), 4);
widget_connect_escape_clear_focus_widget(GTK_WIDGET(_view));
_widget = gtkutil::ScrolledFrame(GTK_WIDGET(_view));
}
int
main (int argc, char *argv[])
{
GtkSourceBuffer *buffer;
GtkSourceSearchContext *search_context;
GtkSourceSearchSettings *search_settings;
GtkTextIter iter;
GtkTextIter match_end;
GTimer *timer;
gint i;
GtkTextSearchFlags flags;
gchar *regex_pattern;
gtk_init (&argc, &argv);
buffer = gtk_source_buffer_new (NULL);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
for (i = 0; i < NB_LINES; i++)
{
gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer),
&iter,
"A line of text to fill the text buffer. Is it long enough?\n",
-1);
}
gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &iter, "foo\n", -1);
/* Basic search, no flags */
timer = g_timer_new ();
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
flags = 0;
while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("basic forward search, no flags: %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Basic search, with flags always enabled by gsv */
g_timer_start (timer);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
flags = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY;
while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("basic forward search, visible and text only flags: %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Basic search, with default flags in gsv */
g_timer_start (timer);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
flags = GTK_TEXT_SEARCH_VISIBLE_ONLY |
GTK_TEXT_SEARCH_TEXT_ONLY |
GTK_TEXT_SEARCH_CASE_INSENSITIVE;
while (gtk_text_iter_forward_search (&iter, "foo", flags, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("basic forward search, all flags: %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Smart forward search, with default flags in gsv */
search_settings = gtk_source_search_settings_new ();
search_context = gtk_source_search_context_new (buffer, search_settings);
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, "foo");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("smart synchronous forward search, case insensitive: %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Smart forward search, case sensitive */
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, NULL);
gtk_source_search_settings_set_case_sensitive (search_settings, TRUE);
gtk_source_search_settings_set_search_text (search_settings, "foo");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("smart synchronous forward search, case sensitive: %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Regex search: search "foo" */
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, NULL);
gtk_source_search_settings_set_regex_enabled (search_settings, TRUE);
gtk_source_search_settings_set_search_text (search_settings, "foo");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("regex search: 'foo' (no partial matches): %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Regex search: search "fill" */
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, "fill");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("regex search: 'fill' (no partial matches): %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Regex search: search single lines */
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, ".*");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("regex search: match single lines (no partial matches): %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Regex search: search matches of 3 lines */
g_timer_start (timer);
/* The space at the beginning of the pattern permits to not have contiguous
* matches. There is a performance issue with contiguous matches.
*/
gtk_source_search_settings_set_search_text (search_settings, " (.*\n){3}");
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("regex search: matches of 3 lines (small partial matches): %lf seconds.\n",
g_timer_elapsed (timer, NULL));
/* Regex search: search matches of really big chunks */
g_timer_start (timer);
regex_pattern = g_strdup_printf (" (.*\n){%d}", NB_LINES / 10);
gtk_source_search_settings_set_search_text (search_settings, regex_pattern);
g_free (regex_pattern);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
while (gtk_source_search_context_forward (search_context, &iter, NULL, &match_end, NULL))
{
iter = match_end;
}
g_timer_stop (timer);
g_print ("regex search: 10 matches of %d lines (big partial matches): %lf seconds.\n",
NB_LINES / 10,
g_timer_elapsed (timer, NULL));
/* Smart search, case sensitive, asynchronous */
/* The asynchronous overhead doesn't depend on the search flags, it
* depends on the maximum number of lines to scan in one batch, and
* (obviously), on the buffer size.
* You can tune SCAN_BATCH_SIZE in gtksourcesearchcontext.c to see a
* difference in the overhead.
*/
g_signal_connect (search_context,
"notify::occurrences-count",
G_CALLBACK (on_notify_search_occurrences_count_cb),
timer);
g_timer_start (timer);
gtk_source_search_settings_set_search_text (search_settings, NULL);
gtk_source_search_settings_set_regex_enabled (search_settings, FALSE);
gtk_source_search_settings_set_search_text (search_settings, "foo");
gtk_main ();
return 0;
}
/**
* gb_view_source_init:
* @: (in): A #GbViewSource.
*
* Initializes the newly created #GbViewSource instance.
*/
static void
gb_view_source_init (GbViewSource *source)
{
GbViewSourcePrivate *priv;
GtkWidget *overlay;
ENTRY;
source->priv = priv =
G_TYPE_INSTANCE_GET_PRIVATE(source,
GB_TYPE_VIEW_SOURCE,
GbViewSourcePrivate);
g_object_set(source,
"icon-name", GTK_STOCK_FILE,
"name", _("Unsaved Document"),
NULL);
priv->buffer = gtk_source_buffer_new(NULL);
g_signal_connect_swapped(priv->buffer,
"notify::cursor-position",
G_CALLBACK(gb_view_source_notify_cursor),
source);
g_signal_connect_swapped(priv->buffer, "modified-changed",
G_CALLBACK(gb_view_source_buffer_modified_changed),
source);
overlay = g_object_new(GTK_TYPE_OVERLAY,
"visible", TRUE,
NULL);
g_signal_connect(overlay, "get-child-position",
G_CALLBACK(gb_view_source_position_progress),
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(source), overlay,
"left-attach", 0,
"width", 1,
"top-attach", 0,
"height", 1,
NULL);
priv->vpaned = g_object_new(GTK_TYPE_VPANED,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(overlay), priv->vpaned);
priv->progress = g_object_new(GB_TYPE_PROGRESS_BAR,
"visible", FALSE,
NULL);
gtk_overlay_add_overlay(GTK_OVERLAY(overlay), priv->progress);
priv->scroller1 = g_object_new(gb_get_scrolled_window_gtype(),
"expand", TRUE,
"visible", TRUE,
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(priv->vpaned), priv->scroller1,
"shrink", FALSE,
"resize", TRUE,
NULL);
priv->source1 = gb_view_source_create_source_view(source);
gtk_container_add(GTK_CONTAINER(priv->scroller1), priv->source1);
{
GtkSourceLanguageManager *langs = gtk_source_language_manager_get_default();
const gchar * const * ids = gtk_source_language_manager_get_language_ids(langs);
GtkSourceLanguage *lang;
const gchar *section;
GHashTable *section_menu;
GPtrArray *sorted;
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *menu;
GtkWidget *mitem;
GtkWidget *submenu;
guint i;
section_menu = g_hash_table_new(g_str_hash, g_str_equal);
menu = gtk_menu_new();
sorted = g_ptr_array_new();
for (i = 0; ids[i]; i++) {
lang = gtk_source_language_manager_get_language(langs, ids[i]);
g_ptr_array_add(sorted, lang);
}
g_ptr_array_sort(sorted, lang_sort_func);
for (i = 0; i < sorted->len; i++) {
lang = g_ptr_array_index(sorted, i);
section = gtk_source_language_get_section(lang);
if (!(submenu = g_hash_table_lookup(section_menu, section))) {
submenu = gtk_menu_new();
mitem = g_object_new(GTK_TYPE_MENU_ITEM,
"label", section,
"submenu", submenu,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(menu), mitem);
g_hash_table_insert(section_menu, (gchar*)section, submenu);
}
mitem = g_object_new(GTK_TYPE_MENU_ITEM,
"label", gtk_source_language_get_name(lang),
"visible", TRUE,
NULL);
g_signal_connect_swapped(mitem, "activate",
G_CALLBACK(gb_view_source_lang_activate),
source);
g_object_set_data(G_OBJECT(mitem), "language-id",
(gchar *)gtk_source_language_get_id(lang));
gtk_container_add(GTK_CONTAINER(submenu), mitem);
}
g_ptr_array_free(sorted, TRUE);
priv->lang_combo = g_object_new(GB_TYPE_MENU_BUTTON,
"hexpand", FALSE,
"label", "",
"menu", menu,
"tooltip-text", _("Set source language."),
"visible", TRUE,
NULL);
gb_widget_shrink_font(
gb_menu_button_get_label_widget(
GB_MENU_BUTTON(priv->lang_combo)));
gtk_style_context_add_class(gtk_widget_get_style_context(priv->lang_combo),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), priv->lang_combo,
"expand", FALSE,
NULL);
g_hash_table_unref(section_menu);
}
{
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *b;
GtkWidget *item;
GtkWidget *menu;
GtkWidget *group = NULL;
gboolean active;
gchar *str;
int tabs[] = { 2, 3, 4, 5, 8, 0 };
int i;
b = g_object_new(GB_TYPE_MENU_BUTTON,
"hexpand", FALSE,
"label", "4",
"tooltip-text", _("Set tab-character width."),
"visible", TRUE,
"width-request", 45,
NULL);
menu = gtk_menu_new();
for (i = 0; tabs[i]; i++) {
str = g_strdup_printf("%d", tabs[i]);
item = g_object_new(GTK_TYPE_RADIO_MENU_ITEM,
"group", group,
"label", str,
"visible", TRUE,
NULL);
if (!group) {
group = item;
}
active = (tabs[i] == gtk_source_view_get_tab_width(
GTK_SOURCE_VIEW(priv->source1)));
g_object_set(item, "active", active, NULL);
if (active) {
g_object_set(b, "label", str, NULL);
}
g_signal_connect(item, "activate",
G_CALLBACK(gb_view_source_tab_size_activate),
source);
gtk_container_add(GTK_CONTAINER(menu), item);
g_free(str);
}
g_object_set(b, "menu", menu, NULL);
item = g_object_new(GTK_TYPE_SEPARATOR_MENU_ITEM,
"visible", TRUE,
NULL);
gtk_container_add(GTK_CONTAINER(menu), item);
item = g_object_new(GTK_TYPE_CHECK_MENU_ITEM,
"active", TRUE,
"label", _("Use Spaces"),
"visible", TRUE,
NULL);
g_signal_connect(item, "toggled",
G_CALLBACK(gb_view_source_spaces_toggled),
source);
gtk_container_add(GTK_CONTAINER(menu), item);
gb_widget_shrink_font(gb_menu_button_get_label_widget(GB_MENU_BUTTON(b)));
gtk_style_context_add_class(gtk_widget_get_style_context(b),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), b,
"expand", FALSE,
NULL);
priv->size_combo = b;
}
{
GtkWidget *controls = gb_view_get_controls(GB_VIEW(source));
GtkWidget *img;
GtkWidget *b;
img = g_object_new(GTK_TYPE_IMAGE,
"icon-name", "gb-split",
"icon-size", GTK_ICON_SIZE_MENU,
"visible", TRUE,
NULL);
b = g_object_new(GTK_TYPE_TOGGLE_BUTTON,
"child", img,
"tooltip-text", _("Split the editor into two views."),
"visible", TRUE,
NULL);
gtk_style_context_add_class(gtk_widget_get_style_context(b),
GB_STYLE_CLASS_TOP_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(controls), b,
"expand", FALSE,
NULL);
g_signal_connect(b, "toggled",
G_CALLBACK(split_toggled),
source);
}
{
GtkWidget *hbox;
GtkWidget *vp;
GtkWidget *c;
hbox = g_object_new(GTK_TYPE_HBOX,
"height-request", 30,
"visible", TRUE,
NULL);
gtk_container_add_with_properties(GTK_CONTAINER(source), hbox,
"height", 1,
"left-attach", 0,
"top-attach", 1,
"width", 1,
NULL);
gtk_container_add(GTK_CONTAINER(hbox),
(c = g_object_new(GTK_TYPE_COMBO_BOX,
"visible", TRUE,
NULL)));
gtk_style_context_add_class(gtk_widget_get_style_context(c),
GB_STYLE_CLASS_BOTTOM_BAR);
vp = g_object_new(GTK_TYPE_VIEWPORT,
"visible", TRUE,
NULL);
gtk_style_context_add_class(gtk_widget_get_style_context(vp),
GB_STYLE_CLASS_BOTTOM_BAR);
gtk_container_add_with_properties(GTK_CONTAINER(hbox), vp,
"expand", FALSE,
"fill", TRUE,
NULL);
priv->pos_label = g_object_new(GTK_TYPE_LABEL,
"label", _("Line 1, Column 1"),
"visible", TRUE,
"xalign", 1.0f,
"xpad", 6,
NULL);
gb_widget_shrink_font(priv->pos_label);
gtk_container_add(GTK_CONTAINER(vp), priv->pos_label);
}
priv->theme_handler =
g_signal_connect_swapped(gtk_settings_get_default(),
"notify::gtk-application-prefer-dark-theme",
G_CALLBACK(gb_view_source_update_style),
source);
EXIT;
}
GUIEditor *
gui_editor_new (void)
{
GUIEditor *self;
GPtrArray *dirs;
const gchar * const *current_search_path;
gchar **lang_spec_search_path;
self = g_malloc0 (sizeof (GUIEditor));
self->buffer = gtk_source_buffer_new (NULL);
self->widget = gtk_source_view_new_with_buffer (self->buffer);
self->scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (self->scroll), self->widget);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (self->scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gui_editor_set_font (self, DEFAULT_EDITOR_FONT);
self->hltag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER(self->buffer),
HIGHLIGHT_TAG,
"background", COLOUR_BG_HL,
NULL);
self->lang_manager = gtk_source_language_manager_new ();
self->style_scheme_manager = gtk_source_style_scheme_manager_get_default ();
dirs = g_ptr_array_new();
current_search_path = gtk_source_language_manager_get_search_path(self->lang_manager);
for (; current_search_path != NULL && *current_search_path != NULL; ++current_search_path)
g_ptr_array_add(dirs, g_strdup(*current_search_path));
// look for spec file in our own directory
g_ptr_array_add(dirs, g_strdup(PACKAGE_DATA_DIR));
// look for spec file in data directory when running from svn
g_ptr_array_add(dirs, g_strdup("data"));
// look for spec file in current directory, when running on windows
g_ptr_array_add(dirs, g_strdup("."));
g_ptr_array_add(dirs, g_strdup(NULL));
lang_spec_search_path = (gchar **)g_ptr_array_free(dirs, FALSE);
gtk_source_language_manager_set_search_path (self->lang_manager, lang_spec_search_path);
gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, "data");
gtk_source_style_scheme_manager_append_search_path (self->style_scheme_manager, ".");
#if GTK_CHECK_VERSION(3, 0, 0)
GtkSourceMarkAttributes *mark_attributes = gtk_source_mark_attributes_new ();
gtk_source_mark_attributes_set_icon_name (mark_attributes, "gtk-no");
gtk_source_view_set_mark_attributes (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, mark_attributes, 0);
#else
GdkPixbuf *pixbuf;
pixbuf = gui_editor_get_stock_icon (GTK_WIDGET(self->widget), GTK_STOCK_NO, GTK_ICON_SIZE_MENU);
if (pixbuf)
{
gtk_source_view_set_mark_category_icon_from_pixbuf (GTK_SOURCE_VIEW (self->widget), MARKER_BREAKPOINT, pixbuf);
g_object_unref (pixbuf);
}
#endif
return self;
}
