void
_gtk_recent_chooser_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
GtkRecentChooser *recent_chooser;
GtkRecentChooser *action_chooser;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
recent_chooser = GTK_RECENT_CHOOSER (activatable);
action_chooser = GTK_RECENT_CHOOSER (action);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (!action)
return;
if (recent_chooser_has_show_numbers (recent_chooser))
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
g_object_set (recent_chooser, "show-numbers",
gtk_recent_action_get_show_numbers (GTK_RECENT_ACTION (action)),
NULL);
G_GNUC_END_IGNORE_DEPRECATIONS;
}
gtk_recent_chooser_set_show_private (recent_chooser, gtk_recent_chooser_get_show_private (action_chooser));
gtk_recent_chooser_set_show_not_found (recent_chooser, gtk_recent_chooser_get_show_not_found (action_chooser));
gtk_recent_chooser_set_show_tips (recent_chooser, gtk_recent_chooser_get_show_tips (action_chooser));
gtk_recent_chooser_set_show_icons (recent_chooser, gtk_recent_chooser_get_show_icons (action_chooser));
gtk_recent_chooser_set_limit (recent_chooser, gtk_recent_chooser_get_limit (action_chooser));
gtk_recent_chooser_set_local_only (recent_chooser, gtk_recent_chooser_get_local_only (action_chooser));
gtk_recent_chooser_set_sort_type (recent_chooser, gtk_recent_chooser_get_sort_type (action_chooser));
gtk_recent_chooser_set_filter (recent_chooser, gtk_recent_chooser_get_filter (action_chooser));
}
void
board_window_init (window_board_t *win)
{
//win->window = create_window_hand ();
win->window = get_widget ("window_hand");
win->statusbar = GTK_STATUSBAR (get_widget ("statusbar1"));
win->board_menu = get_widget ("board_menu1");
create_hand_widgets(win);
create_bidding_widget (win);
/* set up "recently used" menu */
GtkWidget *jump_menu = get_widget ("jump_to1");
#if GTK_CHECK_VERSION (2,10,0)
GtkWidget *recentchooser = gtk_recent_chooser_menu_new ();
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recentchooser),
GTK_RECENT_SORT_MRU);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (jump_menu), recentchooser);
g_signal_connect (G_OBJECT (recentchooser), "item-activated",
G_CALLBACK (jump_menu_select), NULL);
GtkRecentFilter *filter = gtk_recent_filter_new ();
gtk_recent_filter_add_pattern (filter, "*.lin");
gtk_recent_filter_add_pattern (filter, "*.pbn");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (recentchooser), filter);
#else
gtk_widget_set_sensitive (jump_menu, FALSE);
#endif
win->keyfile = g_key_file_new ();
win->show_played_cards = 0;
win->show_hands = seat_all;
win->show_dd_scores = seat_all;
win->svg = NULL;
win->card_width = 70;
win->filename = NULL;
win->title = win->subtitle = win->team1 = win->team2 = NULL;
win->boards = NULL;
win->board_numbers = NULL;
win->n_boards_alloc = 0;
win->n_boards = 0;
win->cutbuf = NULL;
win->cur = 0;
GdkColor bg = { 0, HAND_DISPLAY_TABLE_GDK_BG };
gdk_colormap_alloc_color (gdk_colormap_get_system (), &bg, FALSE, TRUE);
gtk_widget_modify_bg (win->window, GTK_STATE_NORMAL, &bg);
gtk_widget_show (win->window);
}
static void
gtk_recent_action_connect_proxy (GtkAction *action,
GtkWidget *widget)
{
GtkRecentAction *recent_action = GTK_RECENT_ACTION (action);
GtkRecentActionPrivate *priv = recent_action->priv;
/* it can only be a recent chooser implementor anyway... */
if (GTK_IS_RECENT_CHOOSER (widget) &&
!g_slist_find (priv->choosers, widget))
{
if (priv->sort_func)
{
gtk_recent_chooser_set_sort_func (GTK_RECENT_CHOOSER (widget),
priv->sort_func,
priv->sort_data,
priv->data_destroy);
}
g_signal_connect_swapped (widget, "selection_changed",
G_CALLBACK (delegate_selection_changed),
action);
g_signal_connect_swapped (widget, "item-activated",
G_CALLBACK (delegate_item_activated),
action);
}
if (GTK_ACTION_CLASS (gtk_recent_action_parent_class)->connect_proxy)
GTK_ACTION_CLASS (gtk_recent_action_parent_class)->connect_proxy (action, widget);
}
/**
* swfdec_window_new:
* @uri: a valid UTF-8 encoded URI.
*
* Opens a new window. If a URI was specified, it will be shown. Otherwise the
* window will appear empty.
*
* Returns: The window that was just openend. You don't own a reference to it.
**/
SwfdecWindow *
swfdec_window_new (const char *url)
{
GError *error = NULL;
SwfdecWindow *window;
window = g_object_new (SWFDEC_TYPE_WINDOW, NULL);
window->builder = gtk_builder_new ();
gtk_builder_set_translation_domain (window->builder, GETTEXT_PACKAGE);
if (!gtk_builder_add_from_file (window->builder, BUILDER_FILE, &error)) {
swfdec_window_error (window, error->message);
return window;
}
gtk_builder_connect_signals (window->builder, window);
swfdec_window_add_recent_filter (GTK_RECENT_CHOOSER (
gtk_builder_get_object (window->builder, "recent")));
window->window = GTK_WIDGET (gtk_builder_get_object (window->builder, "player-window"));
if (window->window == NULL) {
swfdec_window_error (window, _("Broken user interface definition file"));
return window;
}
g_object_weak_ref (G_OBJECT (window->window), (GWeakNotify) g_object_unref, window);
if (url != NULL) {
swfdec_window_set_url (window, url);
}
swfdec_window_set_settings (window, &window->settings);
return window;
}
static void
pluma_prefs_manager_max_recents_changed (GSettings *settings,
gchar *key,
gpointer user_data)
{
pluma_debug (DEBUG_PREFS);
if (strcmp (key, GPM_MAX_RECENTS) == 0)
{
const GList *windows;
gint max;
max = g_settings_get_int (settings, key);
if (max < 0) {
max = GPM_DEFAULT_MAX_RECENTS;
}
windows = pluma_app_get_windows (pluma_app_get_default ());
while (windows != NULL)
{
PlumaWindow *w = windows->data;
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (w->priv->toolbar_recent_menu),
max);
windows = g_list_next (windows);
}
/* FIXME: we have no way at the moment to trigger the
* update of the inline recents in the File menu */
}
}
static void
jump_menu_select (GtkWidget *recentchooser, char *unused)
{
char *filename = gtk_recent_chooser_get_current_uri (GTK_RECENT_CHOOSER (recentchooser));
if (strncmp (filename, "file://", sizeof ("file://") - 1))
return;
board_load_popup (win, 0, filename + sizeof ("file://") - 1);
}
void setupRecent(GtkMenuItem *menu)
{
GtkRecentFilter *filter;
GtkWidget *recent;
recent=gtk_recent_chooser_menu_new();
gtk_recent_chooser_set_local_only(GTK_RECENT_CHOOSER(recent),false);
gtk_recent_chooser_set_sort_type(GTK_RECENT_CHOOSER(recent),GTK_RECENT_SORT_MRU);
gtk_recent_chooser_set_limit(GTK_RECENT_CHOOSER(recent),10);
filter=gtk_recent_filter_new();
gtk_recent_filter_add_mime_type (filter,"application/x-maneditdoc");
//gtk_recent_filter_add_application(filter,"manpageeditor");
gtk_recent_chooser_set_filter(GTK_RECENT_CHOOSER(recent),filter);
g_signal_connect(recent,"item_activated",G_CALLBACK(recentFileMenu),NULL);
gtk_menu_item_set_submenu(menu,recent);
}
GtkWidget * __recent_create_menu (void)
{
GtkWidget *recent_menu;
GtkRecentFilter *recent_filter;
recent_menu = gtk_recent_chooser_menu_new_for_manager (recent_manager);
gtk_recent_chooser_menu_set_show_numbers (GTK_RECENT_CHOOSER_MENU (recent_menu), FALSE);
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (recent_menu), TRUE);
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (recent_menu), 4);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recent_menu), GTK_RECENT_SORT_MRU);
gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (recent_menu), TRUE);
recent_filter = gtk_recent_filter_new ();
gtk_recent_filter_add_mime_type (recent_filter, GNOMINT_MIME_TYPE);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (recent_menu), recent_filter);
return recent_menu;
}
void
_gtk_recent_chooser_update (GtkActivatable *activatable,
GtkAction *action,
const gchar *property_name)
{
GtkRecentChooser *recent_chooser;
GtkRecentChooser *action_chooser;
GtkRecentAction *recent_action;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
recent_chooser = GTK_RECENT_CHOOSER (activatable);
action_chooser = GTK_RECENT_CHOOSER (action);
recent_action = GTK_RECENT_ACTION (action);
G_GNUC_END_IGNORE_DEPRECATIONS;
if (strcmp (property_name, "show-numbers") == 0 && recent_chooser_has_show_numbers (recent_chooser))
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
g_object_set (recent_chooser, "show-numbers",
gtk_recent_action_get_show_numbers (recent_action), NULL);
G_GNUC_END_IGNORE_DEPRECATIONS;
}
else if (strcmp (property_name, "show-private") == 0)
gtk_recent_chooser_set_show_private (recent_chooser, gtk_recent_chooser_get_show_private (action_chooser));
else if (strcmp (property_name, "show-not-found") == 0)
gtk_recent_chooser_set_show_not_found (recent_chooser, gtk_recent_chooser_get_show_not_found (action_chooser));
else if (strcmp (property_name, "show-tips") == 0)
gtk_recent_chooser_set_show_tips (recent_chooser, gtk_recent_chooser_get_show_tips (action_chooser));
else if (strcmp (property_name, "show-icons") == 0)
gtk_recent_chooser_set_show_icons (recent_chooser, gtk_recent_chooser_get_show_icons (action_chooser));
else if (strcmp (property_name, "limit") == 0)
gtk_recent_chooser_set_limit (recent_chooser, gtk_recent_chooser_get_limit (action_chooser));
else if (strcmp (property_name, "local-only") == 0)
gtk_recent_chooser_set_local_only (recent_chooser, gtk_recent_chooser_get_local_only (action_chooser));
else if (strcmp (property_name, "sort-type") == 0)
gtk_recent_chooser_set_sort_type (recent_chooser, gtk_recent_chooser_get_sort_type (action_chooser));
else if (strcmp (property_name, "filter") == 0)
gtk_recent_chooser_set_filter (recent_chooser, gtk_recent_chooser_get_filter (action_chooser));
}
static void
gitg_window_parser_finished(GtkBuildable *buildable, GtkBuilder *builder)
{
if (parent_iface.parser_finished)
parent_iface.parser_finished(buildable, builder);
// Store widgets
GitgWindow *window = GITG_WINDOW(buildable);
window->priv->vpaned_main = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_main"));
window->priv->hpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "hpaned_commit"));
window->priv->vpaned_commit = GTK_WIDGET(gtk_builder_get_object(builder, "vpaned_commit"));
window->priv->notebook_main = GTK_NOTEBOOK(gtk_builder_get_object(builder, "notebook_main"));
window->priv->tree_view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "tree_view_rv"));
window->priv->statusbar = GTK_STATUSBAR(gtk_builder_get_object(builder, "statusbar"));
window->priv->revision_view = GITG_REVISION_VIEW(gtk_builder_get_object(builder, "revision_view"));
window->priv->revision_tree_view = GITG_REVISION_TREE_VIEW(gtk_builder_get_object(builder, "revision_tree_view"));
window->priv->commit_view = GITG_COMMIT_VIEW(gtk_builder_get_object(builder, "hpaned_commit"));
restore_state(window);
window->priv->edit_group = GTK_ACTION_GROUP(gtk_builder_get_object(builder, "action_group_menu_edit"));
GtkTreeViewColumn *col = GTK_TREE_VIEW_COLUMN(gtk_builder_get_object(builder, "rv_column_subject"));
window->priv->renderer_path = GITG_CELL_RENDERER_PATH(gtk_builder_get_object(builder, "rv_renderer_subject"));
gtk_tree_view_column_set_cell_data_func(col, GTK_CELL_RENDERER(window->priv->renderer_path), (GtkTreeCellDataFunc)on_renderer_path, window, NULL);
GtkRecentFilter *filter = gtk_recent_filter_new();
gtk_recent_filter_add_group(filter, "gitg");
GtkRecentChooser *chooser = GTK_RECENT_CHOOSER(gtk_builder_get_object(builder, "RecentOpenAction"));
gtk_recent_chooser_add_filter(chooser, filter);
// Intialize branches
build_branches_combo(window, builder);
// Create search entry
build_search_entry(window, builder);
gtk_builder_connect_signals(builder, window);
// Connect signals
GtkTreeSelection *selection = gtk_tree_view_get_selection(window->priv->tree_view);
g_signal_connect(selection, "changed", G_CALLBACK(on_selection_changed), window);
g_signal_connect(window->priv->revision_view, "parent-activated", G_CALLBACK(on_parent_activated), window);
g_signal_connect(window->priv->tree_view, "motion-notify-event", G_CALLBACK(on_tree_view_motion), window);
g_signal_connect(window->priv->tree_view, "button-release-event", G_CALLBACK(on_tree_view_button_release), window);
}
static GtkWidget *
create_recent_chooser_menu (gint limit)
{
GtkWidget *menu;
GtkRecentFilter *filter;
GtkWidget *menuitem;
menu = gtk_recent_chooser_menu_new_for_manager (manager);
if (limit > 0)
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER (menu), limit);
gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER (menu), TRUE);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (menu),
GTK_RECENT_SORT_MRU);
gtk_recent_chooser_menu_set_show_numbers (GTK_RECENT_CHOOSER_MENU (menu),
TRUE);
filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter, "Gedit files");
gtk_recent_filter_add_application (filter, "gedit");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (menu), filter);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (menu), filter);
g_signal_connect (menu, "item-activated",
G_CALLBACK (item_activated_cb),
NULL);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Test prepend");
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("Test append");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_mnemonic ("Clear");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_show_all (menu);
return menu;
}
static void
glide_window_insert_recent_menu_item (GlideWindow *w)
{
GtkRecentFilter *filter = gtk_recent_filter_new ();
GtkWidget *men = gtk_recent_chooser_menu_new_for_manager (w->priv->recent_manager);
GtkMenuItem *recent_menu_item = GTK_MENU_ITEM (GLIDE_WINDOW_UI_OBJECT (w, "open-recent-menuitem"));
gtk_recent_filter_add_application (filter, "Glide");
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (men), filter);
g_signal_connect (men, "item-activated", G_CALLBACK (glide_window_recent_item_activated), w);
gtk_menu_item_set_submenu (recent_menu_item, men);
}
static void
recent_cb (GSimpleAction *action,
GVariant *parameter,
gpointer app)
{
GtkWidget *dialog;
GtkWindow *win;
GtkRecentInfo *info;
GtkRecentChooser *chooser;
GtkRecentFilter *filter;
GtkRecentFilter *filter_all;
const gchar *uri = NULL;
win = gtk_application_get_active_window (app);
dialog = gtk_recent_chooser_dialog_new (
_("Recent Files"),
win,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Open"), GTK_RESPONSE_ACCEPT,
NULL);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (dialog), GTK_RECENT_SORT_MRU); /* Most Recently Used first */
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER (dialog), TRUE);
filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter, _("Parlatype"));
gtk_recent_filter_add_application (filter, "parlatype");
gtk_recent_filter_add_mime_type (filter, "audio/*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter);
filter_all = gtk_recent_filter_new ();
gtk_recent_filter_set_name (filter_all, _("All files"));
gtk_recent_filter_add_pattern (filter_all, "*");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (dialog), filter_all);
gtk_recent_chooser_set_filter (GTK_RECENT_CHOOSER (dialog), filter);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
chooser = GTK_RECENT_CHOOSER (dialog);
info = gtk_recent_chooser_get_current_item (chooser);
uri = gtk_recent_info_get_uri (info);
}
gtk_widget_destroy (dialog);
if (uri) {
/* GStreamer has problems with uris from recent chooser,
as a workaround use GFile magic */
GFile *file = g_file_new_for_uri (uri);
gchar *tmp = g_file_get_uri (file);
pt_window_open_file (PT_WINDOW (win), tmp);
g_free (tmp);
g_object_unref (file);
gtk_recent_info_unref (info);
}
}
static GtkWidget *
gtk_recent_action_create_menu (GtkAction *action)
{
GtkRecentAction *recent_action = GTK_RECENT_ACTION (action);
GtkRecentActionPrivate *priv = recent_action->priv;
GtkWidget *widget;
widget = g_object_new (GTK_TYPE_RECENT_CHOOSER_MENU,
"show-private", priv->show_private,
"show-not-found", priv->show_not_found,
"show-tips", priv->show_tips,
"show-icons", priv->show_icons,
"show-numbers", priv->show_numbers,
"limit", priv->limit,
"sort-type", priv->sort_type,
"recent-manager", priv->manager,
"filter", priv->current_filter,
"local-only", priv->local_only,
NULL);
if (priv->sort_func)
{
gtk_recent_chooser_set_sort_func (GTK_RECENT_CHOOSER (widget),
priv->sort_func,
priv->sort_data,
priv->data_destroy);
}
g_signal_connect_swapped (widget, "selection_changed",
G_CALLBACK (delegate_selection_changed),
recent_action);
g_signal_connect_swapped (widget, "item-activated",
G_CALLBACK (delegate_item_activated),
recent_action);
/* keep track of the choosers we create */
priv->choosers = g_slist_prepend (priv->choosers, widget);
return widget;
}
void open_recent(GtkRecentChooser *chooser, gpointer user_data) {
/** The user select an item from the recent file list. **/
#ifdef DEBUG
DEBUG_FUNC_MARK
#endif
/** retrieve the file URI from the selected item. **/
gchar *uri = gtk_recent_chooser_get_current_uri(GTK_RECENT_CHOOSER(chooser)) ;
if (uri) {
/** Convert the URI in a filepath. **/
gchar *filepath = g_filename_from_uri(uri, NULL, NULL) ;
/** Storing last opened file folder. **/
if (open_file_dirname != NULL) {
free(open_file_dirname) ;
}
open_file_dirname = g_strdup(g_path_get_dirname(filepath)) ;
/** Every file has an associated File_Editor structure which hold the Scrolled Window, TextView and GtkSourceBuffer. **/
File_Editor *file_editor = g_malloc0(sizeof(File_Editor)) ;
/** Add file content to the editor has an new notebook page. @NOTE: this function does more than the initalisation work, take a look at it. **/
add_file_to_editor(gui->editor_notebook, file_editor , filepath, false) ;
/** Setting the filepath text in the bottom bar. **/
gtk_label_set_text(GTK_LABEL(gui->bottom_bar->filename_label), g_path_get_basename(filepath)) ;
g_free(uri) ;
}
return ;
}
/* Callback for when of the items from the File->Open Recent submenu
is selected */
void
action_open_recent(GtkAction *action, I7App *app)
{
GtkRecentInfo *item = gtk_recent_chooser_get_current_item(GTK_RECENT_CHOOSER(action));
g_assert(gtk_recent_info_has_application(item, "Inform 7"));
GFile *file = g_file_new_for_uri(gtk_recent_info_get_uri(item));
if(gtk_recent_info_has_group(item, "inform7_project")) {
i7_story_new_from_file(app, file);
} else if(gtk_recent_info_has_group(item, "inform7_extension")) {
i7_extension_new_from_file(app, file, FALSE);
} else if(gtk_recent_info_has_group(item, "inform7_builtin")) {
i7_extension_new_from_file(app, file, TRUE);
} else {
g_warning("Recent manager file does not have an Inform tag. This means "
"it was not saved by Inform. I'll try to open it anyway.");
i7_story_new_from_file(app, file);
}
g_object_unref(file);
gtk_recent_info_unref(item);
}
static
GtkWidget *make_recent_documents_list (gboolean images, gchar *command, int limit, int age, gchar *sort_type)
{
GtkWidget *widget = gtk_recent_chooser_menu_new ();
if (images)
{
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER(widget), TRUE);
}
else
{
gtk_recent_chooser_set_show_icons (GTK_RECENT_CHOOSER(widget), FALSE);
}
g_signal_connect (G_OBJECT (widget), "item-activated", G_CALLBACK (recent_activated), g_strdup (command));
if (age)
{
GtkRecentFilter *filter = gtk_recent_filter_new ();
gtk_recent_filter_add_pattern (filter, "*");
gtk_recent_filter_add_age (filter, age);
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER(widget), filter);
}
if (sort_type)
{
if (strcmp (sort_type, "most used") == 0)
{
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER(widget), GTK_RECENT_SORT_MRU);
}
else
{
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER(widget), GTK_RECENT_SORT_LRU);
}
}
gtk_recent_chooser_set_limit (GTK_RECENT_CHOOSER(widget), limit);
return widget;
}
int
main (int argc, char *argv [])
{
/*Running Shell*/
GError *error = NULL;
python_shell_data = g_try_malloc (sizeof (ChildProcessData));
python_shell_data->argv = NULL;
python_shell_data->slave_termios = g_try_malloc (sizeof (struct termios));
python_shell_data->current_dir = NULL;
bash_loaded = ptyFork (python_shell_data, &error);
gtk_init (&argc, &argv);
python_shell_data->channel = g_io_channel_unix_new (python_shell_data->master_fd);
g_io_add_watch (python_shell_data->channel, G_IO_IN,
(GIOFunc)read_masterFd, &(python_shell_data->master_fd));
/**********/
/*Loading Options*/
if (g_file_test ("./options.inf", G_FILE_TEST_EXISTS))
load_options_from_file ("./options.inf");
else
{
options.indent_width = 4;
options.tab_width = 4;
options.is_code_completion = TRUE;
options.is_code_folding = TRUE;
options.show_line_numbers = TRUE;
options.font_name = "Liberation Mono";
}
/*************/
options.python_shell_path = "/usr/bin/python";
options.comment_out_str = "##";
options.indent_width_str = " ";
options.tab_width_str = " ";
env_python_path = "";
gchar **p = options.env_vars;
if (p)
{
while (*p)
{
gchar *s = g_strstr_len (*p, -1, "PYTHONPATH=");
if (s)
{
env_python_path = s + strlen ("PYTHONPATH=");
break;
}
p++;
}
}
/*Get sys.path*/
char *sys_path_argv[] = {"python", "./scripts/path.py", NULL};
g_spawn_sync (NULL, sys_path_argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, &sys_path_string, NULL, NULL, NULL);
/***********/
char *_str = g_strconcat (sys_path_string, "\n", env_python_path, NULL);
g_free (sys_path_string);
sys_path_string = _str;
file_monitor = file_monitor_new (file_monitor_changed);
/*Setting Main Window*/
GtkWidget *navigate_bookmarks;
builder = gtk_builder_new ();
gtk_builder_add_from_file (builder, "./ui/main.ui", NULL);
content_box = GTK_WIDGET (gtk_builder_get_object (builder, "content_box"));
window = gtk_builder_get_object (builder, "main_window");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
path_browser = path_browser_new ();
g_object_ref (path_browser);
proj_notebook = project_notebook_new ();
/**Setting proj_syms_tree_view**/
symbols_view = symbols_view_new ();
g_object_ref (symbols_view);
/*************************/
content_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
g_object_ref (content_paned);
status_bar = gtk_statusbar_new ();
g_object_ref (status_bar);
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
symbols_view, gtk_label_new ("Symbols"));
gtk_notebook_append_page (GTK_NOTEBOOK (proj_notebook),
path_browser,
gtk_label_new ("Paths"));
navigate_bookmarks = GTK_WIDGET (gtk_builder_get_object (builder,
"navigate_bookmarks"));
bookmarks_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (navigate_bookmarks),
bookmarks_menu);
GtkAccelGroup *accelgroup = GTK_ACCEL_GROUP (gtk_builder_get_object (builder,
"accelgroup"));
/*Connecting menu item's signals*/
//For File Menu
g_signal_connect (gtk_builder_get_object (builder, "file_new"), "activate",
G_CALLBACK (file_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_new_tab"), "activate",
G_CALLBACK (file_new_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_open"), "activate",
G_CALLBACK (file_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "recentchoosermenu"), "selection-done",
G_CALLBACK (file_recent_menu_selection_done), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save"), "activate",
G_CALLBACK (file_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_as"), "activate",
G_CALLBACK (file_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_copy_as"), "activate",
G_CALLBACK (file_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_save_all"), "activate",
G_CALLBACK (file_save_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_tab"), "activate",
G_CALLBACK (file_close_tab_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_close_all_tabs"), "activate",
G_CALLBACK (file_close_all_tabs_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "file_quit"), "activate",
G_CALLBACK (file_quit_activate), NULL);
//For Edit Menu
g_signal_connect (gtk_builder_get_object (builder, "edit_undo"), "activate",
G_CALLBACK (edit_undo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_redo"), "activate",
G_CALLBACK (edit_redo_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_cut"), "activate",
G_CALLBACK (edit_cut_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_copy"), "activate",
G_CALLBACK (edit_copy_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_paste"), "activate",
G_CALLBACK (edit_paste_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_delete"), "activate",
G_CALLBACK (edit_delete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_all"), "activate",
G_CALLBACK (edit_select_all_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_function"), "activate",
G_CALLBACK (edit_select_function_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_select_block"), "activate",
G_CALLBACK (edit_select_block_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_all_func"), "activate",
G_CALLBACK (edit_fold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_unfold_all_func"), "activate",
G_CALLBACK (edit_unfold_all_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_fold_current_func"), "activate",
G_CALLBACK (edit_fold_current_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_autocomplete"), "activate",
G_CALLBACK (edit_autocomplete_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "edit_matching_paranthesis"), "activate",
G_CALLBACK (edit_matching_paranthesis_activate), NULL);
//For Format Menu
g_signal_connect (gtk_builder_get_object (builder, "format_inc_indent"), "activate",
G_CALLBACK (format_inc_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_inc_indent")),
"activate", accelgroup, GDK_KEY_bracketright,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_dec_indent"), "activate",
G_CALLBACK (format_dec_indent_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_dec_indent")),
"activate", accelgroup, GDK_KEY_bracketleft,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_comment_out"), "activate",
G_CALLBACK (format_comment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_comment_out")),
"activate", accelgroup, GDK_KEY_3,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_uncomment_out"), "activate",
G_CALLBACK (format_uncomment_out_activate), NULL);
gtk_widget_add_accelerator (GTK_WIDGET (gtk_builder_get_object (builder, "format_uncomment_out")),
"activate", accelgroup, GDK_KEY_4,
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (gtk_builder_get_object (builder, "format_tabify_region"), "activate",
G_CALLBACK (format_tabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_untabify_region"), "activate",
G_CALLBACK (format_untabify_region_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_uppercase"), "activate",
G_CALLBACK (format_uppercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_lowercase"), "activate",
G_CALLBACK (format_lowercase_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "format_strip_spaces"), "activate",
G_CALLBACK (format_strip_spaces_activate), NULL);
//For Search Menu
g_signal_connect (gtk_builder_get_object (builder, "search_find"), "activate",
G_CALLBACK (search_find_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_next"), "activate",
G_CALLBACK (search_find_next_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_prev"), "activate",
G_CALLBACK (search_find_prev_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_replace"), "activate",
G_CALLBACK (search_find_replace_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_selected"), "activate",
G_CALLBACK (search_find_selected_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_in_text"), "activate",
G_CALLBACK (search_find_in_text_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_find_file"), "activate",
G_CALLBACK (search_find_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_replace_file"), "activate",
G_CALLBACK (search_replace_file_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "search_reg_exp"), "activate",
G_CALLBACK (search_reg_exp_activate), NULL);
//For Navigation Menu
g_signal_connect (gtk_builder_get_object (builder, "navigate_back"), "activate",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_forward"), "activate",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_first_line"), "activate",
G_CALLBACK (navigate_first_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_last_line"), "activate",
G_CALLBACK (navigate_last_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_line_history"), "select",
G_CALLBACK (navigate_line_history_select), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_add_bookmark"), "activate",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "naviagate_clear_bookmarks"), "activate",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_prev_bookmarks"), "activate",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_next_bookmark"), "activate",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_bookmarks"), "activate",
G_CALLBACK (navigate_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_line"), "activate",
G_CALLBACK (navigate_go_to_line_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_block_start"), "activate",
G_CALLBACK (navigate_go_to_block_start_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_func_def"), "activate",
G_CALLBACK (navigate_go_to_func_def_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_next_func"), "activate",
G_CALLBACK (navigate_go_to_next_func_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "navigate_go_to_prev_func"), "activate",
G_CALLBACK (navigate_go_to_prev_func_activate), NULL);
//For Project Menu
g_signal_connect (gtk_builder_get_object (builder, "project_new"), "activate",
G_CALLBACK (project_new_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_open"), "activate",
G_CALLBACK (project_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save"), "activate",
G_CALLBACK (project_save_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_as"), "activate",
G_CALLBACK (project_save_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_save_copy_as"), "activate",
G_CALLBACK (project_save_copy_as_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_empty"), "activate",
G_CALLBACK (project_empty_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_close"), "activate",
G_CALLBACK (project_close_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_preferences"), "activate",
G_CALLBACK (project_preferences_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "project_recent"), "activate",
G_CALLBACK (project_recent_activate), NULL);
//For Python Shell Menu
g_signal_connect (gtk_builder_get_object (builder, "python_shell_open"), "activate",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_restart"), "activate",
G_CALLBACK (python_shell_restart_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "python_shell_close"), "activate",
G_CALLBACK (python_shell_close_activate), NULL);
//For Run Menu
g_signal_connect (gtk_builder_get_object (builder, "run_run_script"), "activate",
G_CALLBACK (run_run_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_script"), "activate",
G_CALLBACK (run_debug_script_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_run_project"), "activate",
G_CALLBACK (run_run_project_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "run_debug_project"), "activate",
G_CALLBACK (run_debug_project_activate), NULL);
//For Debug Menu
g_signal_connect (gtk_builder_get_object (builder, "debug_open_pdb_shell"), "activate",
G_CALLBACK (debug_open_pdb_shell_activate), NULL);
//For Tools Menu
g_signal_connect (gtk_builder_get_object (builder, "tools_options"), "activate",
G_CALLBACK (tools_options_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_auto_indent"), "activate",
G_CALLBACK (tools_auto_indent_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "tools_class_browser"), "activate",
G_CALLBACK (tools_class_browser_activate), NULL);
/*************************/
/**Connecting Toolbar's signals**/
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_menu"), "clicked",
G_CALLBACK (toolbar_new_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_file"), "activate",
G_CALLBACK (toolbar_new_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_new_project"), "activate",
G_CALLBACK (toolbar_new_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_menu"), "clicked",
G_CALLBACK (toolbar_open_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_file"), "activate",
G_CALLBACK (toolbar_open_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_project"), "activate",
G_CALLBACK (toolbar_open_proj_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_menu"), "clicked",
G_CALLBACK (toolbar_save_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_file"), "activate",
G_CALLBACK (toolbar_save_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_project"), "activate",
G_CALLBACK (toolbar_save_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as"), "clicked",
G_CALLBACK (toolbar_save_as_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_file"), "activate",
G_CALLBACK (toolbar_save_as_file_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_save_as_project"), "activate",
G_CALLBACK (toolbar_save_as_project_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_undo"), "clicked",
G_CALLBACK (toolbar_undo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_redo"), "clicked",
G_CALLBACK (toolbar_redo_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_cut"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_copy"), "clicked",
G_CALLBACK (toolbar_copy_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_paste"), "clicked",
G_CALLBACK (toolbar_cut_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_delete"), "clicked",
G_CALLBACK (toolbar_delete_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_select_all"), "clicked",
G_CALLBACK (toolbar_select_all_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find"), "clicked",
G_CALLBACK (toolbar_find_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_find_replace"), "clicked",
G_CALLBACK (toolbar_find_replace_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_inc_indent"), "clicked",
G_CALLBACK (toolbar_inc_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_dec_indent"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_line"), "clicked",
G_CALLBACK (navigate_forward_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_line"), "clicked",
G_CALLBACK (navigate_back_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_add_bookmark"), "clicked",
G_CALLBACK (naviagate_add_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_next_bookmark"), "clicked",
G_CALLBACK (navigate_next_bookmark_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_prev_bookmark"), "clicked",
G_CALLBACK (navigate_prev_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_clear_bookmark"), "clicked",
G_CALLBACK (naviagate_clear_bookmarks_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_run"), "clicked",
G_CALLBACK (toolbar_run), NULL);
/*g_signal_connect (gtk_builder_get_object (builder, "toolbar_debug"), "clicked",
G_CALLBACK (toolbar_dec_indent_clicked), NULL); */
g_signal_connect (gtk_builder_get_object (builder, "toolbar_open_shell"), "clicked",
G_CALLBACK (python_shell_open_activate), NULL);
g_signal_connect (gtk_builder_get_object (builder, "toolbar_options"), "clicked",
G_CALLBACK (tools_options_activate), NULL);
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_add_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksadd.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_next_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksnext.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_prev_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksprev.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_clear_bookmark")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/bookmarksclear.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_debug")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/debug.png",NULL)));
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (gtk_builder_get_object (builder, "toolbar_open_shell")),
gtk_image_new_from_pixbuf(gdk_pixbuf_new_from_file("./icons/python_shell.png",NULL)));
/*************************/
line_history_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (builder, "navigate_line_history")),
line_history_menu);
GtkRecentFilter *py_recent_filter = gtk_recent_filter_new ();
gtk_recent_filter_set_name (py_recent_filter, "Python Files");
gtk_recent_filter_add_pattern (py_recent_filter, "*.py");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (gtk_builder_get_object (builder, "recentchoosermenu")),
py_recent_filter);
/* Connecting window's signals and events */
g_signal_connect (window, "delete-event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (main_window_destroy), NULL);
/********************************/
/*Other global variables*/
search_text = NULL;
bookmark_array= NULL;
bookmark_array_size = 0;
current_bookmark_index = -1;
/******************/
/*Initialize Regular Expressions*/
regex_class = g_regex_new ("[ \\ \\t]*\\bclass\\b\\s*\\w+\\s*\\(*.*\\)*:", 0, 0, NULL);
regex_func = g_regex_new ("[ \\ \\t]*def\\s+[\\w\\d_]+\\s*\\(.+\\)\\:", 0, 0, NULL);
/*Regex if you don't want to search imports with in indentation*/
/*regex_import = g_regex_new ("^import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^import\\s+[\\w\\d_\\.]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);*/
regex_from_import = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+", 0, 0, NULL);
regex_from_import_as = g_regex_new ("^from\\s+[\\w\\d_\\.]+\\s+import\\s+[\\w\\d_]+as\\s+[\\w\\d_]", 0, 0, NULL);
regex_global_var = g_regex_new ("^[\\w\\d_]+\\s*=\\s*[\\w\\d_]+\\s*\\(.+\\)", 0, 0, NULL);
regex_static_var = g_regex_new ("^\\s*[\\w\\d_]+\\s*=.+", 0, 0, NULL);
regex_word = g_regex_new ("[self]*[\\w\\d_\\.]+$", 0, 0, NULL);
regex_local_var = g_regex_new ("^\\s*[\\w\\d_\\.]+\\s*=.+", 0, 0, NULL);
regex_self_var = g_regex_new ("^\\s+self\\.[\\w\\d_]+\\s*=.+", 0, 0, NULL);
/*Regex if you want to search imports with in indentation*/
regex_import = g_regex_new ("^\\s*import\\s+[\\w\\d_\\.]+", 0, 0, NULL);
regex_import_as = g_regex_new ("^\\s*import\\s+[\\w\\d_]+\\s+as\\s+[\\w\\d_]+", 0, 0, NULL);
/***********************/
async_queue = g_async_queue_new ();
//Creating code_widget_array
//code_widget_array = g_malloc0 (1*sizeof (CodeWidget *));
//code_widget_array [0] = codewidget_new ();
code_widget_array_size = 0;
notebook = gtk_notebook_new ();
g_object_ref (notebook);
//gtk_notebook_append_page (GTK_NOTEBOOK (notebook), code_widget_array [0]->vbox,
// gtk_label_new ("New File"));
/*If bash is not loaded*/
if (!bash_loaded)
{
gchar *msg = g_strdup_printf ("Cannot run Python Shell (%s)", error->message);
gtk_statusbar_push (GTK_STATUSBAR (status_bar), 0, msg);
g_free (msg);
g_error_free (error);
}
/****************/
GtkSettings *settings = gtk_settings_get_default ();
g_object_set (settings, "gtk-application-prefer-dark-theme", TRUE, NULL);
gtk_window_maximize (GTK_WINDOW (window));
gtk_widget_show_all (GTK_WIDGET (window));
gtk_main ();
return 0;
}
static void
delegate_selection_changed (GtkRecentChooser *receiver,
gpointer user_data)
{
_gtk_recent_chooser_selection_changed (GTK_RECENT_CHOOSER (user_data));
}
/**
* Print the uri of the selected item in a recent file widget.
* @param widget recent file menu to print information about
*/
void mk_print_GtkRecentChooserWidget_info(GtkRecentChooserWidget* widget)
{
mk_print_GtkRecentChooser_info(GTK_RECENT_CHOOSER(widget));
}
/**
* Print the uri of the selected item in a recent file menu.
* @param menu recent file menu to print information about
*/
void mk_print_GtkRecentChooserMenu_info(GtkRecentChooserMenu* menu)
{
mk_print_GtkRecentChooser_info(GTK_RECENT_CHOOSER(menu));
}
void gtkui_create() {
// Create the GTK+ Window
gtkui_image_paths();
GdkPixbuf *icon = gdk_pixbuf_new_from_file(iconpath, NULL);
char title[24];
snprintf(title, sizeof(title), "Nestopia UE %s", VERSION);
gtkwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon(GTK_WINDOW(gtkwindow), icon);
gtk_window_set_title(GTK_WINDOW(gtkwindow), title);
gtk_window_set_resizable(GTK_WINDOW(gtkwindow), FALSE);
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(gtkwindow), box);
// Define the menubar and menus
GtkWidget *menubar = gtk_menu_bar_new();
// Define the File menu
GtkWidget *filemenu = gtk_menu_new();
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
GtkWidget *open = gtk_image_menu_item_new_from_stock(GTK_STOCK_OPEN, NULL);
GtkWidget *recent = gtk_image_menu_item_new_with_label("Open Recent");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(recent), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
GtkWidget *sep_open = gtk_separator_menu_item_new();
GtkWidget *stateload = gtk_image_menu_item_new_with_mnemonic("_Load State...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(stateload), gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_MENU));
GtkWidget *statesave = gtk_image_menu_item_new_with_mnemonic("_Save State...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(statesave), gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU));
GtkWidget *quickload = gtk_image_menu_item_new_with_label("Quick Load");
GtkWidget *qloadmenu = gtk_menu_new();
GtkWidget *qload0 = gtk_image_menu_item_new_with_label("0");
GtkWidget *qload1 = gtk_image_menu_item_new_with_label("1");
GtkWidget *qload2 = gtk_image_menu_item_new_with_label("2");
GtkWidget *qload3 = gtk_image_menu_item_new_with_label("3");
GtkWidget *qload4 = gtk_image_menu_item_new_with_label("4");
GtkWidget *quicksave = gtk_image_menu_item_new_with_label("Quick Save");
GtkWidget *qsavemenu = gtk_menu_new();
GtkWidget *qsave0 = gtk_image_menu_item_new_with_label("0");
GtkWidget *qsave1 = gtk_image_menu_item_new_with_label("1");
GtkWidget *qsave2 = gtk_image_menu_item_new_with_label("2");
GtkWidget *qsave3 = gtk_image_menu_item_new_with_label("3");
GtkWidget *qsave4 = gtk_image_menu_item_new_with_label("4");
GtkWidget *sep_state = gtk_separator_menu_item_new();
GtkWidget *screenshot = gtk_image_menu_item_new_with_mnemonic("S_creenshot...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(screenshot), gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU));
GtkWidget *sep_screenshot = gtk_separator_menu_item_new();
GtkWidget *movieload = gtk_image_menu_item_new_with_label("Load Movie...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(movieload), gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU));
GtkWidget *moviesave = gtk_image_menu_item_new_with_label("Record Movie...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviesave), gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD, GTK_ICON_SIZE_MENU));
GtkWidget *moviestop = gtk_image_menu_item_new_with_label("Stop Movie");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(moviestop), gtk_image_new_from_stock(GTK_STOCK_MEDIA_STOP, GTK_ICON_SIZE_MENU));
GtkWidget *sep_movie = gtk_separator_menu_item_new();
GtkWidget *quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
// Set up the recently used items
GtkWidget *recent_items = gtk_recent_chooser_menu_new();
GtkRecentFilter *recent_filter = gtk_recent_filter_new();
gtk_recent_filter_add_pattern(recent_filter, "*.nes");
gtk_recent_filter_add_pattern(recent_filter, "*.fds");
gtk_recent_filter_add_pattern(recent_filter, "*.unf");
gtk_recent_filter_add_pattern(recent_filter, "*.unif");
gtk_recent_filter_add_pattern(recent_filter, "*.nsf");
gtk_recent_filter_add_pattern(recent_filter, "*.zip");
gtk_recent_filter_add_pattern(recent_filter, "*.7z");
gtk_recent_filter_add_pattern(recent_filter, "*.txz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.xz");
gtk_recent_filter_add_pattern(recent_filter, "*.xz");
gtk_recent_filter_add_pattern(recent_filter, "*.tgz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.gz");
gtk_recent_filter_add_pattern(recent_filter, "*.gz");
gtk_recent_filter_add_pattern(recent_filter, "*.tbz");
gtk_recent_filter_add_pattern(recent_filter, "*.tar.bz2");
gtk_recent_filter_add_pattern(recent_filter, "*.bz2");
gtk_recent_chooser_add_filter(GTK_RECENT_CHOOSER(recent_items), recent_filter);
// Populate the File menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), open);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), recent);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(recent), recent_items);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_open);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), stateload);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), statesave);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quickload);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(quickload), qloadmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload0);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload1);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload2);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload3);
gtk_menu_shell_append(GTK_MENU_SHELL(qloadmenu), qload4);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quicksave);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(quicksave), qsavemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave0);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave1);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave2);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave3);
gtk_menu_shell_append(GTK_MENU_SHELL(qsavemenu), qsave4);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_state);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), screenshot);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_screenshot);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), movieload);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviesave);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), moviestop);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), sep_movie);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
// Define the Emulator menu
GtkWidget *emulatormenu = gtk_menu_new();
GtkWidget *emu = gtk_menu_item_new_with_mnemonic("_Emulator");
GtkWidget *cont = gtk_image_menu_item_new_with_mnemonic("C_ontinue");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cont), gtk_image_new_from_stock(GTK_STOCK_MEDIA_PLAY, GTK_ICON_SIZE_MENU));
GtkWidget *pause = gtk_image_menu_item_new_from_stock(GTK_STOCK_MEDIA_PAUSE, NULL);
GtkWidget *sep_pause = gtk_separator_menu_item_new();
GtkWidget *resetsoft = gtk_image_menu_item_new_with_mnemonic("_Reset (Soft)");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resetsoft), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
GtkWidget *resethard = gtk_image_menu_item_new_with_mnemonic("Reset (_Hard)");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(resethard), gtk_image_new_from_stock(GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU));
GtkWidget *sep_reset = gtk_separator_menu_item_new();
GtkWidget *fullscreen = gtk_image_menu_item_new_from_stock(GTK_STOCK_FULLSCREEN, NULL);
GtkWidget *sep_fullscreen = gtk_separator_menu_item_new();
GtkWidget *diskflip = gtk_image_menu_item_new_with_mnemonic("Flip FDS _Disk");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskflip), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
GtkWidget *diskswitch = gtk_image_menu_item_new_with_mnemonic("_Switch FDS Disk");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(diskswitch), gtk_image_new_from_stock(GTK_STOCK_FLOPPY, GTK_ICON_SIZE_MENU));
GtkWidget *sep_disk = gtk_separator_menu_item_new();
GtkWidget *cheats = gtk_image_menu_item_new_with_mnemonic("Ch_eats...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(cheats), gtk_image_new_from_stock(GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_MENU));
GtkWidget *sep_cheats = gtk_separator_menu_item_new();
GtkWidget *configuration = gtk_image_menu_item_new_with_mnemonic("_Configuration...");
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(configuration), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU));
// Populate the Emulator menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(emu), emulatormenu);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cont);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), pause);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_pause);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resetsoft);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), resethard);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), fullscreen);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_fullscreen);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskflip);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), diskswitch);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_disk);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), cheats);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), sep_cheats);
gtk_menu_shell_append(GTK_MENU_SHELL(emulatormenu), configuration);
// Define the Help menu
GtkWidget *helpmenu = gtk_menu_new();
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
GtkWidget *about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
// Populate the Help menu
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
// Put the menus into the menubar
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), emu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
// Create the DrawingArea/OpenGL context
drawingarea = gtk_drawing_area_new();
//gtk_widget_set_double_buffered(drawingarea, FALSE);
g_object_set_data(G_OBJECT(gtkwindow), "area", drawingarea);
// Set the Drawing Area to be the size of the game output
gtk_widget_set_size_request(drawingarea, rendersize.w, rendersize.h);
// Create the statusbar
GtkWidget *statusbar = gtk_statusbar_new();
// Pack the box with the menubar, drawingarea, and statusbar
gtk_box_pack_start(GTK_BOX(box), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), drawingarea, TRUE, TRUE, 0);
//gtk_box_pack_start(GTK_BOX(box), statusbar, FALSE, FALSE, 0);
// Make it dark if there's a dark theme
GtkSettings *gtksettings = gtk_settings_get_default();
g_object_set(G_OBJECT(gtksettings), "gtk-application-prefer-dark-theme", TRUE, NULL);
// Set up the Drag and Drop target
GtkTargetEntry target_entry[1];
target_entry[0].target = (gchar*)"text/uri-list";
target_entry[0].flags = 0;
target_entry[0].info = 0;
gtk_drag_dest_set(drawingarea, (GtkDestDefaults)(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP),
target_entry, sizeof(target_entry) / sizeof(GtkTargetEntry), (GdkDragAction)(GDK_ACTION_MOVE | GDK_ACTION_COPY));
// Connect the signals
g_signal_connect(G_OBJECT(drawingarea), "drag-data-received",
G_CALLBACK(gtkui_drag_data), NULL);
g_signal_connect(G_OBJECT(gtkwindow), "delete_event",
G_CALLBACK(nst_schedule_quit), NULL);
// File menu
g_signal_connect(G_OBJECT(open), "activate",
G_CALLBACK(gtkui_file_open), NULL);
g_signal_connect(G_OBJECT(recent_items), "item-activated",
G_CALLBACK(gtkui_open_recent), NULL);
g_signal_connect(G_OBJECT(stateload), "activate",
G_CALLBACK(gtkui_state_load), NULL);
g_signal_connect(G_OBJECT(statesave), "activate",
G_CALLBACK(gtkui_state_save), NULL);
g_signal_connect(G_OBJECT(qload0), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(0));
g_signal_connect(G_OBJECT(qload1), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(1));
g_signal_connect(G_OBJECT(qload2), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(2));
g_signal_connect(G_OBJECT(qload3), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(3));
g_signal_connect(G_OBJECT(qload4), "activate",
G_CALLBACK(gtkui_state_quickload), gpointer(4));
g_signal_connect(G_OBJECT(qsave0), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(0));
g_signal_connect(G_OBJECT(qsave1), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(1));
g_signal_connect(G_OBJECT(qsave2), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(2));
g_signal_connect(G_OBJECT(qsave3), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(3));
g_signal_connect(G_OBJECT(qsave4), "activate",
G_CALLBACK(gtkui_state_quicksave), gpointer(4));
g_signal_connect(G_OBJECT(statesave), "activate",
G_CALLBACK(gtkui_state_save), NULL);
g_signal_connect(G_OBJECT(screenshot), "activate",
G_CALLBACK(gtkui_screenshot_save), NULL);
g_signal_connect(G_OBJECT(moviesave), "activate",
G_CALLBACK(gtkui_movie_save), NULL);
g_signal_connect(G_OBJECT(movieload), "activate",
G_CALLBACK(gtkui_movie_load), NULL);
g_signal_connect(G_OBJECT(moviestop), "activate",
G_CALLBACK(gtkui_movie_stop), NULL);
g_signal_connect(G_OBJECT(quit), "activate",
G_CALLBACK(nst_schedule_quit), NULL);
// Emulator menu
g_signal_connect(G_OBJECT(cont), "activate",
G_CALLBACK(nst_play), NULL);
g_signal_connect(G_OBJECT(pause), "activate",
G_CALLBACK(nst_pause), NULL);
g_signal_connect(G_OBJECT(resetsoft), "activate",
G_CALLBACK(gtkui_cb_reset), gpointer(0));
g_signal_connect(G_OBJECT(resethard), "activate",
G_CALLBACK(gtkui_cb_reset), gpointer(1));
g_signal_connect(G_OBJECT(fullscreen), "activate",
G_CALLBACK(video_toggle_fullscreen), NULL);
g_signal_connect(G_OBJECT(diskflip), "activate",
G_CALLBACK(nst_flip_disk), NULL);
g_signal_connect(G_OBJECT(diskswitch), "activate",
G_CALLBACK(nst_switch_disk), NULL);
g_signal_connect(G_OBJECT(cheats), "activate",
G_CALLBACK(gtkui_cheats), NULL);
g_signal_connect(G_OBJECT(configuration), "activate",
G_CALLBACK(gtkui_config), NULL);
// Help menu
g_signal_connect(G_OBJECT(about), "activate",
G_CALLBACK(gtkui_about), NULL);
// Key translation
g_signal_connect(G_OBJECT(gtkwindow), "key-press-event",
G_CALLBACK(gtkui_cb_convert_key), NULL);
g_signal_connect(G_OBJECT(gtkwindow), "key-release-event",
G_CALLBACK(gtkui_cb_convert_key), NULL);
// Mouse translation
gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_PRESS_MASK);
gtk_widget_add_events(GTK_WIDGET(drawingarea), GDK_BUTTON_RELEASE_MASK);
g_signal_connect(G_OBJECT(drawingarea), "button-press-event",
G_CALLBACK(gtkui_cb_convert_mouse), NULL);
g_signal_connect(G_OBJECT(drawingarea), "button-release-event",
G_CALLBACK(gtkui_cb_convert_mouse), NULL);
gtk_widget_show_all(gtkwindow);
}
void
panel_recent_append_documents_menu (GtkWidget *top_menu,
GtkRecentManager *manager)
{
GtkWidget *recent_menu;
GtkWidget *menu_item;
int size;
menu_item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (menu_item,
panel_menu_icon_get_size (),
PANEL_ICON_RECENT,
NULL, NULL,
_("Recent Documents"));
recent_menu = gtk_recent_chooser_menu_new_for_manager (manager);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), recent_menu);
g_signal_connect (G_OBJECT (recent_menu), "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (top_menu), menu_item);
gtk_widget_show_all (menu_item);
gtk_recent_chooser_set_local_only (GTK_RECENT_CHOOSER (recent_menu),
FALSE);
gtk_recent_chooser_set_show_tips (GTK_RECENT_CHOOSER (recent_menu),
TRUE);
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recent_menu),
GTK_RECENT_SORT_MRU);
g_signal_connect (GTK_RECENT_CHOOSER (recent_menu),
"item-activated",
G_CALLBACK (recent_documents_activate_cb),
NULL);
//FIXME this is not possible with GtkRecent...: egg_recent_view_gtk_set_icon_size (view, panel_menu_icon_get_size ());
g_signal_connect_object (manager, "changed",
G_CALLBACK (panel_recent_manager_changed_cb),
menu_item, 0);
size = 0;
g_object_get (manager, "size", &size, NULL);
gtk_widget_set_sensitive (menu_item, size > 0);
add_menu_separator (recent_menu);
menu_item = gtk_image_menu_item_new ();
setup_menu_item_with_icon (menu_item,
panel_menu_icon_get_size (),
NULL,
GTK_STOCK_CLEAR, NULL,
_("Clear Recent Documents..."));
panel_util_set_tooltip_text (menu_item,
_("Clear all items from the recent documents list"));
gtk_menu_shell_append (GTK_MENU_SHELL (recent_menu), menu_item);
g_signal_connect (menu_item, "activate",
G_CALLBACK (recent_documents_clear_cb),
manager);
}
static gboolean
create_window(void)
{
GError *error = NULL;
builder = gtk_builder_new();
if( !gtk_builder_add_from_file(builder, PACKAGE_DATA_DIR "/chimara.ui", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !gtk_builder_add_from_file(builder, PACKAGE_SRC_DIR "/chimara.ui", &error) ) {
#endif /* DEBUG */
return FALSE;
#ifdef DEBUG
}
#endif /* DEBUG */
}
window = GTK_WIDGET(load_object("chimara"));
aboutwindow = GTK_WIDGET(load_object("aboutwindow"));
prefswindow = GTK_WIDGET(load_object("prefswindow"));
GtkActionGroup *actiongroup = GTK_ACTION_GROUP(load_object("actiongroup"));
/* Set the default value of the "View/Toolbar" menu item upon creation of a
new window to the "show-toolbar-default" setting, but bind the setting
one-way only - we don't want toolbars to disappear suddenly */
GtkToggleAction *toolbar_action = GTK_TOGGLE_ACTION(load_object("toolbar"));
gtk_toggle_action_set_active(toolbar_action, g_settings_get_boolean(state_settings, "show-toolbar-default"));
g_settings_bind(state_settings, "show-toolbar-default", toolbar_action, "active", G_SETTINGS_BIND_SET);
const gchar **ptr;
GtkRecentFilter *filter = gtk_recent_filter_new();
/* TODO: Use mimetypes and construct the filter dynamically depending on
what plugins are installed */
const gchar *patterns[] = {
"*.z[1-8]", "*.[zg]lb", "*.[zg]blorb", "*.ulx", "*.blb", "*.blorb", NULL
};
for(ptr = patterns; *ptr; ptr++)
gtk_recent_filter_add_pattern(filter, *ptr);
GtkRecentChooser *recent = GTK_RECENT_CHOOSER(load_object("recent"));
gtk_recent_chooser_add_filter(recent, filter);
uimanager = gtk_ui_manager_new();
if( !gtk_ui_manager_add_ui_from_file(uimanager, PACKAGE_DATA_DIR "/chimara.menus", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !gtk_ui_manager_add_ui_from_file(uimanager, PACKAGE_SRC_DIR "/chimara.menus", &error) )
#endif /* DEBUG */
return FALSE;
}
glk = chimara_if_new();
g_object_set(glk,
"ignore-errors", TRUE,
/*"interpreter-number", CHIMARA_IF_ZMACHINE_TANDY_COLOR,*/
NULL);
if( !chimara_glk_set_css_from_file(CHIMARA_GLK(glk), PACKAGE_DATA_DIR "/style.css", &error) ) {
#ifdef DEBUG
g_error_free(error);
error = NULL;
if( !chimara_glk_set_css_from_file(CHIMARA_GLK(glk), PACKAGE_SRC_DIR "/style.css", &error) )
#endif /* DEBUG */
return FALSE;
}
/* DON'T UNCOMMENT THIS your eyes will burn
but it is a good test of programmatically altering just one style
chimara_glk_set_css_from_string(CHIMARA_GLK(glk),
"buffer { font-family: 'Comic Sans MS'; }");*/
GtkBox *vbox = GTK_BOX( gtk_builder_get_object(builder, "vbox") );
if(vbox == NULL)
return FALSE;
gtk_ui_manager_insert_action_group(uimanager, actiongroup, 0);
GtkWidget *menubar = gtk_ui_manager_get_widget(uimanager, "/menubar");
toolbar = gtk_ui_manager_get_widget(uimanager, "/toolbar");
gtk_widget_set_no_show_all(toolbar, TRUE);
if(gtk_toggle_action_get_active(toolbar_action))
gtk_widget_show(toolbar);
else
gtk_widget_hide(toolbar);
/* Connect the accelerators */
GtkAccelGroup *accels = gtk_ui_manager_get_accel_group(uimanager);
gtk_window_add_accel_group(GTK_WINDOW(window), accels);
gtk_box_pack_end(vbox, glk, TRUE, TRUE, 0);
gtk_box_pack_start(vbox, menubar, FALSE, FALSE, 0);
gtk_box_pack_start(vbox, toolbar, FALSE, FALSE, 0);
gtk_builder_connect_signals(builder, glk);
g_signal_connect(glk, "notify::program-name", G_CALLBACK(change_window_title), window);
g_signal_connect(glk, "notify::story-name", G_CALLBACK(change_window_title), window);
/* Create preferences window */
preferences_create(CHIMARA_GLK(glk));
return TRUE;
}
static void
delegate_item_activated (GtkRecentChooser *receiver,
gpointer user_data)
{
_gtk_recent_chooser_item_activated (GTK_RECENT_CHOOSER (user_data));
}
/**
* Print the uri of the selected item in a recent file dialog.
* @param dialog recent file dialog to print information about
*/
void mk_print_GtkRecentChooserDialog_info(GtkRecentChooserDialog* dialog)
{
mk_print_GtkRecentChooser_info(GTK_RECENT_CHOOSER(dialog));
}
GtkRecentChooser* cast_GtkRecentChooser(GtkWidget* widget) {
return GTK_RECENT_CHOOSER(widget);
}
