static void
gy_window_settings__window_realize (GtkWindow *window)
{
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
gtk_window_set_default_size (window, geom.width, geom.height);
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
DzlDockBin* dockbin = gy_window_get_dockbin (GY_WINDOW (window));
GtkWidget * edge = dzl_dock_bin_get_left_edge (dockbin);
g_settings_bind (settings, "left-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "left-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
edge = dzl_dock_bin_get_right_edge (dockbin);
g_settings_bind (settings, "right-panel-visible", edge, "reveal-child", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "right-panel-position", edge, "position", G_SETTINGS_BIND_DEFAULT);
}
static void
refresh_recent_project_view (GtkListBox *box)
{
GSettings *settings;
GtkRecentManager *manager;
GtkRecentData *recent_project;
GList *items, *list;
gint i;
guint recent_limit;
manager = gtk_recent_manager_get_default ();
items = gtk_recent_manager_get_items (manager);
items = g_list_reverse (items);
list = items;
settings = g_settings_new (PREF_SCHEMA);
i = 0;
g_settings_get (settings, RECENT_LIMIT, "i", &recent_limit);
while (i < recent_limit && list != NULL)
{
if (strcmp (gtk_recent_info_get_mime_type (list->data), "application/x-anjuta") == 0)
{
recent_project = list->data;
add_recent_project_row (box, recent_project);
i++;
}
list = list->next;
}
g_list_free_full(items, (GDestroyNotify)gtk_recent_info_unref);
g_object_unref (settings);
}
/**
* gucharma_settings_add_window:
* @window: a #GtkWindow
*
* Restore the window configuration, and persist changes to the window configuration:
* window width and height, and maximised and fullscreen state.
* @window must not be realised yet.
*/
void
gucharmap_settings_add_window (GtkWindow *window)
{
WindowState *state;
int width, height;
gboolean maximised, fullscreen;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
state = g_slice_new0 (WindowState);
state->settings = g_settings_new ("org.gnome.Charmap.WindowState");
g_object_set_data_full (G_OBJECT (window), "GamesConf::WindowState",
state, (GDestroyNotify) free_window_state);
g_signal_connect_after (window, "size-allocate",
G_CALLBACK (window_size_allocate_cb), state);
g_signal_connect (window, "window-state-event",
G_CALLBACK (window_state_event_cb), state);
maximised = g_settings_get_boolean (state->settings, "maximized");
fullscreen = g_settings_get_boolean (state->settings, "fullscreen");
g_settings_get (state->settings, "size", "(ii)", &width, &height);
if (width > 0 && height > 0) {
gtk_window_set_default_size (GTK_WINDOW (window), width, height);
}
if (maximised) {
gtk_window_maximize (GTK_WINDOW (window));
}
if (fullscreen) {
gtk_window_fullscreen (GTK_WINDOW (window));
}
}
/* The GeditRecentConfiguration struct is allocated and owned by the caller */
void
gedit_recent_configuration_init_default (GeditRecentConfiguration *config)
{
GSettings *settings;
config->manager = gtk_recent_manager_get_default ();
if (config->filter != NULL)
{
g_object_unref (config->filter);
}
config->filter = gtk_recent_filter_new ();
gtk_recent_filter_add_application (config->filter, g_get_application_name ());
gtk_recent_filter_add_mime_type (config->filter, "text/plain");
g_object_ref_sink (config->filter);
settings = g_settings_new ("org.gnome.gedit.preferences.ui");
g_settings_get (settings,
GEDIT_SETTINGS_MAX_RECENTS,
"u",
&config->limit);
g_object_unref (settings);
config->show_not_found = TRUE;
config->show_private = FALSE;
config->local_only = FALSE;
config->substring_filter = NULL;
}
gboolean w_settings_get_window_size(wSettings *sett, gint *w, gint *h)
{
g_return_val_if_fail( sett != NULL && w != NULL && h != NULL, FALSE);
g_settings_get(G_SETTINGS(sett), "window-size", "(ii)", w, h);
return TRUE;
}
gboolean w_settings_get_window_pos(wSettings *sett, gint *x, gint *y)
{
g_return_val_if_fail( sett != NULL && x != NULL && y != NULL, FALSE);
g_settings_get(G_SETTINGS(sett), "window-pos", "(ii)", x, y);
return TRUE;
}
static void
sp_window_settings__window_realize (GtkWindow *window)
{
GtkApplication *app;
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
GList *list;
guint count = 0;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (settings));
g_settings_get (settings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (settings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (settings, "window-maximized", "b", &maximized);
geom.width = MAX (geom.width, WINDOW_MIN_WIDTH);
geom.height = MAX (geom.height, WINDOW_MIN_HEIGHT);
gtk_window_set_default_size (window, geom.width, geom.height);
/*
* If there are other windows currently visible other than this one,
* then ignore positioning and let the window manager decide.
*/
count = 0;
app = GTK_APPLICATION (g_application_get_default ());
list = gtk_application_get_windows (app);
for (; list != NULL; list = list->next)
{
GtkWindow *ele = list->data;
if (SP_IS_WINDOW (ele) && (ele != window) &&
gtk_widget_get_visible (GTK_WIDGET (window)))
count++;
}
if (count == 0)
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
}
/**
* gedit_app_create_window:
* @app: the #GeditApp
* @screen: (allow-none):
*
* Create a new #GeditWindow part of @app.
*
* Return value: (transfer none): the new #GeditWindow
*/
GeditWindow *
gedit_app_create_window (GeditApp *app,
GdkScreen *screen)
{
GeditAppPrivate *priv;
GeditWindow *window;
gchar *role;
GdkWindowState state;
gint w, h;
gedit_debug (DEBUG_APP);
priv = gedit_app_get_instance_private (app);
window = GEDIT_APP_GET_CLASS (app)->create_window (app);
if (screen != NULL)
{
gtk_window_set_screen (GTK_WINDOW (window), screen);
}
role = gen_role ();
gtk_window_set_role (GTK_WINDOW (window), role);
g_free (role);
state = g_settings_get_int (priv->window_settings,
GEDIT_SETTINGS_WINDOW_STATE);
g_settings_get (priv->window_settings,
GEDIT_SETTINGS_WINDOW_SIZE,
"(ii)", &w, &h);
gtk_window_set_default_size (GTK_WINDOW (window), w, h);
if ((state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
{
gtk_window_maximize (GTK_WINDOW (window));
}
else
{
gtk_window_unmaximize (GTK_WINDOW (window));
}
if ((state & GDK_WINDOW_STATE_STICKY ) != 0)
{
gtk_window_stick (GTK_WINDOW (window));
}
else
{
gtk_window_unstick (GTK_WINDOW (window));
}
return window;
}
void
setup_camera (CheeseWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
char *webcam_device = NULL;
int x_resolution;
int y_resolution;
gdouble brightness;
gdouble contrast;
gdouble saturation;
gdouble hue;
g_settings_get (priv->settings, "photo-x-resolution", "i", &x_resolution);
g_settings_get (priv->settings, "photo-y-resolution", "i", &y_resolution);
g_settings_get (priv->settings, "camera", "s", &webcam_device);
g_settings_get (priv->settings, "brightness", "d", &brightness);
g_settings_get (priv->settings, "contrast", "d", &contrast);
g_settings_get (priv->settings, "saturation", "d", &saturation);
g_settings_get (priv->settings, "hue", "d", &hue);
gdk_threads_enter ();
priv->webcam = cheese_camera_new (CLUTTER_TEXTURE (priv->texture),
webcam_device,
x_resolution,
y_resolution);
gdk_threads_leave ();
g_free (webcam_device);
cheese_camera_setup (priv->webcam, NULL, &priv->error);
gdk_threads_enter ();
gtk_spinner_stop (GTK_SPINNER (priv->spinner));
if (priv->error != NULL)
{
priv->state = CHEESE_WIDGET_STATE_ERROR;
g_object_notify (G_OBJECT (widget), "state");
cheese_widget_set_problem_page (CHEESE_WIDGET (widget), "error");
}
else
{
cheese_camera_set_balance_property (priv->webcam, "brightness", brightness);
cheese_camera_set_balance_property (priv->webcam, "contrast", contrast);
cheese_camera_set_balance_property (priv->webcam, "saturation", saturation);
cheese_camera_set_balance_property (priv->webcam, "hue", hue);
priv->state = CHEESE_WIDGET_STATE_READY;
g_object_notify (G_OBJECT (widget), "state");
cheese_camera_play (priv->webcam);
gtk_notebook_set_current_page (GTK_NOTEBOOK (widget), WEBCAM_PAGE);
}
gdk_threads_leave ();
}
static void
gb_settings__window_realize (GtkWindow *window,
GSettings *settings)
{
GdkRectangle geom = { 0 };
gboolean maximized = FALSE;
g_assert (GTK_IS_WINDOW (window));
g_assert (G_IS_SETTINGS (gSettings));
g_settings_get (gSettings, "window-position", "(ii)", &geom.x, &geom.y);
g_settings_get (gSettings, "window-size", "(ii)", &geom.width, &geom.height);
g_settings_get (gSettings, "window-maximized", "b", &maximized);
geom.width = MAX (geom.width, GB_WINDOW_MIN_WIDTH);
geom.height = MAX (geom.height, GB_WINDOW_MIN_HEIGHT);
gtk_window_set_default_size (window, geom.width, geom.height);
gtk_window_move (window, geom.x, geom.y);
if (maximized)
gtk_window_maximize (window);
}
static void
children_changed (GSettings *settings,
const char *key,
CcNotificationsPanel *panel)
{
int i;
const gchar **new_app_ids;
g_settings_get (panel->master_settings,
"application-children",
"^a&s", &new_app_ids);
for (i = 0; new_app_ids[i]; i++)
maybe_add_app_id (panel, new_app_ids[i]);
g_free (new_app_ids);
}
void UpdateDPI()
{
auto* uscreen = UScreen::GetDefault();
double min_scale = 4.0;
double max_scale = 0.0;
bool any_changed = false;
glib::Variant dict;
g_settings_get(ubuntu_ui_settings_, SCALE_FACTOR.c_str(), "@a{si}", &dict);
glib::String app_target_monitor(g_settings_get_string(ui_settings_, APP_SCALE_MONITOR.c_str()));
double app_target_scale = 0;
for (unsigned monitor = 0; monitor < em_converters_.size(); ++monitor)
{
int dpi = DEFAULT_DPI;
if (monitor < uscreen->GetMonitors().size())
{
auto const& monitor_name = uscreen->GetMonitorName(monitor);
double ui_scale = 1.0f;
int value;
if (g_variant_lookup(dict, monitor_name.c_str(), "i", &value) && value > 0)
ui_scale = static_cast<double>(value)/8.0f;
if (app_target_monitor.Str() == monitor_name)
app_target_scale = ui_scale;
dpi = DEFAULT_DPI * ui_scale;
min_scale = std::min(min_scale, ui_scale);
max_scale = std::max(max_scale, ui_scale);
}
if (em_converters_[monitor]->SetDPI(dpi))
any_changed = true;
}
if (app_target_scale == 0)
app_target_scale = (g_settings_get_boolean(ui_settings_, APP_USE_MAX_SCALE.c_str())) ? max_scale : min_scale;
UpdateAppsScaling(app_target_scale);
if (any_changed)
parent_->dpi_changed.emit();
}
static void
set_lock_value_for_combo (GtkComboBox *combo_box, CcScreenPanel *self)
{
GtkTreeIter iter;
GtkTreeModel *model;
guint value;
gint value_tmp, value_prev;
gboolean ret;
guint i;
/* get entry */
model = gtk_combo_box_get_model (combo_box);
ret = gtk_tree_model_get_iter_first (model, &iter);
if (!ret)
return;
value_prev = 0;
i = 0;
/* try to make the UI match the lock setting */
g_settings_get (self->priv->lock_settings, "lock-delay", "u", &value);
do
{
gtk_tree_model_get (model, &iter,
1, &value_tmp,
-1);
if (value == value_tmp ||
(value_tmp > value_prev && value < value_tmp))
{
gtk_combo_box_set_active_iter (combo_box, &iter);
return;
}
value_prev = value_tmp;
i++;
} while (gtk_tree_model_iter_next (model, &iter));
/* If we didn't find the setting in the list */
gtk_combo_box_set_active (combo_box, i - 1);
}
/**
* gva_main_get_last_selected_match:
* @column_name: return location for the column name
* @search_text: return location for the search text
*
* Returns the most recently selected match in a search completion list
* from either the current or previous session of <emphasis>GNOME Video
* Arcade</emphasis>. If the completion feature was not used in the
* most recent search, @column_name and @search_text are set to %NULL
* and the function returns %FALSE.
*
* Returns: %TRUE if match values were successfully retrieved from
* GSettings, %FALSE otherwise
**/
gboolean
gva_main_get_last_selected_match (gchar **column_name,
gchar **search_text)
{
GSettings *settings;
g_return_val_if_fail (column_name != NULL, FALSE);
g_return_val_if_fail (search_text != NULL, FALSE);
settings = gva_get_settings ();
*column_name = *search_text = NULL;
g_settings_get (
settings, GVA_SETTING_SELECTED_MATCH,
"(ss)", column_name, search_text);
/* The value may be unset. Treat it as a failure. */
if (*column_name == NULL || *search_text == NULL)
goto fail;
g_strstrip (*column_name);
g_strstrip (*search_text);
/* Both strings must be non-empty. */
if (**column_name == '\0' || **search_text == '\0')
goto fail;
return TRUE;
fail:
g_free (*column_name);
g_free (*search_text);
*column_name = *search_text = NULL;
return FALSE;
}
static void
fr_file_selector_dialog_get_default_size (FrFileSelectorDialog *self,
int *default_width,
int *default_height)
{
int width, height;
g_settings_get (self->priv->settings, PREF_FILE_SELECTOR_WINDOW_SIZE, "(ii)", &width, &height);
if ((width > 0) && (height > 0)) {
*default_width = width;
*default_height = height;
return;
}
find_good_window_size_from_style (GTK_WIDGET (self), default_width, default_height);
if ((self->priv->extra_widget != NULL) && gtk_widget_get_visible (self->priv->extra_widget)) {
GtkRequisition req;
gtk_widget_get_preferred_size (GET_WIDGET ("extra_widget_container"), &req, NULL);
*default_height += gtk_box_get_spacing (GTK_BOX (GET_WIDGET ("content"))) + req.height;
}
}
static void
terminal_app_encoding_list_notify_cb (GSettings *settings,
const char *key,
TerminalApp *app)
{
gs_strfreev char **encodings = NULL;
int i;
TerminalEncoding *encoding;
app->encodings_locked = !g_settings_is_writable (settings, key);
/* Mark all as non-active, then re-enable the active ones */
g_hash_table_foreach (app->encodings, (GHFunc) encoding_mark_active, GUINT_TO_POINTER (FALSE));
/* First add the locale's charset */
encoding = g_hash_table_lookup (app->encodings, "current");
g_assert (encoding);
if (terminal_encoding_is_valid (encoding))
encoding->is_active = TRUE;
/* Also always make UTF-8 available */
encoding = g_hash_table_lookup (app->encodings, "UTF-8");
g_assert (encoding);
if (terminal_encoding_is_valid (encoding))
encoding->is_active = TRUE;
g_settings_get (settings, key, "^as", &encodings);
for (i = 0; encodings[i] != NULL; ++i) {
encoding = terminal_app_ensure_encoding (app, encodings[i]);
if (!terminal_encoding_is_valid (encoding))
continue;
encoding->is_active = TRUE;
}
g_signal_emit (app, signals[ENCODING_LIST_CHANGED], 0);
}
/* Create the preferences dialog. */
void
preferences_create(ChimaraGlk *glk)
{
/* Initialize the tree of style names */
GtkTreeStore *style_list = GTK_TREE_STORE( load_object("style-list") );
GtkTreeIter buffer, grid, buffer_child, grid_child;
gtk_tree_store_append(style_list, &buffer, NULL);
gtk_tree_store_append(style_list, &grid, NULL);
gtk_tree_store_set(style_list, &buffer, 0, "Text buffer", -1);
gtk_tree_store_set(style_list, &grid, 0, "Text grid", -1);
unsigned i, num_tags;
const char * const *tag_names = chimara_glk_get_tag_names(glk, &num_tags);
for(i=0; i<num_tags; i++) {
gtk_tree_store_append(style_list, &buffer_child, &buffer);
gtk_tree_store_append(style_list, &grid_child, &grid);
gtk_tree_store_set(style_list, &buffer_child, 0, tag_names[i], -1);
gtk_tree_store_set(style_list, &grid_child, 0, tag_names[i], -1);
}
/* Set selection mode to single select */
GtkTreeView *view = GTK_TREE_VIEW( load_object("style-treeview") );
GtkTreeSelection *selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(style_tree_select_callback), glk);
/* Bind the preferences to the entries in the preferences file */
extern GSettings *prefs_settings;
GObject *flep = G_OBJECT( load_object("flep") );
g_settings_bind(prefs_settings, "flep", flep, "active", G_SETTINGS_BIND_DEFAULT);
GtkFileChooser *blorb_chooser = GTK_FILE_CHOOSER( load_object("blorb_file_chooser") );
GtkFileChooser *css_chooser = GTK_FILE_CHOOSER( load_object("css-filechooser") );
char *filename;
g_settings_get(prefs_settings, "resource-path", "ms", &filename);
if(filename) {
gtk_file_chooser_set_filename(blorb_chooser, filename);
g_free(filename);
}
g_settings_get(prefs_settings, "css-file", "ms", &filename);
if(filename) {
if(!chimara_glk_set_css_from_file(glk, filename, NULL)) {
/* If the setting didn't point to a CSS file, fail silently and
null the setting */
g_settings_set(prefs_settings, "css-file", "ms", NULL);
} else {
gtk_file_chooser_set_filename(css_chooser, filename);
}
g_free(filename);
}
/* Populate the list of available interpreters */
GtkListStore *interp_list = GTK_LIST_STORE( load_object("available_interpreters") );
unsigned int count;
GtkTreeIter tree_iter;
for(count = 0; count < CHIMARA_IF_NUM_INTERPRETERS; count++) {
gtk_list_store_append(interp_list, &tree_iter);
gtk_list_store_set(interp_list, &tree_iter,
0, interpreter_to_display_string(count),
-1);
}
/* Get the list of preferred interpreters from the preferences */
GVariantIter *iter;
char *format, *plugin;
g_settings_get(prefs_settings, "preferred-interpreters", "a{ss}", &iter);
while(g_variant_iter_loop(iter, "{ss}", &format, &plugin)) {
ChimaraIFFormat format_num = parse_format(format);
if(format_num == CHIMARA_IF_FORMAT_NONE)
continue;
ChimaraIFInterpreter interp_num = parse_interpreter(plugin);
if(interp_num == CHIMARA_IF_INTERPRETER_NONE)
continue;
chimara_if_set_preferred_interpreter(CHIMARA_IF(glk), format_num, interp_num);
}
g_variant_iter_free(iter);
/* Display it all in the list */
preferred_list = GTK_LIST_STORE( load_object("interpreters") );
for(count = 0; count < CHIMARA_IF_NUM_FORMATS; count++) {
gtk_list_store_append(preferred_list, &tree_iter);
gtk_list_store_set(preferred_list, &tree_iter,
0, format_to_display_string(count),
1, interpreter_to_display_string(chimara_if_get_preferred_interpreter(CHIMARA_IF(glk), count)),
-1);
}
}
void
create_main_window (GsmApplication *app)
{
GtkApplicationWindow *main_window;
GtkStack *stack;
GtkMenuButton *process_menu_button;
GMenuModel *process_menu_model;
GdkDisplay *display;
GdkMonitor *monitor;
GdkRectangle monitor_geometry;
const char* session;
int width, height, xpos, ypos;
GtkBuilder *builder = gtk_builder_new();
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL);
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL);
main_window = GTK_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window"));
gtk_window_set_application (GTK_WINDOW (main_window), app->gobj());
gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor");
app->main_window = main_window;
session = g_getenv ("XDG_CURRENT_DESKTOP");
if (session && !strstr (session, "GNOME")){
GtkBox *mainbox;
GtkHeaderBar *headerbar;
mainbox = GTK_BOX (gtk_builder_get_object (builder, "main_box"));
headerbar = GTK_HEADER_BAR (gtk_builder_get_object (builder, "header_bar"));
gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET (headerbar)), "titlebar");
gtk_window_set_titlebar (GTK_WINDOW (main_window), NULL);
gtk_header_bar_set_show_close_button (headerbar, FALSE);
gtk_box_pack_start (mainbox, GTK_WIDGET (headerbar), FALSE, FALSE, 0);
}
g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)",
&width, &height, &xpos, &ypos);
display = gdk_display_get_default ();
monitor = gdk_display_get_monitor_at_point (display, xpos, ypos);
if (monitor == NULL) {
monitor = gdk_display_get_monitor (display, 0);
}
gdk_monitor_get_geometry (monitor, &monitor_geometry);
width = CLAMP (width, 50, monitor_geometry.width);
height = CLAMP (height, 50, monitor_geometry.height);
xpos = CLAMP (xpos, 0, monitor_geometry.width - width);
ypos = CLAMP (ypos, 0, monitor_geometry.height - height);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
gtk_window_move (GTK_WINDOW (main_window), xpos, ypos);
if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED))
gtk_window_maximize (GTK_WINDOW (main_window));
app->process_menu_button = process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button"));
process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu"));
gtk_menu_button_set_menu_model (process_menu_button, process_menu_model);
app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button"));
app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button"));
GActionEntry win_action_entries[] = {
{ "about", on_activate_about, NULL, NULL, NULL },
{ "search", on_activate_search, "b", "false", NULL },
{ "send-signal-stop", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-cont", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-end", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-kill", on_activate_send_signal, "i", NULL, NULL },
{ "priority", on_activate_priority, "i", "@i 0", change_priority_state },
{ "memory-maps", on_activate_memory_maps, NULL, NULL, NULL },
{ "open-files", on_activate_open_files, NULL, NULL, NULL },
{ "process-properties", on_activate_process_properties, NULL, NULL, NULL },
{ "refresh", on_activate_refresh, NULL, NULL, NULL },
{ "show-page", on_activate_radio, "s", "'resources'", change_show_page_state },
{ "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state },
{ "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state }
};
g_action_map_add_action_entries (G_ACTION_MAP (main_window),
win_action_entries,
G_N_ELEMENTS (win_action_entries),
app);
GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window));
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
/* use visual, if available */
if (visual)
gtk_widget_set_visual(GTK_WIDGET (main_window), visual);
/* create the main stack */
app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack"));
create_proc_view(app, builder);
create_sys_view (app, builder);
create_disk_view (app, builder);
g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT);
g_signal_connect (G_OBJECT (stack), "notify::visible-child",
G_CALLBACK (cb_change_current_page), app);
g_signal_connect (G_OBJECT (main_window), "delete_event",
G_CALLBACK (cb_main_window_delete),
app);
g_signal_connect (G_OBJECT (main_window), "window-state-event",
G_CALLBACK (cb_main_window_state_changed),
app);
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-dependencies");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES));
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-whose-processes");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES));
gtk_widget_show (GTK_WIDGET (main_window));
update_page_activities (app);
g_object_unref (G_OBJECT (builder));
}
void
modeline_parser_apply_modeline (GtkSourceView *view)
{
ModelineOptions options;
GtkTextBuffer *buffer;
GtkTextIter iter, liter;
gint line_count;
GSettings *settings;
options.language_id = NULL;
options.set = MODELINE_SET_NONE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
gtk_text_buffer_get_start_iter (buffer, &iter);
line_count = gtk_text_buffer_get_line_count (buffer);
/* Parse the modelines on the 10 first lines... */
while ((gtk_text_iter_get_line (&iter) < 10) &&
!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* ...and on the 10 last ones (modelines are not allowed in between) */
if (!gtk_text_iter_is_end (&iter))
{
gint cur_line;
guint remaining_lines;
/* we are on the 11th line (count from 0) */
cur_line = gtk_text_iter_get_line (&iter);
/* g_assert (10 == cur_line); */
remaining_lines = line_count - cur_line - 1;
if (remaining_lines > 10)
{
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_iter_backward_lines (&iter, 9);
}
}
while (!gtk_text_iter_is_end (&iter))
{
gchar *line;
liter = iter;
gtk_text_iter_forward_to_line_end (&iter);
line = gtk_text_buffer_get_text (buffer, &liter, &iter, TRUE);
parse_modeline (line,
1 + gtk_text_iter_get_line (&iter),
line_count,
&options);
gtk_text_iter_forward_line (&iter);
g_free (line);
}
/* Try to set language */
if (has_option (&options, MODELINE_SET_LANGUAGE) && options.language_id)
{
if (g_ascii_strcasecmp (options.language_id, "text") == 0)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
NULL);
}
else
{
GtkSourceLanguageManager *manager;
GtkSourceLanguage *language;
manager = gedit_get_language_manager ();
language = gtk_source_language_manager_get_language
(manager, options.language_id);
if (language != NULL)
{
gedit_document_set_language (GEDIT_DOCUMENT (buffer),
language);
}
else
{
gedit_debug_message (DEBUG_PLUGINS,
"Unknown language `%s'",
options.language_id);
}
}
}
ModelineOptions *previous = g_object_get_data (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY);
settings = g_settings_new ("org.gnome.gedit.preferences.editor");
/* Apply the options we got from modelines and restore defaults if
we set them before */
if (has_option (&options, MODELINE_SET_INSERT_SPACES))
{
gtk_source_view_set_insert_spaces_instead_of_tabs
(view, options.insert_spaces);
}
else if (check_previous (view, previous, MODELINE_SET_INSERT_SPACES))
{
gboolean insert_spaces;
insert_spaces = g_settings_get_boolean (settings, GEDIT_SETTINGS_INSERT_SPACES);
gtk_source_view_set_insert_spaces_instead_of_tabs (view, insert_spaces);
}
if (has_option (&options, MODELINE_SET_TAB_WIDTH))
{
gtk_source_view_set_tab_width (view, options.tab_width);
}
else if (check_previous (view, previous, MODELINE_SET_TAB_WIDTH))
{
guint tab_width;
g_settings_get (settings, GEDIT_SETTINGS_TABS_SIZE, "u", &tab_width);
gtk_source_view_set_tab_width (view, tab_width);
}
if (has_option (&options, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, options.indent_width);
}
else if (check_previous (view, previous, MODELINE_SET_INDENT_WIDTH))
{
gtk_source_view_set_indent_width (view, -1);
}
if (has_option (&options, MODELINE_SET_WRAP_MODE))
{
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), options.wrap_mode);
}
else if (check_previous (view, previous, MODELINE_SET_WRAP_MODE))
{
GtkWrapMode mode;
mode = g_settings_get_enum (settings,
GEDIT_SETTINGS_WRAP_MODE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), mode);
}
if (has_option (&options, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
gtk_source_view_set_right_margin_position (view, options.right_margin_position);
}
else if (check_previous (view, previous, MODELINE_SET_RIGHT_MARGIN_POSITION))
{
guint right_margin_pos;
g_settings_get (settings, GEDIT_SETTINGS_RIGHT_MARGIN_POSITION, "u",
&right_margin_pos);
gtk_source_view_set_right_margin_position (view,
right_margin_pos);
}
if (has_option (&options, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gtk_source_view_set_show_right_margin (view, options.display_right_margin);
}
else if (check_previous (view, previous, MODELINE_SET_SHOW_RIGHT_MARGIN))
{
gboolean display_right_margin;
display_right_margin = g_settings_get_boolean (settings,
GEDIT_SETTINGS_DISPLAY_RIGHT_MARGIN);
gtk_source_view_set_show_right_margin (view, display_right_margin);
}
if (previous)
{
g_free (previous->language_id);
*previous = options;
previous->language_id = g_strdup (options.language_id);
}
else
{
previous = g_slice_new (ModelineOptions);
*previous = options;
previous->language_id = g_strdup (options.language_id);
g_object_set_data_full (G_OBJECT (buffer),
MODELINE_OPTIONS_DATA_KEY,
previous,
(GDestroyNotify)free_modeline_options);
}
g_object_unref (settings);
g_free (options.language_id);
}