static void
gm_window_init (GTypeInstance *instance,
gpointer g_class)
{
GmWindow *self = NULL;
(void) g_class; /* -Wextra */
self = GM_WINDOW (instance);
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_WINDOW_TYPE, GmWindowPrivate);
self->priv->key = g_strdup ("");
self->priv->hide_on_esc = TRUE;
self->priv->hide_on_delete = TRUE;
self->priv->accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
gtk_accel_group_connect (self->priv->accel, GDK_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
g_cclosure_new_swap (G_CALLBACK (gtk_widget_hide), (gpointer) self, NULL));
g_signal_connect (G_OBJECT (self), "delete_event",
G_CALLBACK (gm_window_delete_event), NULL);
g_signal_connect (G_OBJECT (self), "show",
G_CALLBACK (gm_window_show), self);
g_signal_connect (G_OBJECT (self), "hide",
G_CALLBACK (gm_window_hide), self);
g_signal_connect (G_OBJECT (self), "configure-event",
G_CALLBACK (gm_window_configure_event), self);
}
static void
gm_window_init (GmWindow* self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
self->priv->settings = NULL;
self->priv->key = g_strdup ("");
self->priv->hide_on_esc = TRUE;
self->priv->hide_on_delete = TRUE;
self->priv->state_restored = FALSE;
self->priv->accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
gtk_accel_group_connect (self->priv->accel, GDK_KEY_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
g_cclosure_new_swap (G_CALLBACK (gtk_widget_hide), (gpointer) self, NULL));
g_signal_connect (self, "delete-event",
G_CALLBACK (gm_window_delete_event_cb), NULL);
g_signal_connect (self, "show",
G_CALLBACK (window_show_cb), self);
g_signal_connect (self, "realize",
G_CALLBACK (window_realize_cb), self);
g_signal_connect (self, "hide",
G_CALLBACK (window_hide_cb), self);
g_signal_connect (self, "configure-event",
G_CALLBACK (gm_window_configure_event), self);
}
static void
gis_finished_page_constructed (GObject *object)
{
GisFinishedPage *page = GIS_FINISHED_PAGE (object);
GisFinishedPagePrivate *priv = gis_finished_page_get_instance_private (page);
g_autoptr(GClosure) closure = NULL;
G_OBJECT_CLASS (gis_finished_page_parent_class)->constructed (object);
gis_page_set_complete (GIS_PAGE (page), TRUE);
g_signal_connect (priv->restart_button, "clicked", G_CALLBACK (reboot_cb), page);
priv->gedit = g_desktop_app_info_new ("org.gnome.gedit.desktop");
if (priv->gedit != NULL)
g_signal_connect (priv->diagnostics_label, "activate-link",
G_CALLBACK (diagnostics_label_activate_link_cb), page);
/* Use Ctrl+U to write unattended config */
priv->accel_group = gtk_accel_group_new ();
closure = g_cclosure_new_swap (G_CALLBACK (write_unattended_config_cb), page, NULL);
gtk_accel_group_connect (priv->accel_group, GDK_KEY_u, GDK_CONTROL_MASK, 0, closure);
gtk_widget_show (GTK_WIDGET (page));
}
CALLER_OWN GClosure *owl_variable_make_closure(owl_variable *v,
GCallback fn,
GClosureMarshal marshal) {
GClosure *closure = g_cclosure_new_swap(fn, v, NULL);
g_closure_set_marshal(closure,marshal);
g_closure_ref(closure);
g_closure_sink(closure);
return closure;
}
static void _add_hotkey (const gchar *hotkey, GtkAccelGroup *accelgroup,
GCallback callback, gpointer user_data) {
GClosure *keycallback;
guint accelkey;
GdkModifierType accelmod;
gtk_accelerator_parse (hotkey, &accelkey, &accelmod);
keycallback = g_cclosure_new_swap (callback, user_data, NULL);
gtk_accel_group_connect(accelgroup, accelkey, accelmod, 0, keycallback);
g_closure_unref(keycallback);
}
gulong connect_to_signal(void* obj, gchar* name, gint64 id) {
gint64 *pgint64 = (gint64*)malloc(sizeof(gint64));
*pgint64 = id;
GClosure* c = g_cclosure_new_swap(G_CALLBACK(func_handler),
(gpointer)pgint64,
destroy_id);
g_closure_set_marshal(c, simple_go_marshal);
gulong handler_id = g_signal_connect_closure((gpointer)obj,
name,
c,
TRUE);
return handler_id;
}
static void
gm_window_set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *spec)
{
GmWindow *self = NULL;
const gchar *str = NULL;
self = GM_WINDOW (obj);
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
switch (prop_id) {
case GM_WINDOW_KEY:
if (self->priv->key)
g_free (self->priv->key);
str = g_value_get_string (value);
self->priv->key = g_strdup (str ? str : "");
if (self->priv->settings)
g_clear_object (&self->priv->settings);
self->priv->settings = g_settings_new (self->priv->key);
break;
case GM_HIDE_ON_ESC:
self->priv->hide_on_esc = g_value_get_boolean (value);
if (!self->priv->hide_on_esc)
gtk_accel_group_disconnect_key (self->priv->accel, GDK_KEY_Escape, (GdkModifierType) 0);
else
gtk_accel_group_connect (self->priv->accel, GDK_KEY_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
g_cclosure_new_swap (G_CALLBACK (gtk_widget_hide), (gpointer) self, NULL));
break;
case GM_HIDE_ON_DELETE:
self->priv->hide_on_delete = g_value_get_boolean (value);
break;
case GM_STAY_ON_TOP:
self->priv->stay_on_top = g_value_get_boolean (value);
gtk_window_set_keep_above (GTK_WINDOW (self), self->priv->stay_on_top);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, spec);
break;
}
}
void add_shortcuts(void)
{
long i = 0;
guint acc_key;
GdkModifierType mod;
if(macros == NULL)
return;
while(macros[i].shortcut != NULL)
{
macros[i].closure = g_cclosure_new_swap(G_CALLBACK(shortcut_callback), (gpointer)i, NULL);
gtk_accelerator_parse(macros[i].shortcut, &acc_key, &mod);
if(acc_key != 0)
gtk_accel_group_connect(shortcuts, acc_key, mod, GTK_ACCEL_MASK, macros[i].closure);
i++;
}
}
/* Takes (method_name, handler_func) pairs and connects the handlers to the
* signals on skeleton, with object as the user_data, but swapped so it comes
* first in the argument list, and handling the return value automatically.
*/
void
_nm_dbus_bind_methods (gpointer object, gpointer skeleton, ...)
{
va_list ap;
const char *method_name;
char *signal_name;
GCallback handler;
GClosure *closure;
va_start (ap, skeleton);
while ( (method_name = va_arg (ap, const char *))
&& (handler = va_arg (ap, GCallback))) {
signal_name = signal_name_from_method_name (method_name);
closure = g_cclosure_new_swap (handler, object, NULL);
g_closure_set_meta_marshal (closure, NULL, _nm_dbus_method_meta_marshal);
g_signal_connect_closure (skeleton, signal_name, closure, FALSE);
g_free (signal_name);
}
va_end (ap);
}
bool cterm_register_accel(CTerm* term, const char* keyspec, GCallback callback_func) {
guint key;
GdkModifierType mod;
GClosure* closure;
/* Empty key spec */
if(keyspec[0] == '\0') {
return true;
}
if(term->config.keys == NULL) {
term->config.keys = gtk_accel_group_new();
}
gtk_accelerator_parse(keyspec, &key, &mod);
if(key == 0 || mod == 0) {
return false;
}
closure = g_cclosure_new_swap(callback_func, (gpointer)term, NULL);
gtk_accel_group_connect(term->config.keys, key, mod, GTK_ACCEL_LOCKED, closure);
return true;
}
GtkWidget*
chat_window_new (Ekiga::ServiceCore& core)
{
ChatWindow* self = NULL;
GtkAccelGroup *accel = NULL;
self = (ChatWindow*)g_object_new (CHAT_WINDOW_TYPE,
"hide_on_esc", FALSE,
NULL);
self->priv = new ChatWindowPrivate;
self->priv->notification_core =
core.get<Ekiga::NotificationCore>("notification-core");
self->priv->notebook = gtk_notebook_new ();
gtk_container_add (GTK_CONTAINER (self), self->priv->notebook);
gtk_widget_show (self->priv->notebook);
accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), accel);
gtk_accel_group_connect (accel, GDK_KEY_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
g_cclosure_new_swap (G_CALLBACK (on_escaped), (gpointer) self, NULL));
g_object_unref (accel);
g_signal_connect (self, "focus-in-event",
G_CALLBACK (on_focus_in_event), self);
g_signal_connect (self->priv->notebook, "switch-page",
G_CALLBACK (on_switch_page), self);
boost::shared_ptr<Ekiga::ChatCore> chat_core =
core.get<Ekiga::ChatCore> ("chat-core");
self->priv->connections.add (chat_core->dialect_added.connect (boost::bind (&on_dialect_added, self, _1)));
self->priv->connections.add (chat_core->questions.connect (boost::bind (&on_handle_questions, self, _1)));
chat_core->visit_dialects (boost::bind (&on_dialect_added, self, _1));
return (GtkWidget*)self;
}
/*
* create a generic query box without any entry widget
*/
static QueryBox *
create_query_box (const gchar *title,
GtkWidget *parent,
GimpHelpFunc help_func,
const gchar *help_id,
GCallback response_callback,
const gchar *icon_name,
const gchar *message,
const gchar *ok_button,
const gchar *cancel_button,
GObject *object,
const gchar *signal,
GCallback callback,
gpointer callback_data)
{
QueryBox *query_box;
GtkWidget *hbox = NULL;
GtkWidget *label;
/* make sure the object / signal passed are valid
*/
g_return_val_if_fail (parent == NULL || GTK_IS_WIDGET (parent), NULL);
g_return_val_if_fail (object == NULL || G_IS_OBJECT (object), NULL);
g_return_val_if_fail (object == NULL || signal != NULL, NULL);
query_box = g_slice_new0 (QueryBox);
query_box->qbox = gimp_dialog_new (title, "gimp-query-box",
parent, 0,
help_func, help_id,
cancel_button, GTK_RESPONSE_CANCEL,
ok_button, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (query_box->qbox),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
query_box->response_handler =
g_signal_connect (query_box->qbox, "response",
G_CALLBACK (response_callback),
query_box);
g_signal_connect (query_box->qbox, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&query_box->qbox);
/* if we are associated with an object, connect to the provided signal
*/
if (object)
{
GClosure *closure;
closure = g_cclosure_new_swap (G_CALLBACK (query_box_cancel_callback),
query_box, NULL);
g_object_watch_closure (G_OBJECT (query_box->qbox), closure);
g_signal_connect_closure (object, signal, closure, FALSE);
}
if (icon_name)
{
GtkWidget *content_area;
GtkWidget *image;
content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 12);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_widget_show (image);
}
query_box->vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
g_object_set_data (G_OBJECT (query_box->qbox), "gimp-query-box-vbox",
query_box->vbox);
if (hbox)
{
gtk_box_pack_start (GTK_BOX (hbox), query_box->vbox, FALSE, FALSE, 0);
}
else
{
GtkWidget *content_area;
content_area = gtk_dialog_get_content_area (GTK_DIALOG (query_box->qbox));
gtk_container_set_border_width (GTK_CONTAINER (query_box->vbox), 12);
gtk_box_pack_start (GTK_BOX (content_area), query_box->vbox,
TRUE, TRUE, 0);
}
gtk_widget_show (query_box->vbox);
if (message)
{
label = gtk_label_new (message);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (query_box->vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
}
query_box->entry = NULL;
query_box->object = object;
query_box->callback = callback;
query_box->callback_data = callback_data;
return query_box;
}
static void about_create(void)
{
GtkWidget *vbox1;
GtkWidget *image;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *button;
GtkWidget *scrolledwin;
GtkWidget *notebook;
GtkWidget *table;
char *markup;
GtkWidget *confirm_area;
GtkWidget *close_button;
static GdkGeometry geometry;
stats_text_buffer = NULL;
window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "about");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_title(GTK_WINDOW(window), _("About Claws Mail"));
gtk_container_set_border_width(GTK_CONTAINER(window), 8);
gtk_widget_set_size_request(window, -1, -1);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(about_size_allocate_cb), NULL);
g_signal_connect(G_OBJECT(window), "size_allocate",
G_CALLBACK(about_size_allocate_cb), NULL);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(gtk_widget_hide_on_delete), NULL);
g_signal_connect(G_OBJECT(window), "key_press_event",
G_CALLBACK(key_pressed), NULL);
if (!geometry.min_width) {
geometry.min_width = 450;
geometry.min_height = 500;
}
gtk_window_set_geometry_hints(GTK_WINDOW(window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_window_set_default_size(GTK_WINDOW(window), prefs_common.aboutwin_width,
prefs_common.aboutwin_height);
gtk_widget_realize(window);
vbox1 = gtk_vbox_new(FALSE, 8);
gtk_container_add(GTK_CONTAINER(window), vbox1);
table = gtk_table_new (2, 1, FALSE);
gtk_box_pack_start(GTK_BOX(vbox1), table,
FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 8);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
image = stock_pixmap_widget(window, STOCK_PIXMAP_CLAWS_MAIL_LOGO);
gtk_table_attach (GTK_TABLE (table), image, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
vbox2 = gtk_vbox_new (FALSE, 4);
gtk_table_attach (GTK_TABLE (table), vbox2, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
label = gtk_label_new("");
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, FALSE, 0);
markup = g_markup_printf_escaped
("<span weight=\"bold\" size=\"xx-large\">Claws Mail</span>\nversion %s",
VERSION_GIT_FULL);
gtk_label_set_markup(GTK_LABEL(label), markup);
g_free(markup);
button = gtkut_get_link_btn(window, HOMEPAGE_URI, " "HOMEPAGE_URI" ");
gtk_box_pack_start(GTK_BOX(vbox2), button, FALSE, FALSE, 0);
#ifndef GENERIC_UMPC
label = gtk_label_new
(_("Copyright (C) 1999-2016\nThe Claws Mail Team\n"
"and Hiroyuki Yamamoto"));
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_CENTER);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_box_pack_start(GTK_BOX(vbox2), label, FALSE, FALSE, 0);
#endif
notebook = gtk_notebook_new();
gtk_widget_set_size_request(notebook, -1, 220);
gtk_widget_show(notebook);
if ((scrolledwin = about_create_child_page_info()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_Info")));
}
if ((scrolledwin = about_create_child_page_authors()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_Authors")));
}
if ((scrolledwin = about_create_child_page_features()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_Features")));
}
if ((scrolledwin = about_create_child_page_license()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_License")));
}
if (release_notes_available() &&
(scrolledwin = about_create_child_page_release_notes()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_Release Notes")));
}
if ((scrolledwin = about_create_child_page_session_stats()) != NULL) {
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
scrolledwin,
gtk_label_new_with_mnemonic(_("_Statistics")));
}
gtk_box_pack_start(GTK_BOX(vbox1), notebook, TRUE, TRUE, 0);
gtkut_stock_button_set_create(&confirm_area, &close_button, GTK_STOCK_CLOSE,
NULL, NULL, NULL, NULL);
gtk_box_pack_end(GTK_BOX(vbox1), confirm_area, FALSE, FALSE, 4);
gtk_widget_grab_default(close_button);
gtk_widget_grab_focus(close_button);
g_signal_connect_closure
(G_OBJECT(close_button), "clicked",
g_cclosure_new_swap(G_CALLBACK(gtk_widget_hide_on_delete),
window, NULL), FALSE);
gtk_widget_show_all(window);
}
static void
thunar_uca_provider_activated (ThunarUcaProvider *uca_provider,
GtkAction *action)
{
GtkTreeRowReference *row;
ThunarUcaContext *uca_context;
GtkTreePath *path;
GtkTreeIter iter;
GtkWidget *dialog;
GtkWidget *window;
gboolean succeed;
GError *error = NULL;
GList *files;
gchar **argv;
gchar *working_directory = NULL;
gchar *filename;
gchar *label;
gchar *uri;
gint argc;
gchar *icon_name = NULL;
gboolean startup_notify;
GClosure *child_watch;
g_return_if_fail (THUNAR_UCA_IS_PROVIDER (uca_provider));
g_return_if_fail (GTK_IS_ACTION (action));
/* check if the row reference is still valid */
row = g_object_get_qdata (G_OBJECT (action), thunar_uca_row_quark);
if (G_UNLIKELY (!gtk_tree_row_reference_valid (row)))
return;
/* determine the iterator for the item */
path = gtk_tree_row_reference_get_path (row);
gtk_tree_model_get_iter (GTK_TREE_MODEL (uca_provider->model), &iter, path);
gtk_tree_path_free (path);
/* determine the files and the window for the action */
uca_context = g_object_get_qdata (G_OBJECT (action), thunar_uca_context_quark);
window = thunar_uca_context_get_window (uca_context);
files = thunar_uca_context_get_files (uca_context);
/* determine the argc/argv for the item */
succeed = thunar_uca_model_parse_argv (uca_provider->model, &iter, files, &argc, &argv, &error);
if (G_LIKELY (succeed))
{
/* get the icon name and whether startup notification is active */
gtk_tree_model_get (GTK_TREE_MODEL (uca_provider->model), &iter,
THUNAR_UCA_MODEL_COLUMN_ICON, &icon_name,
THUNAR_UCA_MODEL_COLUMN_STARTUP_NOTIFY, &startup_notify,
-1);
/* determine the working from the first file */
if (G_LIKELY (files != NULL))
{
/* determine the filename of the first selected file */
uri = thunarx_file_info_get_uri (files->data);
filename = g_filename_from_uri (uri, NULL, NULL);
if (G_LIKELY (filename != NULL))
{
/* if this is a folder action, we just use the filename as working directory */
if (g_object_get_qdata (G_OBJECT (action), thunar_uca_folder_quark) != NULL)
{
working_directory = filename;
filename = NULL;
}
else
{
working_directory = g_path_get_dirname (filename);
}
}
g_free (filename);
g_free (uri);
}
/* build closre for child watch */
child_watch = g_cclosure_new_swap (G_CALLBACK (thunar_uca_provider_child_watch),
uca_provider, thunar_uca_provider_child_watch_destroy);
g_closure_ref (child_watch);
g_closure_sink (child_watch);
/* spawn the command on the window's screen */
succeed = xfce_spawn_on_screen_with_child_watch (gtk_widget_get_screen (GTK_WIDGET (window)),
working_directory, argv, NULL,
G_SPAWN_SEARCH_PATH,
startup_notify,
gtk_get_current_event_time (),
icon_name,
child_watch,
&error);
/* check if we succeed */
if (G_LIKELY (succeed))
{
/* release existing child watch */
thunar_uca_provider_child_watch_destroy (uca_provider, NULL);
/* set new closure */
uca_provider->child_watch = child_watch;
/* take over ownership of the working directory as child watch path */
uca_provider->child_watch_path = working_directory;
working_directory = NULL;
}
else
{
/* spawn failed, release watch */
g_closure_unref (child_watch);
}
/* cleanup */
g_free (working_directory);
g_strfreev (argv);
g_free (icon_name);
}
/* present error message to the user */
if (G_UNLIKELY (!succeed))
{
g_object_get (G_OBJECT (action), "label", &label, NULL);
dialog = gtk_message_dialog_new ((GtkWindow *) window,
GTK_DIALOG_DESTROY_WITH_PARENT
| GTK_DIALOG_MODAL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Failed to launch action \"%s\"."), label);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), "%s.", error->message);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
g_error_free (error);
g_free (label);
}
}
GtkUIManager *create_menu_bar(GtkWidget *window)
{
GtkUIManager *ifactory;
#if 0
gboolean flag_emacs = FALSE;
gchar *key_theme = NULL;
GtkSettings *settings = gtk_settings_get_default();
if (settings) {
g_object_get(settings, "gtk-key-theme-name", &key_theme, NULL);
if (key_theme) {
if (!g_ascii_strcasecmp(key_theme, "Emacs"))
flag_emacs = TRUE;
g_free(key_theme);
}
}
#endif
ifactory = gtk_ui_manager_new();
GtkActionGroup *actions = gtk_action_group_new("Actions");
gtk_action_group_set_translate_func(actions, menu_translate, NULL, NULL);
gtk_action_group_add_actions(actions, menu_items, nmenu_items, NULL);
gtk_action_group_add_toggle_actions (actions, toggle_entries, n_toggle_entries, NULL);
gtk_ui_manager_insert_action_group(ifactory, actions, 0);
g_object_unref(actions);
gtk_ui_manager_add_ui_from_string(ifactory, ui_info, -1, NULL);
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
/* hidden keybinds */
gtk_accel_group_connect(
accel_group, GDK_W, GDK_CONTROL_MASK, 0,
g_cclosure_new_swap(G_CALLBACK(on_file_close), NULL, NULL));
gtk_accel_group_connect(
accel_group, GDK_T, GDK_CONTROL_MASK, 0,
g_cclosure_new_swap(G_CALLBACK(on_option_always_on_top), NULL, NULL));
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Edit/Redo"),
"activate", accel_group, GDK_Y, GDK_CONTROL_MASK, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindNext"),
"activate", accel_group, GDK_F3, 0, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindPrevious"),
"activate", accel_group, GDK_F3, GDK_SHIFT_MASK, 0);
gtk_widget_add_accelerator(
gtk_ui_manager_get_widget(ifactory, "/M/Search/Replace"),
"activate", accel_group, GDK_R, GDK_CONTROL_MASK, 0);
/* initialize sensitivities */
gtk_widget_set_sensitive(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindNext"),
FALSE);
gtk_widget_set_sensitive(
gtk_ui_manager_get_widget(ifactory, "/M/Search/FindPrevious"),
FALSE);
menu_item_save = gtk_ui_manager_get_widget(ifactory, "/M/File/Save");
menu_item_cut = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Cut");
menu_item_copy = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Copy");
menu_item_paste = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Paste");
menu_item_delete = gtk_ui_manager_get_widget(ifactory, "/M/Edit/Delete");
menu_sensitivity_from_selection_bound(FALSE);
return ifactory;
}
gboolean check_emacs_key_theme(GtkWindow *window, GtkItemFactory *ifactory)
{
GtkAccelGroup *accel_group;
GSList *groups;
gchar *key_theme = NULL;
gboolean emacs_flag = FALSE;
GtkSettings *settings = gtk_settings_get_default();
g_object_get(settings, "gtk-key-theme-name", &key_theme, NULL);
if (key_theme) {
if (!g_ascii_strcasecmp(key_theme, "Emacs"))
emacs_flag = TRUE;
g_free(key_theme);
}
if (!emacs_flag)
return FALSE;
groups = gtk_accel_groups_from_object(G_OBJECT(window));
accel_group = groups->data;
if (accel_group) {
gtk_window_remove_accel_group(GTK_WINDOW(window), accel_group);
g_object_unref(accel_group);
}
accel_group = gtk_accel_group_new();
gtk_rc_parse_string (
"binding \"gtk-emacs-text-entry\""
"{\n"
"bind \"<ctrl>w\" { \"cut-clipboard\" () }"
"}\n"
);
/* gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/File/New"),
accel_group, GDK_N, GDK_CONTROL_MASK);
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/File/Open..."),
accel_group, GDK_O, GDK_CONTROL_MASK);
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/File/Save"),
accel_group, GDK_S, GDK_CONTROL_MASK);
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/File/Save As..."),
accel_group, GDK_S, GDK_SHIFT_MASK | GDK_CONTROL_MASK);
#ifdef ENABLE_PRINT
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/File/Print..."),
accel_group, GDK_P, GDK_CONTROL_MASK);
#endif
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/Edit/Undo"),
accel_group, GDK_Z, GDK_CONTROL_MASK);
*/ gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Edit/Undo"),
"activate", accel_group, GDK_underscore, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
/* gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/Edit/Select All"),
accel_group, GDK_A, GDK_CONTROL_MASK);
gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Find..."),
accel_group, GDK_F, GDK_CONTROL_MASK);
*/ gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Find..."),
"activate", accel_group, GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
/* gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Find Next"),
"activate", accel_group, GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
*/ gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Find Previous"),
"activate", accel_group, GDK_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
/* gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Replace..."),
accel_group, GDK_H, GDK_CONTROL_MASK);
*/ gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Replace..."),
"activate", accel_group, GDK_percent, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
/* gtk_widget_remove_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Jump To..."),
accel_group, GDK_J, GDK_CONTROL_MASK);
*/ gtk_widget_add_accelerator(
gtk_item_factory_get_widget(ifactory, "/Search/Jump To..."),
"activate", accel_group, GDK_G, GDK_MOD1_MASK, GTK_ACCEL_VISIBLE);
gtk_accel_group_connect(
accel_group, GDK_X, GDK_CONTROL_MASK, 0,
g_cclosure_new_swap(G_CALLBACK(emacs_key_prefix), NULL, NULL));
gtk_window_add_accel_group(GTK_WINDOW(window), accel_group);
return TRUE;
}
static void browser_window_init(BrowserWindow *window)
{
g_atomic_int_inc(&windowCount);
gchar img_src_dir[BUFSIZE] = {0};
strcat(img_src_dir, get_cuprum_dir());
gchar img_source_1[BUFSIZE] = {0};
strcat(img_source_1, img_src_dir);
strcat(img_source_1, "/resources/img/1.png");
gchar img_source_2[BUFSIZE] = {0};
strcat(img_source_2, img_src_dir);
strcat(img_source_2, "/resources/img/2.png");
gtk_window_set_title(GTK_WINDOW(window), defaultWindowTitle);
gtk_window_set_default_size(GTK_WINDOW(window), 1000, 750);
window->uriEntry = gtk_entry_new();
g_signal_connect_swapped(window->uriEntry, "activate", G_CALLBACK(activateUriEntryCallback), (gpointer)window);
gtk_entry_set_icon_activatable(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_PRIMARY, FALSE);
g_signal_connect_swapped (G_OBJECT(window->uriEntry), "icon-press", G_CALLBACK(certificateCallback), window);
updateUriEntryIcon(window);
/* Keyboard accelerators */
window->accelGroup = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), window->accelGroup);
/* Global accelerators */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_I, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(toggleWebInspector), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F12, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(toggleWebInspector), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F11, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(showFullscreen), window, NULL));
/* Reload page */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F5, 0, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPage), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPage), window, NULL));
/* Reload page ignoring cache */
gtk_accel_group_connect(window->accelGroup, GDK_KEY_F5, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPageIgnoringCache), window, NULL));
gtk_accel_group_connect(window->accelGroup, GDK_KEY_R, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE,
g_cclosure_new_swap(G_CALLBACK(reloadPageIgnoringCache), window, NULL));
//add by zgh menu
window->menubar = BROWSER_MENU_BAR(browser_menu_bar_new());
browser_menu_bar_add_accelerators(BROWSER_MENU_BAR(window->menubar), window->accelGroup);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_find", G_CALLBACK(menuSearchCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_in", G_CALLBACK(zoomInCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_out", G_CALLBACK(zoomOutCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_zoom_fit", G_CALLBACK(zoomFitCallback), window);
// g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_nopagestyle", G_CALLBACK(menuNopagestyleCallback), window);
// g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_webpagestyle", G_CALLBACK(menuWebpagestyleCallback), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_fullscreen", G_CALLBACK(showFullscreen), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_bookmarkbar", G_CALLBACK(showBookmarkbar), window);
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_history_manager", G_CALLBACK(showHistoryManagerWindow), window);//add by zlf
g_signal_connect_swapped(G_OBJECT(window->menubar), "menu_history_clear", G_CALLBACK(showHistoryClearWindow), window);//add by zlf
g_signal_connect(G_OBJECT(window->menubar), "menu_quit", G_CALLBACK(gtk_main_quit), window);
// gtk_container_set_border_width(GTK_CONTAINER(window->menubar), 0);
g_signal_connect(G_OBJECT(window->menubar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
GtkWidget *toolbar = gtk_toolbar_new();
window->toolbar = toolbar;
gtk_orientable_set_orientation(GTK_ORIENTABLE(toolbar), GTK_ORIENTATION_HORIZONTAL);
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
// gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_container_set_border_width(GTK_CONTAINER(window->toolbar), 0);
g_signal_connect(G_OBJECT(toolbar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
GtkToolItem *item = gtk_menu_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
window->backItem = GTK_WIDGET(item);
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(item), 0);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
item = gtk_menu_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
window->forwardItem = GTK_WIDGET(item);
gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(item), 0);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(goForwardCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
item = gtk_tool_button_new_from_stock(GTK_STOCK_REFRESH);
window->reloadOrStopButton = GTK_WIDGET(item);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(reloadOrStopCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_add_accelerator(window->reloadOrStopButton, "clicked", window->accelGroup, GDK_KEY_F5, 0, GTK_ACCEL_VISIBLE);
gtk_widget_show(window->reloadOrStopButton);
item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME);
window->homeButton = GTK_WIDGET(item);
g_signal_connect_swapped(item, "clicked", G_CALLBACK(homeButtonCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(window->homeButton);
gtk_entry_set_icon_from_pixbuf(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_SECONDARY, create_pixbuf(img_source_1));
gtk_entry_set_icon_activatable(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_PRIMARY, TRUE);
gtk_entry_set_icon_tooltip_markup(GTK_ENTRY(window->uriEntry), GTK_ENTRY_ICON_SECONDARY, "将此页加为书签");
g_signal_connect_swapped (G_OBJECT(window->uriEntry), "icon-press", G_CALLBACK(collecturiCallback), window);
//by sunh
item = gtk_tool_button_new_from_stock(GTK_STOCK_GOTO_BOTTOM);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(downloadCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
//by sunh end
item = gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
gtk_container_add(GTK_CONTAINER(item), window->uriEntry);
gtk_widget_show(window->uriEntry);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
//setting
item = gtk_tool_button_new_from_stock(GTK_STOCK_PREFERENCES);
g_signal_connect_swapped(G_OBJECT(item), "clicked", G_CALLBACK(settingsCallback), window);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
// -setting
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
window->mainBox = vbox;
gtk_widget_show_all(GTK_WIDGET(window->menubar));
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(window->menubar), FALSE, FALSE, 0);
//<wangc add tab mamager
TabMng* tbmng=(TabMng*)malloc(sizeof(TabMng));
initTabMng(tbmng);
window->tabmng=tbmng;
GtkWidget *boxtab = gtk_box_new (FALSE, 0);
window->boxtab=boxtab;
GtkWidget * btab = gtk_button_new_with_label ("Add");
g_signal_connect (G_OBJECT (btab), "clicked",
G_CALLBACK (cbAddTab), window);
gtk_box_pack_start (GTK_BOX(boxtab), btab, FALSE, FALSE, 0);
gtk_widget_show (btab);
gtk_box_pack_start(GTK_BOX(vbox),boxtab,FALSE, FALSE, 0);
gtk_widget_show(boxtab);
//>
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show(toolbar);
//书签栏
GtkWidget *bookmarkbar = gtk_toolbar_new();
window->bookmarkbar = bookmarkbar;
/*
item =gtk_tool_item_new();
gtk_tool_item_set_expand(item, TRUE);
GtkWidget *bookmarkBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add(GTK_CONTAINER(item), bookmarkBox);
window->bookmarkbox = bookmarkBox;
gtk_toolbar_insert(GTK_TOOLBAR(bookmarkbar), item, 0);
gtk_widget_show(bookmarkBox);
gtk_widget_show(GTK_WIDGET(item));
*/
gtk_toolbar_set_icon_size (GTK_TOOLBAR (window->bookmarkbar),
GTK_ICON_SIZE_MENU);
gtk_toolbar_set_style (GTK_TOOLBAR (window->bookmarkbar),
GTK_TOOLBAR_BOTH);//GTK_TOOLBAR_BOTH_HORIZ
g_signal_connect(G_OBJECT(bookmarkbar), "button-press-event", G_CALLBACK(buttonmenuCallback), window);
gtk_box_pack_start(GTK_BOX(vbox), bookmarkbar, FALSE, FALSE, 0);
// gtk_widget_show(bookmarkbar);
/*
GtkWidget *status_bar = gtk_label_new("");
gtk_label_set_width_chars(GTK_LABEL(status_bar), 50);
gtk_misc_set_alignment(GTK_MISC(status_bar), 0, 0);
gtk_box_pack_end(GTK_BOX(vbox), status_bar, FALSE, FALSE, 0);
// gtk_widget_show(status_bar);
*/
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show(vbox);
HS_init(window);// add by zlf
}
void build_mainwindow(void)
{
guint ic;
uri_regex_count = G_N_ELEMENTS(uri_patterns);
uri_regex = g_new0(GRegex*, uri_regex_count);
for(ic = 0; ic < uri_regex_count; ++ic)
{
GError *error = NULL;
uri_regex[ic] = g_regex_new(uri_patterns[ic].pattern,
uri_patterns[ic].flags | G_REGEX_OPTIMIZE, 0, &error);
if(error)
{
g_message("%s", error->message);
g_error_free (error);
}
}
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(mainwindow, TRUE);
gtk_widget_set_size_request(mainwindow, conf_get_width(), conf_get_height());
gtk_window_set_decorated(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_resizable(GTK_WINDOW(mainwindow), TRUE);
mainwindow_reset_position();
fullscreen = FALSE;
toggled = FALSE;
GtkAccelGroup* accel_group;
GClosure *new_tab, *delete_tab, *next_tab, *prev_tab, *delete_all,
*maximize, *copy, *paste;
GClosure *goto_tab_closure[10];
long i;
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mainwindow), accel_group);
maximize = g_cclosure_new_swap(G_CALLBACK(mainwindow_toggle_fullscreen),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_F11, 0,
GTK_ACCEL_VISIBLE, maximize);
new_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_new_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 't', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, new_tab);
delete_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_delete_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'w', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_tab);
next_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_next_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Up, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, next_tab);
prev_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_prev_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Down, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, prev_tab);
delete_all = g_cclosure_new_swap(G_CALLBACK(mainwindow_destroy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'q', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_all);
/* tab hotkeys, inspired by Tilda -- thanks to castorinop for the patch */
for(i = 0; i < 10; i++)
{
goto_tab_closure[i] = g_cclosure_new_swap(G_CALLBACK(mainwindow_goto_tab),
(gpointer) i, NULL);
gtk_accel_group_connect(accel_group, '0' + ((i+1)%10), GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE, goto_tab_closure[i]);
}
copy = g_cclosure_new_swap(G_CALLBACK(mainwindow_copy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'c', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, copy);
paste = g_cclosure_new_swap(G_CALLBACK(mainwindow_paste),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'v', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, paste);
activetab = -1;
tabcount = 0;
GtkVBox* mainbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
tabbar = GTK_NOTEBOOK(gtk_notebook_new());
g_signal_connect(G_OBJECT(tabbar), "switch-page",
G_CALLBACK(mainwindow_switch_tab), NULL);
if(conf_get_opacity() < 100)
{
GdkScreen *screen = gdk_screen_get_default();
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
screen_is_composited = (colormap != NULL
&& gdk_screen_is_composited(screen));
if(screen_is_composited)
{
gtk_widget_set_colormap(GTK_WIDGET(mainwindow), colormap);
gdk_screen_set_default_colormap(screen, colormap);
}
}
gtk_box_pack_start(GTK_BOX(mainbox), GTK_WIDGET(tabbar), TRUE, TRUE, 0);
mainwindow_create_tab();
gtk_widget_show_all(GTK_WIDGET(mainbox));
gtk_container_add(GTK_CONTAINER(mainwindow), GTK_WIDGET(mainbox));
int border = conf_get_border();
if(border == BORDER_THIN)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 1);
else if(border == BORDER_THICK)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
if(border != BORDER_NONE)
g_signal_connect(G_OBJECT(mainwindow), "expose-event",
G_CALLBACK(mainwindow_expose_event), NULL);
if(conf_get_auto_hide())
g_signal_connect(G_OBJECT(mainwindow), "focus-out-event",
G_CALLBACK(mainwindow_focus_out_event), NULL);
g_signal_connect(G_OBJECT(mainwindow), "show", G_CALLBACK(mainwindow_show),
NULL);
g_signal_connect(G_OBJECT(mainwindow), "destroy",
G_CALLBACK(mainwindow_destroy), NULL);
g_signal_connect_after(G_OBJECT(tabbar), "button_press_event",
G_CALLBACK(mainwindow_notebook_clicked), NULL);
gtk_notebook_set_show_border(tabbar, FALSE);
gtk_notebook_set_scrollable(tabbar, TRUE);
if (conf_get_show_tab() == TABS_ONE|| conf_get_show_tab() == TABS_NEVER)
gtk_notebook_set_show_tabs(tabbar, FALSE);
gtk_notebook_set_tab_pos(tabbar, conf_get_tab_pos());
gtk_notebook_set_homogeneous_tabs(tabbar, FALSE);
XSetErrorHandler(handle_x_error);
init_key();
grab_key();
g_thread_new("stjerm", (GThreadFunc)wait_key, NULL);
// If stjerm has been started for the first time with --toggle, then
// show the window straight away. Make haste!
if(conf_get_toggled()) {
mainwindow_toggle(1);
}
}
void build_mainwindow(void) {
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_app_paintable(mainwindow, TRUE);
gtk_widget_set_size_request(mainwindow, conf_get_width(), conf_get_height());
gtk_window_set_decorated(GTK_WINDOW(mainwindow), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(mainwindow), TRUE);
gtk_window_set_resizable(GTK_WINDOW(mainwindow), TRUE);
mainwindow_reset_position();
fullscreen = FALSE;
toggled = FALSE;
GtkAccelGroup* accel_group;
GClosure *new_tab, *delete_tab, *next_tab, *prev_tab, *delete_all,
*maximize, *copy, *paste;
accel_group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mainwindow), accel_group);
maximize = g_cclosure_new_swap(G_CALLBACK(mainwindow_toggle_fullscreen),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_F11, 0,
GTK_ACCEL_VISIBLE, maximize);
new_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_new_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 't', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, new_tab);
delete_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_delete_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'w', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_tab);
next_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_next_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Down, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, next_tab);
prev_tab = g_cclosure_new_swap(G_CALLBACK(mainwindow_prev_tab),
NULL, NULL);
gtk_accel_group_connect(accel_group, GDK_Page_Up, conf_get_key_mod(),
GTK_ACCEL_VISIBLE, prev_tab);
delete_all = g_cclosure_new_swap(G_CALLBACK(mainwindow_destroy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'q', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, delete_all);
copy = g_cclosure_new_swap(G_CALLBACK(mainwindow_copy),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'c', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, copy);
paste = g_cclosure_new_swap(G_CALLBACK(mainwindow_paste),
NULL, NULL);
gtk_accel_group_connect(accel_group, 'v', conf_get_key_mod(),
GTK_ACCEL_VISIBLE, paste);
activetab = -1;
tabs = g_array_new(TRUE, FALSE, sizeof(VteTerminal*));
tabcount = 0;
GtkVBox* mainbox = GTK_VBOX(gtk_vbox_new(FALSE, 0));
tabbar = GTK_NOTEBOOK(gtk_notebook_new());
g_signal_connect(G_OBJECT(tabbar), "switch-page",
G_CALLBACK(mainwindow_switch_tab), NULL);
if (conf_get_opacity() < 100) {
GdkScreen *screen = gdk_screen_get_default();
GdkColormap *colormap = gdk_screen_get_rgba_colormap(screen);
screen_is_composited = (colormap != NULL
&& gdk_screen_is_composited(screen));
if (screen_is_composited) {
gtk_widget_set_colormap(GTK_WIDGET(mainwindow), colormap);
gdk_screen_set_default_colormap(screen, colormap);
}
}
gtk_box_pack_start(GTK_BOX(mainbox), GTK_WIDGET(tabbar), TRUE, TRUE, 0);
mainwindow_create_tab();
gtk_widget_show_all(GTK_WIDGET(mainbox));
gtk_container_add(GTK_CONTAINER(mainwindow), GTK_WIDGET(mainbox));
int border = conf_get_border();
if (border == BORDER_THIN)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 1);
else if (border == BORDER_THICK)
gtk_container_set_border_width(GTK_CONTAINER(mainwindow), 5);
if (border != BORDER_NONE)
g_signal_connect(G_OBJECT(mainwindow), "expose-event",
G_CALLBACK(mainwindow_expose_event), NULL);
/*
* g_signal_connect connects a GCallback function to a signal for a
* particular object. For example, when the 'focus-out-event' signal is
* triggered (That is, when Stjerm loses focus), the
* 'mainwindow_focus_out_event' function will run.
*/
if (conf_get_auto_hide())
g_signal_connect(G_OBJECT(mainwindow), "focus-out-event",
G_CALLBACK(mainwindow_focus_out_event), NULL);
g_signal_connect(G_OBJECT(mainwindow), "show", G_CALLBACK(mainwindow_show),
NULL);
g_signal_connect(G_OBJECT(mainwindow), "destroy",
G_CALLBACK(mainwindow_destroy), NULL);
gtk_notebook_set_show_border(tabbar, FALSE);
gtk_notebook_set_scrollable(tabbar, TRUE);
if (conf_get_show_tab() == TABS_ONE|| conf_get_show_tab() == TABS_NEVER)
gtk_notebook_set_show_tabs(tabbar, FALSE);
gtk_notebook_set_tab_pos(tabbar, conf_get_tab_pos());
XSetErrorHandler(handle_x_error);
init_key(); // init_key and grab_key are
grab_key(); // defined globally in stjerm.h
g_thread_create((GThreadFunc)wait_key, NULL, FALSE, NULL);
}
void
create_main_window (ProcData *procdata)
{
gint i;
gint width, height, xpos, ypos;
GtkWidget *app;
GtkAction *action;
GtkWidget *menubar;
GtkWidget *main_box;
GtkWidget *notebook;
GtkWidget *tab_label1, *tab_label2, *tab_label3;
GtkWidget *vbox1;
GtkWidget *sys_box, *devices_box;
GtkWidget *sysinfo_box, *sysinfo_label;
app = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(app), _("System Monitor"));
GdkScreen* screen = gtk_widget_get_screen(app);
/* use visual, if available */
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
if (visual)
gtk_widget_set_visual(app, visual);
main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(app), main_box);
width = procdata->config.width;
height = procdata->config.height;
xpos = procdata->config.xpos;
ypos = procdata->config.ypos;
gtk_window_set_default_size (GTK_WINDOW (app), width, height);
gtk_window_move(GTK_WINDOW (app), xpos, ypos);
gtk_window_set_resizable (GTK_WINDOW (app), TRUE);
if (procdata->config.maximized) {
gtk_window_maximize(GTK_WINDOW(app));
}
/* create the menubar */
procdata->uimanager = gtk_ui_manager_new ();
/* show tooltips in the statusbar */
g_signal_connect (procdata->uimanager, "connect_proxy",
G_CALLBACK (connect_proxy_cb), procdata);
g_signal_connect (procdata->uimanager, "disconnect_proxy",
G_CALLBACK (disconnect_proxy_cb), procdata);
gtk_window_add_accel_group (GTK_WINDOW (app),
gtk_ui_manager_get_accel_group (procdata->uimanager));
if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager,
ui_info,
-1,
NULL)) {
g_error("building menus failed");
}
procdata->action_group = gtk_action_group_new ("ProcmanActions");
gtk_action_group_set_translation_domain (procdata->action_group, NULL);
gtk_action_group_add_actions (procdata->action_group,
menu_entries,
G_N_ELEMENTS (menu_entries),
procdata);
gtk_action_group_add_toggle_actions (procdata->action_group,
toggle_menu_entries,
G_N_ELEMENTS (toggle_menu_entries),
procdata);
gtk_action_group_add_radio_actions (procdata->action_group,
radio_menu_entries,
G_N_ELEMENTS (radio_menu_entries),
procdata->config.whose_process,
G_CALLBACK(cb_radio_processes),
procdata);
gtk_action_group_add_radio_actions (procdata->action_group,
priority_menu_entries,
G_N_ELEMENTS (priority_menu_entries),
NORMAL_PRIORITY,
G_CALLBACK(cb_renice),
procdata);
gtk_ui_manager_insert_action_group (procdata->uimanager,
procdata->action_group,
0);
menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar");
gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0);
/* create the main notebook */
procdata->notebook = notebook = gtk_notebook_new ();
gtk_box_pack_start (GTK_BOX (main_box), notebook, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 12);
sysinfo_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); // procman_create_sysinfo_view();
sysinfo_label = gtk_label_new(_("System"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label);
vbox1 = create_proc_view (procdata);
tab_label1 = gtk_label_new (_("Processes"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1);
sys_box = create_sys_view (procdata);
tab_label2 = gtk_label_new (_("Resources"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2);
devices_box = create_disk_view (procdata);
tab_label3 = gtk_label_new (_("File Systems"));
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3);
g_signal_connect (G_OBJECT (notebook), "switch-page",
G_CALLBACK (cb_switch_page), procdata);
g_signal_connect (G_OBJECT (notebook), "change-current-page",
G_CALLBACK (cb_change_current_page), procdata);
gtk_widget_show_all(notebook); // need to make page switch work
gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab);
cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata);
g_signal_connect (G_OBJECT (app), "delete_event",
G_CALLBACK (cb_app_delete),
procdata);
GtkAccelGroup *accel_group;
GClosure *goto_tab_closure[4];
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW(app), accel_group);
for (i = 0; i < 4; ++i) {
goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab),
GINT_TO_POINTER (i), NULL);
gtk_accel_group_connect (accel_group, '0'+(i+1),
GDK_MOD1_MASK, GTK_ACCEL_VISIBLE,
goto_tab_closure[i]);
}
/* create the statusbar */
procdata->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0);
procdata->tip_message_cid = gtk_statusbar_get_context_id
(GTK_STATUSBAR (procdata->statusbar), "tip_message");
action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies");
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
procdata->config.show_tree);
gtk_widget_show_all(app);
procdata->app = app;
}
