gint
tracker_config_get_verbosity (TrackerConfig *config)
{
g_return_val_if_fail (TRACKER_IS_CONFIG (config), 0);
return g_settings_get_enum (G_SETTINGS (config), "verbosity");
}
gboolean
xmr_settings_get_auto_login(XmrSettings *sett)
{
g_return_val_if_fail(sett != NULL, FALSE);
return g_settings_get_boolean(G_SETTINGS(sett), "auto-login");
}
static void
bjb_settings_constructed (GObject *object)
{
BjbSettings *self;
GSettings *settings;
G_OBJECT_CLASS (bjb_settings_parent_class)->constructed (object);
self = BJB_SETTINGS (object);
settings = G_SETTINGS (object);
self->priv->system = g_settings_new ("org.gnome.desktop.interface");
g_settings_bind (settings, "use-system-font",
self, "use-system-font",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "font",
self, "font",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "color",
self, "color",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (settings, "default-location",
self, "default-location",
G_SETTINGS_BIND_DEFAULT);
}
gint
tracker_config_get_graphupdated_delay (TrackerConfig *config)
{
g_return_val_if_fail (TRACKER_IS_CONFIG (config), GRAPHUPDATED_DELAY_DEFAULT);
return g_settings_get_int (G_SETTINGS (config), "graphupdated-delay");
}
gchar*
xmr_settings_get_theme(XmrSettings *sett)
{
g_return_val_if_fail(sett != NULL, NULL);
return g_settings_get_string(G_SETTINGS(sett), "theme");
}
static void
config_constructed (GObject *object)
{
GSettings *settings;
(G_OBJECT_CLASS (tracker_config_parent_class)->constructed) (object);
settings = G_SETTINGS (object);
if (G_LIKELY (!g_getenv ("TRACKER_USE_CONFIG_FILES"))) {
g_settings_delay (settings);
}
/* Set up bindings:
*
* What's interesting here is that 'verbosity' and
* 'initial-sleep' are command line arguments that can be
* overridden, so we don't update the config when we set them
* from main() because it's a session configuration only, not
* a permanent one. To do this we use the flag
* G_SETTINGS_BIND_GET_NO_CHANGES.
*
* For the other settings, we don't bind the
* G_SETTINGS_BIND_SET because we don't want to save anything,
* ever, we only want to know about updates to the settings as
* they're changed externally. The only time this may be
* different is where we use the environment variable
* TRACKER_USE_CONFIG_FILES and we want to write a config
* file for convenience. But this is only necessary if the
* config is different to the default.
*/
g_settings_bind (settings, "verbosity", object, "verbosity", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_GET_NO_CHANGES);
g_settings_bind (settings, "graphupdated-delay", object, "graphupdated-delay", G_SETTINGS_BIND_GET);
}
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;
}
gboolean
xmr_settings_set_theme(XmrSettings *sett,
const gchar *theme)
{
g_return_val_if_fail(sett != NULL, FALSE);
return g_settings_set_string(G_SETTINGS(sett), "theme", theme);
}
gboolean
xmr_settings_set_window_pos(XmrSettings *sett,
gint x, gint y)
{
g_return_val_if_fail( sett != NULL, FALSE);
return g_settings_set(G_SETTINGS(sett), "window-pos", "(ii)", x, y);
}
static void
config_constructed (GObject *object)
{
TrackerConfigFile *config_file;
(G_OBJECT_CLASS (tracker_config_parent_class)->constructed) (object);
g_settings_delay (G_SETTINGS (object));
/* Migrate keyfile-based configuration */
config_file = tracker_config_file_new ();
if (config_file) {
tracker_config_file_migrate (config_file, G_SETTINGS (object), migration);
g_object_unref (config_file);
}
}
void deja_dup_simple_settings_apply (DejaDupSimpleSettings* self) {
gboolean _tmp0_;
g_return_if_fail (self != NULL);
_tmp0_ = self->priv->_read_only;
if (!_tmp0_) {
g_settings_apply (G_SETTINGS (self));
}
}
void
tracker_config_set_graphupdated_delay (TrackerConfig *config,
gint value)
{
g_return_if_fail (TRACKER_IS_CONFIG (config));
g_settings_set_int(G_SETTINGS (config), "graphupdated-delay", value);
g_object_notify (G_OBJECT (config), "graphupdated-delay");
}
void
tracker_config_set_verbosity (TrackerConfig *config,
gint value)
{
g_return_if_fail (TRACKER_IS_CONFIG (config));
g_settings_set_enum (G_SETTINGS (config), "verbosity", value);
g_object_notify (G_OBJECT (config), "verbosity");
}
static void
pd_transp_radio_toggle_cb (GtkWidget *widget, gpointer data)
{
gpointer value = NULL;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
return;
value = g_object_get_data (G_OBJECT (widget), GSETTINGS_OBJECT_VALUE);
g_settings_set_enum (G_SETTINGS (data), EOM_CONF_VIEW_TRANSPARENCY,
GPOINTER_TO_INT (value));
}
void deja_dup_simple_settings_set_int (DejaDupSimpleSettings* self, const gchar* k, gint v) {
const gchar* _tmp0_;
gint _tmp1_ = 0;
gint _tmp2_;
g_return_if_fail (self != NULL);
g_return_if_fail (k != NULL);
_tmp0_ = k;
_tmp1_ = g_settings_get_int ((GSettings*) self, _tmp0_);
_tmp2_ = v;
if (_tmp1_ != _tmp2_) {
const gchar* _tmp3_;
gint _tmp4_;
_tmp3_ = k;
_tmp4_ = v;
g_settings_set_int (G_SETTINGS (self), _tmp3_, _tmp4_);
}
}
GList* w_settings_get_city_id_list(wSettings *sett)
{
GList *list = NULL;
gchar **city_id;
gint i = 0;
g_return_val_if_fail(sett != NULL, 0);
city_id = g_settings_get_strv(G_SETTINGS(sett), "city-id");
if (city_id == NULL)
return NULL;
while(city_id[i])
{
list = g_list_append(list, city_id[i]);
i++;
}
return list;
}
static gboolean
save_column_width (gpointer data)
{
gint width;
gchar *key;
int id;
GSettings *settings;
settings = g_settings_get_child (G_SETTINGS (data), "disktreenew");
id = gtk_tree_view_column_get_sort_column_id (current_column);
width = gtk_tree_view_column_get_width (current_column);
key = g_strdup_printf ("col-%d-width", id);
g_settings_set_int(settings, key, width);
g_free (key);
if (timeout_id) {
g_source_remove (timeout_id);
timeout_id = 0;
}
return FALSE;
}
void deja_dup_simple_settings_set_string (DejaDupSimpleSettings* self, const gchar* k, const gchar* v) {
const gchar* _tmp0_;
gchar* _tmp1_ = NULL;
gchar* _tmp2_;
const gchar* _tmp3_;
gboolean _tmp4_;
g_return_if_fail (self != NULL);
g_return_if_fail (k != NULL);
g_return_if_fail (v != NULL);
_tmp0_ = k;
_tmp1_ = g_settings_get_string ((GSettings*) self, _tmp0_);
_tmp2_ = _tmp1_;
_tmp3_ = v;
_tmp4_ = g_strcmp0 (_tmp2_, _tmp3_) != 0;
_g_free0 (_tmp2_);
if (_tmp4_) {
const gchar* _tmp5_;
const gchar* _tmp6_;
_tmp5_ = k;
_tmp6_ = v;
g_settings_set_string (G_SETTINGS (self), _tmp5_, _tmp6_);
}
}
static gboolean
bjb_application_window_configured (GtkWidget *widget,
GdkEvent *event,
gpointer user_data)
{
BjbWindowBase *win;
GSettings *settings;
GVariant *variant;
GdkWindowState state;
gint32 size[2];
gint32 position[2];
win = BJB_WINDOW_BASE (user_data);
settings = G_SETTINGS (win->priv->settings);
state = gdk_window_get_state (gtk_widget_get_window (widget));
if (state & GDK_WINDOW_STATE_MAXIMIZED)
return FALSE;
gtk_window_get_size (GTK_WINDOW (win),
(gint *) &size[0],
(gint *) &size[1]);
variant = g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
size, 2,
sizeof (size[0]));
g_settings_set_value (settings, "window-size", variant);
gtk_window_get_position (GTK_WINDOW (win),
(gint *) &position[0],
(gint *) &position[1]);
variant = g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
position, 2,
sizeof (position[0]));
g_settings_set_value (settings, "window-position", variant);
return FALSE;
}
gboolean w_settings_get_weather(wSettings *sett, GList **list)
{
gchar **city_id;
gchar **city;
gchar **weather[3];
gchar **wind[3];
gchar **temp[3];
gchar **img[3];
gchar **rtemp;
gchar name[10];
int i;
g_return_val_if_fail(sett != NULL && list != NULL, FALSE);
city_id = g_settings_get_strv(G_SETTINGS(sett), "city-id");
if (city_id == NULL)
return TRUE;
city = g_settings_get_strv(G_SETTINGS(sett), "city");
if (city == NULL)
{
g_strfreev(city_id);
return TRUE;
}
rtemp = g_settings_get_strv(G_SETTINGS(sett), "temp");
i = g_strv_length(city_id);
if (i != g_strv_length(rtemp))
{
// temp is newly added
// to avoid 'Segmentation fault'
g_strfreev(rtemp);
rtemp = (gchar **)g_malloc0(i);
}
for(i=0; i<3; ++i)
{
g_snprintf(name, 10, "%s%d", _names[0], i + 1);
weather[i] = g_settings_get_strv(G_SETTINGS(sett), name);
g_snprintf(name, 10, "%s%d", _names[1], i + 1);
wind[i] = g_settings_get_strv(G_SETTINGS(sett), name);
g_snprintf(name, 10, "%s%d", _names[2], i + 1);
temp[i] = g_settings_get_strv(G_SETTINGS(sett), name);
g_snprintf(name, 10, "%s%d", _names[3], i + 1);
img[i] = g_settings_get_strv(G_SETTINGS(sett), name);
}
i = 0;
while(city_id[i])
{
WeatherInfo *wi;
gint j;
wi = weather_new_info();
if (wi == NULL)
g_error("weather_new_info failed (%s, %d)\n", __FILE__, __LINE__);
wi->city_id = city_id[i];
wi->city = city[i];
wi->temp = rtemp[i];
for(j=0; j<3; ++j)
{
wi->weather[j].temperature = temp[j][i];
wi->weather[j].wind = wind[j][i];
wi->weather[j].weather = weather[j][i];
wi->weather[j].img = g_strtod(img[j][i], NULL);
}
*list = g_list_append(*list, wi);
i++;
}
for(i=0; i<3; ++i)
g_strfreev(img[i]);
return TRUE;
}
gboolean w_settings_set_show_tray(wSettings *sett, gboolean value)
{
g_return_val_if_fail(sett != NULL, FALSE);
return g_settings_set_boolean(G_SETTINGS(sett), "tray", value);
}
gboolean w_settings_get_show_tray(wSettings *sett)
{
g_return_val_if_fail(sett != NULL, TRUE);
return g_settings_get_boolean(G_SETTINGS(sett), "tray");
}
gboolean w_settings_set_window_state(wSettings *sett, gboolean value)
{
g_return_val_if_fail(sett != NULL, FALSE);
return g_settings_set_boolean(G_SETTINGS(sett), "window-maximized", value);
}
gboolean w_settings_set_duration(wSettings *sett, gint t)
{
g_return_val_if_fail( sett != NULL, FALSE);
return g_settings_set_int(G_SETTINGS(sett), "duration", t);
}
gint w_settings_get_duration(wSettings *sett)
{
g_return_val_if_fail( sett != NULL, 0);
return g_settings_get_int(G_SETTINGS(sett), "duration");
}
gboolean w_settings_set_window_size(wSettings *sett, gint w, gint h)
{
g_return_val_if_fail( sett != NULL, FALSE);
return g_settings_set(G_SETTINGS(sett), "window-size", "(ii)", w, h);
}
gboolean w_settings_set_weather(wSettings *sett, GList *list)
{
gchar name[10];
gint i, count;
GList *p;
gchar **city_id = NULL;
gchar **city = NULL;
gchar **temp[3] = {NULL};
gchar **wind[3] = {NULL};
gchar **weather[3] = {NULL};
gchar **img[3] = {NULL};
gchar **rtemp = NULL;
g_return_val_if_fail(sett != NULL, FALSE);
count = g_list_length(list);
if (count > 0)
{
count = (count + 1) * sizeof(gchar *);
city_id = (gchar **)g_malloc0(count);
if (city_id == NULL)
return FALSE;
city = (gchar **)g_malloc0(count);
rtemp = (gchar **)g_malloc0(count);
for(i=0; i<3; ++i)
{
temp[i] = (gchar **)g_malloc0(count);
wind[i] = (gchar **)g_malloc0(count);
weather[i] = (gchar **)g_malloc0(count);
img[i] = (gchar **)g_malloc0(count);
}
}
p = list;
i = 0;
while (p && city_id != NULL)
{
WeatherInfo *wi = (WeatherInfo *)p->data;
gint j;
city_id[i] = wi->city_id;
city[i] = wi->city;
rtemp[i] = wi->temp;
for(j=0; j<3; ++j)
{
temp[j][i] = wi->weather[j].temperature;
wind[j][i] = wi->weather[j].wind;
weather[j][i] = wi->weather[j].weather;
img[j][i] = g_strdup_printf("%d", wi->weather[j].img);
}
p = p->next;
i++;
}
g_settings_set_strv(G_SETTINGS(sett), "city", (const gchar * const*)city);
g_settings_set_strv(G_SETTINGS(sett), "city-id", (const gchar * const*)city_id);
g_settings_set_strv(G_SETTINGS(sett), "temp", (const gchar * const*)rtemp);
for(i=0; i<3; ++i)
{
g_snprintf(name, 10, "%s%d", _names[0], i + 1);
g_settings_set_strv(G_SETTINGS(sett), name, (const gchar * const*)weather[i]);
g_snprintf(name, 10, "%s%d", _names[1], i + 1);
g_settings_set_strv(G_SETTINGS(sett), name, (const gchar * const*)wind[i]);
g_snprintf(name, 10, "%s%d", _names[2], i + 1);
g_settings_set_strv(G_SETTINGS(sett), name, (const gchar * const*)temp[i]);
g_snprintf(name, 10, "%s%d", _names[3], i + 1);
g_settings_set_strv(G_SETTINGS(sett), name, (const gchar * const*)img[i]);
}
if (city_id != NULL)
{
g_free(city_id);
g_free(city);
g_free(rtemp);
for(i=0; i<3; ++i)
{
g_free(weather[i]);
g_free(wind[i]);
g_free(temp[i]);
g_strfreev(img[i]);
}
}
return TRUE;
}
/* Gobj */
static void
bjb_window_base_constructed (GObject *obj)
{
BjbWindowBase *self = BJB_WINDOW_BASE (obj);
BjbWindowBasePriv *priv;
gboolean maximized;
const gint32 *position;
const gint32 *size;
gsize n_elements;
GVariant *variant;
G_OBJECT_CLASS (bjb_window_base_parent_class)->constructed (obj);
priv = self->priv;
priv->settings = bjb_app_get_settings ((gpointer) g_application_get_default ());
gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (self), _(BIJIBEN_MAIN_WIN_TITLE));
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-size");
size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]);
g_variant_unref (variant);
variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-position");
position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32));
if (n_elements == 2)
gtk_window_move (GTK_WINDOW (self), position[0], position[1]);
g_variant_unref (variant);
maximized = g_settings_get_boolean (G_SETTINGS (priv->settings), "window-maximized");
if (maximized)
gtk_window_maximize (GTK_WINDOW (self));
/* We probably want to offer a no entry window at first (startup) */
priv->entry = NULL ;
priv->controller = bjb_controller_new
(bijiben_get_manager (BIJIBEN_APPLICATION(g_application_get_default())),
GTK_WINDOW (obj),
priv->entry );
/* Shared toolbar */
priv->view = bjb_main_view_new (GTK_WIDGET (obj), priv->controller);
priv->main_toolbar = bjb_main_toolbar_new (priv->view, priv->controller);
gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->main_toolbar));
/* Search entry toolbar */
priv->search_bar = bjb_search_toolbar_new (GTK_WIDGET (obj), priv->controller);
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->search_bar), FALSE, FALSE, 0);
/* UI : stack for different views */
priv->stack = GTK_STACK (gtk_stack_new ());
gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->stack), TRUE, TRUE, 0);
priv->spinner = gtk_spinner_new ();
gtk_stack_add_named (priv->stack, priv->spinner, "spinner");
gtk_stack_set_visible_child_name (priv->stack, "spinner");
gtk_widget_show (priv->spinner);
gtk_spinner_start (GTK_SPINNER (priv->spinner));
priv->no_note = bjb_empty_results_box_new ();
gtk_stack_add_named (priv->stack, priv->no_note, "empty");
gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->view), "main-view");
gtk_widget_show (GTK_WIDGET (priv->stack));
/* Connection to window signals */
g_signal_connect (GTK_WIDGET (self),
"destroy",
G_CALLBACK (bjb_window_base_destroy),
self);
g_signal_connect (self,
"window-state-event",
G_CALLBACK (bjb_application_window_state_changed),
priv->settings);
g_signal_connect (self,
"configure-event",
G_CALLBACK (bjb_application_window_configured),
self);
/* Keys */
g_signal_connect (GTK_WIDGET (self),
"key-press-event",
G_CALLBACK(on_key_pressed_cb),
self);
/* If a note is requested at creation, show it
* This is a specific type of window not associated with any view */
if (priv->note == NULL)
{
bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW);
}
else
{
priv->detached = TRUE;
bjb_window_base_switch_to_item (self, BIJI_ITEM (priv->note));
}
/* For some reason, do not gtk_widget_show _self_
* or gtk_application_get_menu_bar will run,
* fire a warning, while app menu will not show up
* you have been warned!
*
* This is probably due to the fact that,
* at startup, we still are
* inside... drums... gapplication startup () */
gtk_widget_show (priv->vbox);
}
