/*

* Helper functions to translate statuses and actions to strings

* Copyright (C) 2008 Bastien Nocera <[email protected]>

* Experimental code. This will be moved out of fprintd into it's own

* package once the system has matured.

*

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License along

* with this program; if not, write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

cairo_font_options_t *opt;

cairo_antialias_t aa;

cairo_hint_style_t hs;

switch (antialiasing) {

case ANTIALIAS_NONE:

aa = CAIRO_ANTIALIAS_NONE;

conv_data = g_new (ThemeConvData, 1);

conv_data->data = data;

conv_data->thumbnail = thumbnail;

/* set useful data for callbacks */

g_object_set_data_full (G_OBJECT (list), THEME_DATA, conv_data, g_free);

g_object_set_data (G_OBJECT (list), GSETTINGS_SETTINGS, settings);

g_object_set_data_full (G_OBJECT (list), GSETTINGS_KEY, g_strdup(key), g_free);

/* select in treeview the theme set in gsettings */

GtkTreeModel *treemodel;

treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (list));

}

if (theme)

g_free (theme);

/* connect to gsettings change event */

gchar *signal_name = g_strdup_printf("changed::%s", key);

g_signal_connect (settings, signal_name,

}

/* Returns FALSE if activation failed, else TRUE */

activate_settings_daemon (void)

{

DBusGConnection *connection = NULL;

g_error_free (error);

return FALSE;

}

proxy = dbus_g_proxy_new_for_name (connection,

"org.mate.SettingsDaemon",

"/org/mate/SettingsDaemon",

/* First look in the users home directory

*/

home_dir = g_get_home_dir();

if (home_dir)

{

path = g_build_filename(home_dir, ".themes", name, subpath, NULL);

if (!g_file_test (path, G_FILE_TEST_EXISTS))

{

g_free (path);

}

files = g_slist_prepend (files, g_strdup (filename));

while (files != NULL)

{

filename = files->data;

interface_settings = g_settings_new (INTERFACE_SCHEMA);

marco_settings = g_settings_new (MARCO_SCHEMA);

mouse_settings = g_settings_new (MOUSE_SCHEMA);

if (mate_gsettings_schema_exists (NOTIFICATION_SCHEMA))

{

notification_settings = g_settings_new (NOTIFICATION_SCHEMA);

if (index < g_list_length(list))

{

item = (GAppInfo*) g_list_nth_data(list, index);

switch (type)

{

case DA_TYPE_WEB_BROWSER:

g_app_info_set_as_default_for_type(item, "application/x-extension-eml", NULL);

g_app_info_set_as_default_for_type(item, "message/rfc822", NULL);

break;

case DA_TYPE_FILE:

g_app_info_set_as_default_for_type(item, "inode/directory", NULL);

break;

case DA_TYPE_TEXT:

g_app_info_set_as_default_for_type(item, "text/plain", NULL);

break;

g_app_info_set_as_default_for_type(item, "audio/x-vorbis+ogg", NULL);

g_app_info_set_as_default_for_type(item, "audio/x-wav", NULL);

break;

case DA_TYPE_VIDEO:

g_app_info_set_as_default_for_type(item, "video/mp4", NULL);

g_app_info_set_as_default_for_type(item, "video/mpeg", NULL);

return;

valid = gtk_tree_model_get_iter_first(model, &iter);

while (valid)

{

gtk_tree_model_get(model, &iter,

{

g_object_unref(pixbuf);

}

g_free(icon_name);

valid = gtk_tree_model_iter_next(model, &iter);

GdkPixbuf* pixbuf = gtk_icon_info_load_icon(icon_info, NULL);

gtk_image_set_from_pixbuf(GTK_IMAGE(icon), pixbuf);

if (pixbuf)

{

g_object_unref(pixbuf);

for (entry = app_list; entry != NULL; entry = g_list_next(entry))

{

GAppInfo* item = (GAppInfo*) entry->data;

/* Icon */

GIcon* icon = g_app_info_get_icon(item);

gchar* icon_name;

} else {

icon_name = g_strdup ("binary");

}

GtkIconInfo* icon_info = gtk_icon_theme_lookup_icon (theme, icon_name, 22, GTK_ICON_LOOKUP_FORCE_SIZE);

pixbuf = gtk_icon_info_load_icon(icon_info, NULL);

{

g_object_unref(pixbuf);

}

/* Set the index for the default app */

if (default_app != NULL && g_app_info_equal(item, default_app))

{

gtk_combo_box_set_active(combo_box, index);

}

g_free(icon_name);

index++;

}

}

nb = GTK_NOTEBOOK(get_widget("preferred_apps_notebook"));

pindex = gtk_notebook_page_num(nb, w);

if (pindex != -1)

{

gtk_notebook_set_current_page(nb, pindex);

struct FooScrollAreaPrivate

{

GdkWindow *input_window;

int width;

int height;

GtkAdjustment *hadj;

GtkAdjustment *vadj;

int x_offset;

int y_offset;

int min_width;

int min_height;

GPtrArray *input_regions;

AutoScrollInfo *auto_scroll_info;

InputRegion *current_input;

gboolean grabbed;

FooScrollAreaEventFunc grab_func;

gpointer grab_data;

foo_scroll_area_map (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

GTK_WIDGET_CLASS (parent_class)->map (widget);

if (area->priv->input_window)

gdk_window_show (area->priv->input_window);

}

foo_scroll_area_unmap (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

if (area->priv->input_window)

gdk_window_hide (area->priv->input_window);

GTK_WIDGET_CLASS (parent_class)->unmap (widget);

}

foo_scroll_area_finalize (GObject *object)

{

FooScrollArea *scroll_area = FOO_SCROLL_AREA (object);

g_object_unref (scroll_area->priv->hadj);

g_object_unref (scroll_area->priv->vadj);

g_ptr_array_free (scroll_area->priv->input_regions, TRUE);

g_free (scroll_area->priv);

G_OBJECT_CLASS (foo_scroll_area_parent_class)->finalize (object);

{

GObjectClass *object_class = G_OBJECT_CLASS (class);

GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);

object_class->finalize = foo_scroll_area_finalize;

object_class->set_property = foo_scroll_area_set_property;

object_class->get_property = foo_scroll_area_get_property;

G_TYPE_NONE, 2,

GDK_TYPE_RECTANGLE,

GDK_TYPE_RECTANGLE);

signals[PAINT] =

g_signal_new ("paint",

G_OBJECT_CLASS_TYPE (object_class),

gtk_widget_set_has_window (widget, FALSE);

gtk_widget_set_redraw_on_allocate (widget, FALSE);

scroll_area->priv = g_new0 (FooScrollAreaPrivate, 1);

scroll_area->priv->width = 0;

scroll_area->priv->height = 0;

gpointer user_data)

{

int i;

for (i = 0; i < path->num_data; i += path->data[i].header.length)

{

cairo_path_data_t *data = &(path->data[i]);

switch (data->header.type)

{

case CAIRO_PATH_MOVE_TO:

case CAIRO_PATH_LINE_TO:

func (&(data[1].point.x), &(data[1].point.y), user_data);

break;

case CAIRO_PATH_CURVE_TO:

func (&(data[1].point.x), &(data[1].point.y), user_data);

func (&(data[2].point.x), &(data[2].point.y), user_data);

func (&(data[3].point.x), &(data[3].point.y), user_data);

break;

case CAIRO_PATH_CLOSE_PATH:

break;

}

allocation_to_canvas (area, &allocation.x, &allocation.y);

viewport = cairo_region_create_rectangle (&allocation);

cairo_region_subtract (viewport, exposed);

for (i = 0; i < area->priv->input_regions->len; ++i)

{

InputRegion *region = area->priv->input_regions->pdata[i];

GdkRectangle *viewport)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

if (!viewport)

return;

get_viewport (scroll_area, viewport);

}

GdkDevice *pointer;

int px, py;

new_viewport, old_viewport);

if (scroll_area->priv->input_window == NULL)

&px,

&py,

NULL);

process_event (scroll_area, FOO_MOTION, px, py);

}

GtkAdjustment *hadj = scroll_area->priv->hadj;

GtkAdjustment *vadj = scroll_area->priv->vadj;

/* Horizontal */

gtk_widget_get_allocation (GTK_WIDGET (scroll_area), &allocation);

g_object_freeze_notify (G_OBJECT (hadj));

gtk_adjustment_set_lower (hadj, 0.0);

gtk_adjustment_set_upper (hadj, scroll_area->priv->width);

g_object_thaw_notify (G_OBJECT (hadj));

/* Vertical */

g_object_freeze_notify (G_OBJECT (vadj));

gtk_adjustment_set_page_size (vadj, allocation.height);

clamp_adjustment (hadj);

clamp_adjustment (vadj);

return TRUE;

}

gtk_widget_get_allocation (widget, &widget_allocation);

gtk_widget_set_realized (widget, TRUE);

attributes.window_type = GDK_WINDOW_CHILD;

attributes.x = widget_allocation.x;

attributes.y = widget_allocation.y;

GDK_POINTER_MOTION_MASK |

GDK_ENTER_NOTIFY_MASK |

GDK_LEAVE_NOTIFY_MASK);

attributes_mask = GDK_WA_X | GDK_WA_Y;

window = gtk_widget_get_parent_window (widget);

gtk_widget_set_window (widget, window);

g_object_ref (window);

area->priv->input_window = gdk_window_new (window,

&attributes, attributes_mask);

cr = gdk_cairo_create (gtk_widget_get_window (widget));

cairo_destroy (cr);

gdk_window_set_user_data (area->priv->input_window, area);

gtk_widget_style_attach (widget);

}

foo_scroll_area_unrealize (GtkWidget *widget)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

if (area->priv->input_window)

{

gdk_window_set_user_data (area->priv->input_window, NULL);

gdk_window_destroy (area->priv->input_window);

area->priv->input_window = NULL;

}

GTK_WIDGET_CLASS (parent_class)->unrealize (widget);

}

return new;

}

static void

allocation_to_canvas_region (FooScrollArea *area,

cairo_region_t *region)

cairo_region_destroy (invalid);

gtk_widget_set_allocation (widget, allocation);

if (scroll_area->priv->input_window)

{

cairo_surface_t *new_surface;

cairo_surface_destroy (scroll_area->priv->surface);

scroll_area->priv->surface = new_surface;

}

get_viewport (scroll_area, &new_viewport);

emit_viewport_changed (scroll_area, &new_viewport, &old_viewport);

}

gpointer data)

{

FooScrollAreaEvent event;

if (!func)

return;

if (type != FOO_MOTION)

emit_input (scroll_area, FOO_MOTION, x, y, func, data);

event.type = type;

event.x = x;

event.y = y;

func (scroll_area, &event, data);

}

int i;

allocation_to_canvas (scroll_area, &x, &y);

if (scroll_area->priv->grabbed)

{

emit_input (scroll_area, input_type, x, y,

inside = cairo_in_fill (cr, x, y);

cairo_destroy (cr);

if (inside)

{

emit_input (scroll_area, input_type,

path->data);

return;

}

path = path->next;

}

GdkEvent *event)

{

FooScrollAreaEventType input_type;

if (event->type == GDK_BUTTON_PRESS)

input_type = FOO_BUTTON_PRESS;

else if (event->type == GDK_BUTTON_RELEASE)

input_type = FOO_MOTION;

else

return;

process_event (scroll_area, input_type, x, y);

}

GdkEventButton *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return TRUE;

}

GdkEventButton *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return FALSE;

}

GdkEventMotion *event)

{

FooScrollArea *area = FOO_SCROLL_AREA (widget);

process_gdk_event (area, event->x, event->y, (GdkEvent *)event);

return TRUE;

}

g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj));

gtk_adjustment_set_value (scroll_area->priv->vadj, new_y);

set_adjustment_values (scroll_area);

g_object_thaw_notify (G_OBJECT (scroll_area->priv->vadj));

}

int height)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

/* FIXME: Default scroll algorithm should probably be to

* keep the same *area* outside the screen as before.

*

* Maybe there should be some generic support for those

* widgets. Can that even be done?

*

* fixed points?

*/

scroll_area->priv->width = width;

scroll_area->priv->height = height;

set_adjustment_values (scroll_area);

}

static void

foo_scroll_area_scroll (FooScrollArea *area,

gint dy)

{

GdkRectangle allocation;

src_area.y -= dy;

invalid_region = cairo_region_create_rectangle (&allocation);

if (gdk_rectangle_intersect (&allocation, &src_area, &move_area))

{

cairo_region_t *move_region;

cairo_destroy (cr);

gtk_widget_queue_draw (GTK_WIDGET (area));

move_region = cairo_region_create_rectangle (&move_area);

cairo_region_translate (move_region, dx, dy);

cairo_region_subtract (invalid_region, move_region);

cairo_region_destroy (move_region);

}

allocation_to_canvas_region (area, invalid_region);

foo_scroll_area_invalidate_region (area, invalid_region);

cairo_region_destroy (invalid_region);

}

gint dx = 0;

gint dy = 0;

GdkRectangle old_viewport, new_viewport;

get_viewport (scroll_area, &old_viewport);

if (adj == scroll_area->priv->hadj)

{

/* FIXME: do we treat the offset as int or double, and,

{

g_assert_not_reached ();

}

if (gtk_widget_get_realized (widget))

{

foo_scroll_area_scroll (scroll_area, -dx, -dy);

}

get_viewport (scroll_area, &new_viewport);

emit_viewport_changed (scroll_area, &new_viewport, &old_viewport);

}

GtkAdjustment **location)

{

g_return_if_fail (location != NULL);

if (adjustment == *location)

return;

if (!adjustment)

adjustment = new_adjustment ();

g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));

if (*location)

{

g_signal_handlers_disconnect_by_func (

*location, foo_scrollbar_adjustment_changed, scroll_area);

g_object_unref (*location);

}

*location = adjustment;

g_object_ref_sink (*location);

g_signal_connect (*location, "value_changed",

G_CALLBACK (foo_scrollbar_adjustment_changed),

scroll_area);

{

scroll_area->priv->min_width = min_width;

scroll_area->priv->min_height = min_height;

/* FIXME: think through invalidation.

*

* Goals: - no repainting everything on size_allocate(),

gpointer data)

{

cairo_t *cr = data;

cairo_user_to_device (cr, x, y);

}

{

GtkAllocation allocation;

GtkWidget *widget = GTK_WIDGET (area);

gtk_widget_get_allocation (widget, &allocation);

cairo_region_translate (region,

-area->priv->x_offset + allocation.x,

if (gtk_widget_get_realized (widget))

{

canvas_to_window (area, region);

gdk_window_invalidate_region (gtk_widget_get_window (widget),

region, TRUE);

window_to_canvas (area, region);

}

}

{

GdkRectangle rect = { x, y, width, height };

cairo_region_t *region;

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

region = cairo_region_create_rectangle (&rect);

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

g_return_if_fail (!scroll_area->priv->grabbed);

scroll_area->priv->grabbed = TRUE;

scroll_area->priv->grab_func = func;

scroll_area->priv->grab_data = input_data;

/* FIXME: we should probably take a server grab */

/* Also, maybe there should be support for setting the grab cursor */

}

foo_scroll_area_end_grab (FooScrollArea *scroll_area)

{

g_return_if_fail (FOO_IS_SCROLL_AREA (scroll_area));

scroll_area->priv->grabbed = FALSE;

scroll_area->priv->grab_func = NULL;

scroll_area->priv->grab_data = NULL;

g_source_remove (area->priv->auto_scroll_info->timeout_id);

g_timer_destroy (area->priv->auto_scroll_info->timer);

g_free (area->priv->auto_scroll_info);

area->priv->auto_scroll_info = NULL;

}

}

AutoScrollInfo *info = area->priv->auto_scroll_info;

int new_x, new_y;

double elapsed;

get_viewport (area, &viewport);

elapsed = g_timer_elapsed (info->timer, NULL);

info->res_x = elapsed * info->dx / 0.2;

info->res_y = elapsed * info->dy / 0.2;

new_x = viewport.x + info->res_x;

new_y = viewport.y + info->res_y;

info->res_y < -1.0))

{

stop_scrolling (area);

/* stop scrolling if it didn't have an effect */

return FALSE;

}

return TRUE;

}

g_idle_add (scroll_idle, area);

area->priv->auto_scroll_info->timer = g_timer_new ();

}

area->priv->auto_scroll_info->dx = dx;

area->priv->auto_scroll_info->dy = dy;

}

FooScrollAreaEvent *event)

{

GdkRectangle viewport;

get_viewport (scroll_area, &viewport);

if (rect_contains (&viewport, event->x, event->y))

{

stop_scrolling (scroll_area);

else

{

int dx, dy;

dx = dy = 0;

if (event->y < viewport.y)

{

dy = event->y - viewport.y;

dy = event->y - (viewport.y + viewport.height - 1);

dy = MAX (dy - 2, 0);

}

if (event->x < viewport.x)

{

dx = event->x - viewport.x;

dx = event->x - (viewport.x + viewport.width - 1);

dx = MAX (dx - 2, 0);

}

ensure_scrolling (scroll_area, dx, dy);

}

}

GtkWidget *panel_checkbox;

GtkWidget *clone_checkbox;

GtkWidget *show_icon_checkbox;

/* We store the event timestamp when the Apply button is clicked */

GtkWidget *apply_button;

* translation could be "Pantallas en Espejo", *not* "Espejar Pantallas".

*/

text = g_strdup_printf (_("Mirror Screens"));

else {

text = g_strdup_printf ("<b>%s</b>\n<small>%s</small>", mate_rr_output_info_get_display_name (output), mate_rr_output_info_get_name (output));

}

{

return FALSE;

}

gchar *new_key_schema = NULL;

gchar *element_schema = NULL;

gchar *new_key_path = NULL;

g_object_get (new_key->settings, "schema-id", &new_key_schema, NULL);

g_object_get (new_key->settings, "path", &new_key_path, NULL);

}

if (element->settings)

{

g_object_get (element->settings, "schema-id", &element_schema, NULL);

}

else

{

g_free (key_entry->gsettings_key);

g_free (key_entry->description);

g_free (key_entry->desc_gsettings_key);

if (retval == NULL) {

if (initial_config.layouts_variants != NULL) {

for (i = 0; initial_config.layouts_variants[i] != NULL; i++)

g_slist_prepend (retval, g_strdup (initial_config.layouts_variants[i]));

}

retval = g_slist_reverse (retval);

(layouts_list_strv, options_list_strv, &was_appended);

if (was_appended) {

xkb_options_set_selected_list (options_list);

}

clear_xkb_elements_list (options_list);

}

if (retval == NULL) {

if (initial_config.options != NULL) {

for (i = 0; initial_config.options[i] != NULL; i++)

g_slist_prepend (retval, g_strdup (initial_config.options[i]));

}

retval = g_slist_reverse (retval);

g_settings_bind (mouse_settings, DOUBLE_CLICK_KEY,

gtk_range_get_adjustment (GTK_RANGE (WID ("delay_scale"))), "value",

G_SETTINGS_BIND_DEFAULT);

gtk_image_set_from_stock (GTK_IMAGE (WID ("double_click_image")), MOUSE_DBLCLCK_OFF, mouse_capplet_dblclck_icon_get_size ());

g_object_set_data (G_OBJECT (WID ("double_click_eventbox")), "image", WID ("double_click_image"));

g_signal_connect (WID ("double_click_eventbox"), "button_press_event",

gtk_box_pack_start (GTK_BOX (WID ("hbox_three_finger_click")), three_click_comboxbox, FALSE, FALSE, 6);

int i;

for (i=0; i<4; i++) {

}

g_signal_connect (two_click_comboxbox, "changed", G_CALLBACK (comboxbox_two_finger_changed_callback), dialog);

g_signal_connect (three_click_comboxbox, "changed", G_CALLBACK (comboxbox_three_finger_changed_callback), dialog);

gtk_combo_box_set_active (GTK_COMBO_BOX (two_click_comboxbox), g_settings_get_int (touchpad_settings, "two-finger-click"));

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

TimeAdmin *ta = (TimeAdmin *)data;

Update_Clock_Start(ta);

ta->ApplyId = 0;

return FALSE;

static void update_apply_timeout(TimeAdmin *ta)

{

Update_Clock_Stop(ta);

{

g_source_remove (ta->ApplyId);

ta->ApplyId = 0;

}

ta->ApplyId = g_timeout_add (10000, (GSourceFunc)CheckClockHealth,ta);

static void ChangeTimeValue(GtkSpinButton *spin_button,

gpointer *data)

{

TimeAdmin *ta = (TimeAdmin *)data;

if(TimeoutFlag == 0)

update_apply_timeout(ta);

}

}

{

MessageReport(("Get Icon Fail"),Error->message,ERROR);

g_error_free(Error);

return Pixbuf;

static gboolean on_window_quit (GtkWidget *widget,

GdkEvent *event,

gpointer user_data)

{

TimeAdmin *ta = (TimeAdmin *)user_data;

QuitApp(ta);

return TRUE;

}

TimeAdmin *ta = (TimeAdmin *)data;

QuitApp(ta);

static void UpdatePermission(TimeAdmin *ta)

{

gboolean is_authorized;

gtk_window_set_resizable(GTK_WINDOW(Window),FALSE);

gtk_window_set_hide_titlebar_when_maximized(GTK_WINDOW(Window),TRUE);

gtk_window_set_position(GTK_WINDOW(Window), GTK_WIN_POS_CENTER);

gtk_container_set_border_width(GTK_CONTAINER(Window),10);

gtk_widget_set_size_request(Window, 300, 360);

g_signal_connect(G_OBJECT(Window),

{

int pid = 0;

int fd;

char WriteBuf[30] = { 0 };

fd = open(LOCKFILE,O_WRONLY|O_CREAT|O_TRUNC,0777);

if(fd < 0)

{

MessageReport(_("open file"),_("Create pid file failed"),ERROR);

pid = getpid();

sprintf(WriteBuf,"%d",pid);

Length = write(fd,WriteBuf,strlen(WriteBuf));

if(Length <= 0 )

{

MessageReport(_("write file"),_("write pid file failed"),ERROR);

close(fd);

return 0;

/******************************************************************************

* record the current process ID =====>"/tmp/user-admin.pid"

* Output: start :TRUE

* not start :FALSE

* Author: zhuyaliang 31/07/2018

******************************************************************************/

static gboolean ProcessRuning(void)

{

MessageReport(_("open file"),_("open pid file failed"),ERROR);

return TRUE;

if(read(fd,ReadBuf,sizeof(ReadBuf)) <= 0)

{

MessageReport(_("read file"),_("read pid file failed"),ERROR);

goto ERROREXIT;

pid = atoi(ReadBuf);

if(kill(pid,0) == 0)

goto ERROREXIT;

}

}

if(RecordPid() < 0)

Run = TRUE;

return Run;

ERROREXIT:

close(fd);

return TRUE;

static char *translate(const char *value)

{

g_autofree gchar *zone_translated = NULL;

char *name;

zone_translated = g_strdup (dgettext (GETTEXT_PACKAGE_TIMEZONES,value));

name = g_strdup_printf (C_("timezone loc", "%s"),zone_translated);

return name;

static GtkWidget * TimeZoneAndNtp(TimeAdmin *ta)

{

GtkWidget *table;

gtk_widget_set_halign(TimeZoneLabel,GTK_ALIGN_START);

SetLableFontType(TimeZoneLabel,11,_("Time Zone:"));

gtk_grid_attach(GTK_GRID(table) ,TimeZoneLabel, 0 , 0 , 1 , 1);

TimeZone = GetTimeZone(ta);

ZoneName = translate(TimeZone);

ta->TimeZoneButton = gtk_button_new_with_label(ZoneName);

ta);

gtk_grid_attach(GTK_GRID(table) ,ta->TimeZoneButton,1 , 0 , 3 , 1);

NtpSyncLabel = gtk_label_new(NULL);

gtk_widget_set_halign(NtpSyncLabel,GTK_ALIGN_START);

SetLableFontType(NtpSyncLabel,11,_("Ntp Sync:"));

gtk_grid_attach(GTK_GRID(table) ,NtpSyncLabel, 0 , 1 , 1 , 1);

ta->NtpSyncSwitch = gtk_switch_new();

NtpState = GetNtpState(ta);

ta->NtpState = NtpState;

"state-set",

G_CALLBACK (ChangeNtpSync),

ta);

gtk_grid_set_row_spacing(GTK_GRID(table), 6);

gtk_grid_set_column_spacing(GTK_GRID(table), 12);

return table;

static GtkWidget *GetSpinButton(int Initial,int Maximum,TimeAdmin *ta)

{

G_CALLBACK (ChangeTimeValue),

ta);

return SpinButton;

static GtkWidget *SetClock(TimeAdmin *ta)

{

GtkWidget *table;

GtkWidget *TimeLabel;

struct tm *LocalTime;

table = gtk_grid_new();

gtk_grid_set_column_homogeneous(GTK_GRID(table),TRUE);

TimeLabel = gtk_label_new(NULL);

SetLableFontType(TimeLabel,13,_("Set Time"));

gtk_widget_set_halign(TimeLabel,GTK_ALIGN_CENTER);

gtk_widget_set_valign(TimeLabel,GTK_ALIGN_START);

gtk_widget_set_hexpand(TimeLabel,FALSE);

gtk_grid_attach(GTK_GRID(table) ,TimeLabel, 1 , 0 , 1 , 1);

LocalTime = GetCurrentTime();

ta->UpdateTimeId = 0;

ta->ApplyId = 0;

ta->HourSpin = GetSpinButton(LocalTime->tm_hour,23,ta);

gtk_grid_attach(GTK_GRID(table) ,ta->HourSpin, 0 , 1 , 1 , 1);

ta->MinuteSpin = GetSpinButton(LocalTime->tm_min,59,ta);

gtk_grid_attach(GTK_GRID(table) ,ta->MinuteSpin, 1 , 1 , 1 , 1);

ta->SecondSpin = GetSpinButton (LocalTime->tm_sec,59,ta);

gtk_grid_attach(GTK_GRID(table) ,ta->SecondSpin, 2 , 1 , 1 , 1);

Update_Clock_Start(ta);

gtk_grid_set_row_spacing(GTK_GRID(table), 6);

gtk_grid_set_column_spacing(GTK_GRID(table), 12);

return table;

static GtkWidget *SetDate(TimeAdmin *ta)

{

table = gtk_grid_new();

gtk_grid_set_column_homogeneous(GTK_GRID(table),TRUE);

DateLabel = gtk_label_new(NULL);

SetLableFontType(DateLabel,13,_("Set Date"));

gtk_grid_attach(GTK_GRID(table) ,DateLabel, 1 , 0 , 2 , 2);

LocalTime = GetCurrentTime();

ta->Calendar = gtk_calendar_new ();

gtk_widget_set_sensitive(ta->Calendar,!ta->NtpState);

gtk_calendar_mark_day(GTK_CALENDAR(ta->Calendar),LocalTime->tm_mday);

ta->OldDay = LocalTime->tm_mday;

gtk_grid_attach(GTK_GRID(table) ,ta->Calendar, 0 , 2 , 4 , 3);

"clicked",

G_CALLBACK (CloseWindow),

ta);

gtk_grid_attach(GTK_GRID(table) ,ta->ButtonLock, 0 , 5 , 1 , 1);

ta->SaveButton = gtk_button_new_with_label (_("Save"));

gtk_widget_set_sensitive(ta->SaveButton,!ta->NtpState);

gtk_grid_attach(GTK_GRID(table) ,ta->SaveButton, 2 , 5 , 1 , 1);

gtk_grid_set_row_spacing(GTK_GRID(table), 6);

gtk_grid_set_column_spacing(GTK_GRID(table), 12);

return table;

}

Vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);

gtk_container_add(GTK_CONTAINER(ta->MainWindow), Vbox);

Vbox1 = TimeZoneAndNtp(ta);

gtk_box_pack_start(GTK_BOX(Vbox),Vbox1,TRUE,TRUE,8);

gtk_box_pack_start(GTK_BOX(Vbox),Vbox2,TRUE,TRUE,8);

Vbox3 = SetDate(ta);

gtk_box_pack_start(GTK_BOX(Vbox),Vbox3,TRUE,TRUE,8);

static gboolean InitDbusProxy(TimeAdmin *ta)

{

GError *error = NULL;

{

MessageReport(_("g_bus_get_sync"),error->message,ERROR);

goto EXIT;

ta->proxy = g_dbus_proxy_new_sync (ta->Connection,

G_DBUS_PROXY_FLAGS_NONE,

NULL,

{

MessageReport(_("g_bus_proxy_new"),error->message,ERROR);

goto EXIT;

return TRUE;

EXIT:

g_error_free(error);

return FALSE;

int main(int argc, char **argv)

{

TimeAdmin ta;

gtk_init(&argc, &argv);

/* Create the main window */

InitMainWindow(&ta);

/* Check whether the process has been started */

if(ProcessRuning() == TRUE)

if(InitDbusProxy(&ta) == FALSE)

{

exit(0);

UpdatePermission(&ta);

gtk_widget_show_all(ta.MainWindow);

gtk_main();

return TRUE;

}

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

guchar green;

guchar blue;

guchar alpha;

enum

{

LOCATION_CHANGED,

LAST_SIGNAL

};

G_DEFINE_TYPE (TimezoneMap, timezone_map, GTK_TYPE_WIDGET)

static guint signals[LAST_SIGNAL];

static TimezoneMapOffset color_codes[] =

TzLocation *location)

{

g_autoptr(TzInfo) info = NULL;

map->location = location;

info = tz_info_from_location (map->location);

map->selected_offset = tz_location_get_utc_offset (map->location)

((info->daylight) ? -1.0 : 0.0);

g_signal_emit (map, signals[LOCATION_CHANGED], 0, map->location,NULL);

}

widget_class->realize = cc_timezone_map_realize;

widget_class->draw = cc_timezone_map_draw;

widget_class->state_flags_changed = cc_timezone_map_state_flags_changed;

signals[LOCATION_CHANGED] = g_signal_new ("location-changed",

TYPE_TIMEZONE_MAP,

G_SIGNAL_RUN_FIRST,

timezone_map_init (TimezoneMap *map)

{

GError *err = NULL;

map->orig_background = gdk_pixbuf_new_from_file (TIMPZONEDIR"bg.png",&err);

if (!map->orig_background)

g_warning ("Could not load background image: %s",

(err) ? err->message : "Unknown error");

g_clear_error (&err);

map->tzdb = tz_load_db ();

G_CONNECT_SWAPPED);

}

gboolean timezone_map_set_timezone (TimezoneMap *map,

guint i;

g_autofree gchar *real_tz = NULL;

gboolean ret;

real_tz = tz_info_get_clean_name (map->tzdb, timezone);

locations = tz_get_locations (map->tzdb);

return ret;

}

TzLocation *timezone_map_get_location (TimezoneMap *map)

return map->location;

}

void timezone_map_set_bubble_text (TimezoneMap *map,

}

TimezoneMap * timezone_map_new (void)

return g_object_new (TYPE_TIMEZONE_MAP, NULL);

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

typedef struct TimezoneMapClass

{

GtkWidgetClass parent_class;

} TimezoneMapClass;

GType timezone_map_get_type (void) G_GNUC_CONST;

TzLocation *timezone_map_get_location (TimezoneMap *map);

G_END_DECLS

#endif

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

/******************************************************************************

* Function: MessageReport

* Explain: Prompt information dialog

* Input: @Title Message title

* @nType Message type

* Author: zhuyaliang 25/05/2018

******************************************************************************/

int MessageReport(const char *Title,const char *Msg,int nType)

GTK_BUTTONS_YES_NO,

"%s",Title);

break;

default :

break;

if(ta->UpdateTimeId > 0)

{

g_source_remove (ta->UpdateTimeId);

if(ta->ApplyId > 0)

{

g_source_remove(ta->ApplyId);

gtk_main_quit();

}

GtkWidget* DialogAddButtonWithIconName (GtkDialog *dialog,

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

GtkWidget *WindowLogin;

int TimeoutFlag;

{

GtkWidget *MainWindow;

GtkWidget *HourSpin;

GtkWidget *Calendar;

GtkWidget *CloseButton;

GtkWidget *SaveButton;

int ApplyId;

int OldDay;

gboolean NtpState;

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

time_t tt;

tzset();

tt=time(NULL);

return localtime(&tt);

}

static void UpdateDate(TimeAdmin *ta,gboolean state)

{

struct tm *LocalTime;

if(state == TRUE)

LocalTime = GetCurrentTime();

LocalTime->tm_mon,

LocalTime->tm_year+1900);

LocalTime->tm_mday);

}

}

TimeAdmin *ta = (TimeAdmin *)data;

struct tm *LocalTime;

gchar *str;

LocalTime = GetCurrentTime();

TimeoutFlag = 1;

gtk_spin_button_set_value(GTK_SPIN_BUTTON(ta->HourSpin),LocalTime->tm_hour);

gtk_spin_button_set_value(GTK_SPIN_BUTTON(ta->MinuteSpin),LocalTime->tm_min);

str = g_strdup_printf ("%02d", LocalTime->tm_sec);

gtk_entry_set_text(GTK_ENTRY(ta->SecondSpin),str);

gtk_calendar_mark_day(GTK_CALENDAR(ta->Calendar),LocalTime->tm_mday);

if(LocalTime->tm_mday != ta->OldDay)

gtk_calendar_unmark_day(GTK_CALENDAR(ta->Calendar),ta->OldDay);

ta->OldDay = LocalTime->tm_mday;

}

if(ta->UpdateTimeId <= 0)

{

ta->UpdateTimeId = g_timeout_add(1000,(GSourceFunc)UpdateClock,ta);

void Update_Clock_Stop(TimeAdmin *ta)

{

if(ta->UpdateTimeId > 0)

{

g_source_remove(ta->UpdateTimeId);

ta->UpdateTimeId = 0;

}

gboolean GetNtpState(TimeAdmin *ta)

{

{

goto EXIT;

}

ret = g_dbus_proxy_call_sync (proxy,

"Get",

g_variant_new ("(ss)",

g_error_free(error);

return FALSE;

const gchar *GetTimeZone(TimeAdmin *ta)

{

{

goto EXIT;

}

ret = g_dbus_proxy_call_sync (proxy,

"Get",

g_variant_new ("(ss)",

{

GError *error = NULL;

GVariant *ret;

ret = g_dbus_proxy_call_sync (proxy,

"SetTimezone",

g_variant_new ("(sb)",zone,1),

if(ret == NULL)

{

MessageReport(_("Set time zone"),error->message,ERROR);

static void ChangeSpinBttonState(TimeAdmin *ta,gboolean State)

{

gtk_widget_set_sensitive(ta->SaveButton,!State);

gtk_widget_set_sensitive(ta->HourSpin, !State);

gtk_widget_set_sensitive(ta->MinuteSpin,!State);

gtk_widget_set_sensitive(ta->SecondSpin,!State);

gtk_widget_set_sensitive(ta->Calendar, !State);

}

gboolean ChangeNtpSync(GtkSwitch *widget,gboolean state,gpointer data)

TimeAdmin *ta = (TimeAdmin *)data;

GError *error = NULL;

GVariant *ret;

ret = g_dbus_proxy_call_sync (ta->proxy,

"SetNTP",

g_variant_new ("(bb)",state,state),

MessageReport(_("Set Ntp sync"),error->message,ERROR);

g_error_free(error);

return TRUE;

else

{

ta->NtpState = state;

ChangeSpinBttonState(ta,state);

Update_Clock_Start(ta);

UpdateDate(ta,state);

return FALSE;

static guint GetTimeStamp(TimeAdmin *ta)

{

guint year,month,day,hour,min,sec;

GDateTime *dt;

char *st;

gtk_calendar_get_date(GTK_CALENDAR(ta->Calendar),&year,&month,&day);

hour = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ta->HourSpin));

min = gtk_spin_button_get_value(GTK_SPIN_BUTTON(ta->MinuteSpin));

{

GError *error = NULL;

GVariant *ret;

ret = g_dbus_proxy_call_sync (proxy,

"SetTime",

g_variant_new ("(xbb)",TimeSec * 1000 * 1000,0,0),

{

MessageReport(_("Set Ntp sync"),error->message,ERROR);

g_error_free(error);

void SaveModifyTime (GtkButton *button,gpointer data)

{

TimeAdmin *ta = (TimeAdmin *)data;

else

{

MessageReport(_("Set Time"),_("NTP synchronization has been started, the modification is invalid"),INFOR);

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

{

g_error("%s does not exist\r\n",BACKFILE);

{

g_auto(GStrv) items = NULL;

guint j;

real = "Etc/GMT";

g_hash_table_insert (tz_db->backward, g_strdup (alias), g_strdup (real));

fclose(fp);

}

TzDB *tz_load_db (void)

g_autofree gchar *tz_data_file = NULL;

TzDB *tz_db;

FILE *tzfile;

char buf[4096];

tz_data_file = tz_data_file_get ();

{

g_warning ("Could not get the TimeZone data file name");

return NULL;

}

tzfile = fopen (tz_data_file, "r");

{

g_warning ("Could not open *%s*\n", tz_data_file);

return NULL;

"location-changed",

G_CALLBACK (LocationChanged),

ta);

completion = gtk_entry_completion_new ();

gtk_entry_set_completion (GTK_ENTRY (ta->TimezoneEntry), completion);

gtk_entry_completion_set_model (completion, GTK_TREE_MODEL (ta->CityListStore));

gtk_entry_completion_set_text_column (completion, CITY_COL_CITY_HUMAN_READABLE);

return map;

static char *

translated_city_name (TzLocation *loc)

{

current_location = timezone_map_get_location (TIMEZONEMAP (map));

city_country = translated_city_name (current_location);

timezone = g_time_zone_new (current_location->zone);

current_date = g_date_time_new_now_local ();

date = g_date_time_to_timezone (current_date, timezone);

g_autofree gchar *human_readable = NULL;

human_readable = translated_city_name (loc);

0,

human_readable,

loc->zone,

-1);

}

static void CreateCityList(TimeAdmin *ta)

{

g_autoptr(TzDB) db = NULL;

ta->CityListStore = gtk_list_store_new (CITY_NUM_COLS,G_TYPE_STRING,G_TYPE_STRING);

db = tz_load_db ();

g_ptr_array_foreach (db->locations, (GFunc) LoadCities, ta->CityListStore);

static GtkWidget *CreateZoneFrame(TimeAdmin *ta)

{

GtkWidget *TimeZoneFrame;

TimeZoneFrame = gtk_frame_new (_("Time Zone"));

gtk_widget_set_size_request(TimeZoneFrame,300,200);

gtk_frame_set_shadow_type(GTK_FRAME(TimeZoneFrame),GTK_SHADOW_NONE);

return TimeZoneFrame;

static GtkWidget *CreateZoneScrolled(TimeAdmin *ta)

{

GtkWidget *Scrolled;

GTK_SHADOW_IN);

return Scrolled;

static void CreateZoneEntry(TimeAdmin *ta)

{

GtkWidget *hbox;

ta->TimezoneEntry = gtk_search_entry_new ();

hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);

gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER);

gtk_container_add (GTK_CONTAINER (ta->SearchBar), hbox);

gtk_search_bar_set_search_mode(GTK_SEARCH_BAR(ta->SearchBar),TRUE);

static gboolean CityChanged(GtkEntryCompletion *completion,

GtkTreeModel *model,

GtkWidget *entry;

g_autofree gchar *zone = NULL;

iter,

&zone,

-1);

timezone_map_set_timezone (TIMEZONEMAP (self->map), zone);

{

TimezoneMap *map;

g_autofree gchar *ZoneCity = NULL;

SetTimeZone(ta->proxy,map->location->zone);

ZoneCity = translated_city_name(map->location);

gtk_widget_hide_on_delete(GTK_WIDGET(ta->dialog));

}

ta->TZclose = DialogAddButtonWithIconName(GTK_DIALOG(ta->dialog),

_("Close"),

"window-close",

ta->TZconfire = DialogAddButtonWithIconName(GTK_DIALOG(ta->dialog),

_("Confirm"),

"emblem-default",

g_signal_connect (ta->TZconfire,

"clicked",

G_CALLBACK (ChoooseTimezoneDone),

G_CALLBACK (ChoooseTimezoneClose),

ta);

gtk_style_context_add_class (gtk_widget_get_style_context (Vbox), "linked");

TimeZoneFrame = CreateZoneFrame(ta);

Scrolled = CreateZoneScrolled(ta);

gtk_container_add (GTK_CONTAINER (Scrolled),ta->map);

gtk_box_pack_start(GTK_BOX(Vbox),TimeZoneFrame,TRUE,TRUE,10);

get_initial_timezone(ta);

g_signal_connect(gtk_entry_get_completion (GTK_ENTRY (ta->TimezoneEntry)),

gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (ta->dialog))),

Vbox,

void tz_info_free (TzInfo *tzinfo)

{

g_return_if_fail (tzinfo != NULL);

if (tzinfo->tzname_normal) g_free (tzinfo->tzname_normal);

if (tzinfo->tzname_daylight) g_free (tzinfo->tzname_daylight);

g_free (tzinfo);

char *tz_info_get_clean_name (TzDB *tz_db,

const char *tz)

char *ret;

const char *timezone;

guint i;

gboolean replaced;

/* Remove useless prefixes */

if (g_str_has_prefix (tz, "right/"))

tz = tz + strlen ("right/");

else if (g_str_has_prefix (tz, "posix/"))

tz = tz + strlen ("posix/");

/* Here start the crazies */

replaced = FALSE;

glong tz_location_get_utc_offset (TzLocation *loc)

{

g_autoptr(TzInfo) tz_info = NULL;

tz_info = tz_info_from_location (loc);

offset = tz_info->utc_offset;

* Copyright (C) 2018 zhuyaliang https://github.com/zhuyaliang/

*

* This program is free software: you can redistribute it and/or modify

#endif

typedef struct TzDB

GPtrArray *locations;

GHashTable *backward;

}TzDB;

typedef struct TzLocation

gchar *country;

gdouble latitude;

gdouble longitude;

/* -*- mode: C; c-basic-offset: 4 -*-

*

* Copyright (C) 2012 Cosimo Cecchi <[email protected]>

*

*

* fontilus - a collection of font utilities for MATE

* Copyright (C) 2002-2003 James Henstridge <[email protected]>

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

GObjectClass *oclass = G_OBJECT_CLASS (klass);

oclass->finalize = font_view_model_finalize;

g_signal_new ("config-changed",

FONT_VIEW_TYPE_MODEL,

G_SIGNAL_RUN_FIRST,

scale = MIN (scale_x, scale_y);

cairo_scale (cr, scale, scale);

PADDING_HORIZONTAL - text_extents.x_bearing + (thumb_size - scale * text_extents.width) / 2.0,

PADDING_VERTICAL - text_extents.y_bearing + (thumb_size - scale * text_extents.height) / 2.0);

}

gtk_label_set_max_width_chars (GTK_LABEL (label), 64);

name_w, GTK_POS_RIGHT,

1, 1);

}

font_view_ensure_model (self);

self->info_button = gd_main_toolbar_add_button (GD_MAIN_TOOLBAR (self->toolbar),

FALSE);

g_signal_connect (self->info_button, "clicked",

G_CALLBACK (info_button_clicked_cb), self);

/* add install button */

self->install_button = gd_main_toolbar_add_button (GD_MAIN_TOOLBAR (self->toolbar),

FALSE);

g_signal_connect (self->install_button, "clicked",

G_CALLBACK (install_button_clicked_cb), self);

gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_view), cell, FALSE);

gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (icon_view), cell,

"pixbuf", COLUMN_ICON);

cell = gtk_cell_renderer_text_new ();

g_object_set (cell,

"alignment", PANGO_ALIGN_CENTER,

"license-type", GTK_LICENSE_GPL_2_0,

"wrap-license", TRUE,

NULL);

}

static GActionEntry action_entries[] = {

G_APPLICATION_CLASS (font_view_application_parent_class)->startup (application);

G_N_ELEMENTS (action_entries), self);

builder = gtk_builder_new ();

gtk_builder_add_from_string (builder, app_menu, -1, NULL);

self->toolbar = gd_main_toolbar_new ();

gtk_style_context_add_class (gtk_widget_get_style_context (self->toolbar), "menubar");

self->search_button = gd_main_toolbar_add_toggle (GD_MAIN_TOOLBAR (self->toolbar),

FALSE);

gtk_container_add (GTK_CONTAINER (self->main_grid), self->toolbar);

self->search_bar = gtk_search_bar_new();

gtk_container_add (GTK_CONTAINER (self->main_grid), self->search_bar);

self->entry = gtk_search_entry_new();

gtk_entry_set_width_chars (GTK_ENTRY (self->entry), 40);

gtk_container_add (GTK_CONTAINER (self->search_bar), self->entry);

g_object_bind_property (self->search_bar, "search-mode-enabled",

self->search_button, "active",

G_BINDING_BIDIRECTIONAL);

* Copyright (c) 2011, 2012 Red Hat, Inc.

*

* This program is free software; you can redistribute it and/or modify

* the Free Software Foundation; either version 2 of the License, or (at your

* option) any later version.

*

* This program is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

* License for more details.

*

* along with this program; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

*

(GtkCallback) gtk_widget_destroy, self);

gtk_container_foreach (GTK_CONTAINER (self->priv->modes_box),

(GtkCallback) gtk_widget_destroy, self);

(GtkCallback) gtk_widget_destroy, self);

}

* Copyright (c) 2011, 2012 Red Hat, Inc.

*

* This program is free software; you can redistribute it and/or modify

* the Free Software Foundation; either version 2 of the License, or (at your

* option) any later version.

*

* This program is distributed in the hope that it will be useful, but

* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

* License for more details.

*

* along with this program; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

*

GString *string;

gulong c;

guint glyph;

string = g_string_new (NULL);

self->priv->font_name = NULL;

if (self->priv->face->family_name != NULL) {

g_strconcat (self->priv->face->family_name, " ",

self->priv->face->style_name, NULL);

if (self->priv->lowercase_text != NULL) {

cairo_text_extents (cr, self->priv->lowercase_text, &extents);

extents.y_advance + LINE_SPACING;

pixmap_width = MAX (pixmap_width, extents.width + padding.left + padding.right);

}

* Copyright (C) 2007 Bastien Nocera <[email protected]>

*

* This program is free software; you can redistribute it and/or modify

* Copyright (C) 2007 Bastien Nocera <[email protected]>

*

* This program is free software; you can redistribute it and/or modify

StartupStatus retval;

gint x;

filename = g_filename_from_uri (mate_desktop_item_get_location (desktop_item), NULL, NULL);

if (!filename)

return APP_NOT_ELIGIBLE;

gsize uris_len;

gint i;

g_return_if_fail (priv->user_modifiable);

uris = g_bookmark_file_get_uris (priv->store, &uris_len);

if (TYPE_IS_RECENT (priv->type)) {

for (i = 0; i < uris_len; i++) {

if (rank >= 0) {

uris = g_bookmark_file_get_uris (priv->store, NULL);

for (i = 0; uris && uris [i]; ++i) {

rank_i = get_rank (this, uris [i]);

gchar **uris;

gchar **groups;

gchar **bookmarks = NULL;

gchar *buf, *label, *uri;

gint i, j, bookmark_len;

dirs = g_get_system_data_dirs ();

for (i = 0; ! path && dirs && dirs [i]; ++i) {

path = g_build_filename (dirs [i], PACKAGE, filename, NULL);

if (! g_file_test (path, G_FILE_TEST_EXISTS)) {

g_free (path);

path = NULL;

status = BOOKMARK_STORE_DEFAULT_ONLY;

else

status = BOOKMARK_STORE_ABSENT;

if (priv->status != status) {

priv->status = status;

g_object_notify (G_OBJECT (this), BOOKMARK_AGENT_STORE_STATUS_PROP);

if (name)

g_bookmark_file_set_title (priv->store, uri, name);

if (uri_new && libslab_strcmp (uri, uri_new))

g_bookmark_file_move_item (priv->store, uri, uri_new, NULL);

"tile-uri", uri,

"nameplate-image", image,

"nameplate-header", header,

NULL));

}

g_warning ("Marco window manager module wasn't compiled with the current version of mate-control-center");

return NULL;

}

wm = g_object_new (marco_window_manager_get_type (), NULL);

return wm;

* only checks existence, not wether we can really read it.*/

if (theme_dir == NULL)

return current_list;

for (entry = readdir (theme_dir); entry != NULL; entry = readdir (theme_dir)) {

theme_file_path = g_build_filename (path, entry->d_name, "metacity-1/metacity-theme-2.xml", NULL);

/*g_free (entry);*/

g_free (theme_file_path);

}

closedir (theme_dir);

return current_list;

}

marco_get_theme_list (MateWindowManager *wm)

{

GList *themes = NULL;

g_settings_set_boolean (meta_wm->p->settings,

MARCO_AUTORAISE_KEY,

settings->autoraise);

if (settings->flags & MATE_WM_SETTING_AUTORAISE_DELAY)

g_settings_set_int (meta_wm->p->settings,

MARCO_AUTORAISE_DELAY_KEY,

MARCO_FONT_KEY,

settings->font);

}

if (settings->flags & MATE_WM_SETTING_MOUSE_MOVE_MODIFIER) {

char *value;

MarcoWindowManager *meta_wm;

meta_wm = MARCO_WINDOW_MANAGER (wm);

to_get = settings->flags;

settings->flags = 0;

if (to_get & MATE_WM_SETTING_COMPOSITING_MANAGER) {

settings->compositing_manager = g_settings_get_boolean (meta_wm->p->settings,

MARCO_COMPOSITING_MANAGER_KEY);

settings->flags |= MATE_WM_SETTING_COMPOSITING_MANAGER;

}

if (to_get & MATE_WM_SETTING_COMPOSITING_ALTTAB) {

settings->compositing_fast_alt_tab = g_settings_get_boolean (meta_wm->p->settings,

MARCO_COMPOSITING_FAST_ALT_TAB_KEY);

settings->flags |= MATE_WM_SETTING_COMPOSITING_ALTTAB;

}

if (to_get & MATE_WM_SETTING_MOUSE_FOCUS) {

gint marco_focus_value;

settings->flags |= MATE_WM_SETTING_MOUSE_FOCUS;

}

if (to_get & MATE_WM_SETTING_AUTORAISE) {

settings->autoraise = g_settings_get_boolean (meta_wm->p->settings,

MARCO_AUTORAISE_KEY);

settings->flags |= MATE_WM_SETTING_AUTORAISE;

}

if (to_get & MATE_WM_SETTING_AUTORAISE_DELAY) {

settings->autoraise_delay =

g_settings_get_int (meta_wm->p->settings,

g_free (meta_wm->p->font);

meta_wm->p->font = str;

}

settings->font = meta_wm->p->font;

settings->flags |= MATE_WM_SETTING_FONT;

}

if (to_get & MATE_WM_SETTING_MOUSE_MOVE_MODIFIER) {

char *str;

const char *new;

g_free (str);

settings->mouse_move_modifier = meta_wm->p->mouse_modifier;

settings->flags |= MATE_WM_SETTING_MOUSE_MOVE_MODIFIER;

}

settings->double_click_action =

g_settings_get_enum (meta_wm->p->settings,

MARCO_DOUBLE_CLICK_TITLEBAR_KEY);

settings->flags |= MATE_WM_SETTING_DOUBLE_CLICK_ACTION;

}

}

{ ACTION_TITLEBAR_MINIMIZE, N_("Minimize") },

{ ACTION_TITLEBAR_NONE, N_("None") }

};

static gboolean initialized = FALSE;

if (!initialized) {

int i;

initialized = TRUE;

for (i = 0; i < G_N_ELEMENTS (actions); i++) {

actions[i].human_readable_name = _(actions[i].human_readable_name);

}

*actions_p = actions;

}

static void

}

static void

{

MarcoWindowManager *marco_window_manager;

static void

{

GObjectClass *object_class;

MateWindowManagerClass *wm_class;

wm_class->get_user_theme_folder = marco_get_user_theme_folder;

wm_class->get_theme_list = marco_get_theme_list;

wm_class->get_double_click_actions = marco_get_double_click_actions;

parent_class = g_type_class_peek_parent (class);

}

NULL

};

"MarcoWindowManager",

&marco_window_manager_info, 0);

}

}

success = g_module_symbol (module, "window_manager_new",

if ((!success) || wm_new_func == NULL) {

g_warning ("Couldn't load window manager settings module `%s`, couldn't find symbol \'window_manager_new\'", module_name);

g_free (module_name);

if (wm == NULL)

return NULL;

(MATE_WINDOW_MANAGER (wm))->p->window_manager_name = g_strdup (mate_desktop_item_get_string (it, MATE_DESKTOP_ITEM_NAME));

(MATE_WINDOW_MANAGER (wm))->p->ditem = mate_desktop_item_ref (it);

return wm;

}

mate_window_manager_get_name (MateWindowManager *wm)

{

return wm->p->window_manager_name;

*actions = NULL;

*n_actions = 0;

if (klass->get_double_click_actions)

klass->get_double_click_actions (wm, actions, n_actions);

}

const MateWMSettings *settings)

{

MateWindowManagerClass *klass = MATE_WINDOW_MANAGER_GET_CLASS (wm);

(* klass->change_settings) (wm, settings);

}

* fields to the caller that the WM module

* doesn't know about

*/

(* klass->get_settings) (wm, settings);

}

}

static void

{

MateWindowManager *mate_window_manager;

static guint signals[LAST_SIGNAL] = { 0 };

static void

{

GObjectClass *object_class;

object_class = G_OBJECT_CLASS (class);

object_class->finalize = mate_window_manager_finalize;

parent_class = g_type_class_peek_parent (class);

signals[SETTINGS_CHANGED] =

g_signal_new ("settings_changed",

G_OBJECT_CLASS_TYPE (class),

NULL

};

"MateWindowManager",

}

return mate_window_manager_type;

};

object_type = g_type_register_static (G_TYPE_OBJECT,

&object_info, 0);

}

drw_monitor_class_init (DrwMonitorClass *klass)

{

GObjectClass *object_class = G_OBJECT_CLASS (klass);

parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));

object_class->finalize = drw_monitor_finalize;

g_signal_new ("activity",

G_TYPE_FROM_CLASS (klass),

G_SIGNAL_RUN_LAST,

drw_monitor_init (DrwMonitor *monitor)

{

DrwMonitorPriv *priv;

priv = g_new0 (DrwMonitorPriv, 1);

monitor->priv = priv;

{

DrwMonitor *monitor = DRW_MONITOR (object);

DrwMonitorPriv *priv;

priv = monitor->priv;

g_source_remove (priv->timeout_id);

if (priv->ss_info) {

XFree (priv->ss_info);

}

g_free (priv);

monitor->priv = NULL;

time_t now;

priv = monitor->priv;

if (XScreenSaverQueryInfo (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), DefaultRootWindow (GDK_DISPLAY_XDISPLAY(gdk_display_get_default())), priv->ss_info) != 0) {

if (priv->ss_info->idle < priv->last_idle) {

now = time (NULL);

if (now - priv->last_activity < 25) {

g_signal_emit (monitor, signals[ACTIVITY], 0, NULL);

}

priv->last_activity = now;

}

priv->ss_info = XScreenSaverAllocInfo ();

priv->last_activity = time (NULL);

priv->timeout_id = g_timeout_add_seconds (3, (GSourceFunc) drw_monitor_timeout, monitor);

return TRUE;

}

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL RED HAT

* BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION

* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

*

* Author: Owen Taylor, Red Hat, Inc.

#include <glib.h>

#include "drw-timer.h"

{

GTimeVal start_time;

};

{

DrwTimer * timer = g_new0 (DrwTimer, 1);

drw_timer_start (timer);

return timer;

}

{

g_get_current_time (&timer->start_time);

}

{

GTimeVal now;

g_get_current_time (&now);

GdkPixbuf *src_pixbuf,

GdkRectangle *field_geom,

guint alpha,

{

gboolean need_composite;

gboolean use_simple;

if (need_composite && !use_simple)

gdk_pixbuf_composite (src_pixbuf, dest_pixbuf,

cx, cy,

MIN (pheight, field_geom->height - cy),

cx, cy,

1.0, 1.0,

else if (need_composite && use_simple)

gdk_pixbuf_composite_color (src_pixbuf, dest_pixbuf,

cx, cy,

MIN (pheight, field_geom->height - cy),

cx, cy,

1.0, 1.0,

Screen *xscreen = DefaultScreenOfDisplay (gdk_x11_display_get_xdisplay(gdk_display_get_default()));

Atom selection_atom;

char *selection_atom_name;

selection_atom_name = g_strdup_printf ("_NET_SYSTEM_TRAY_S%d",

XScreenNumberOfScreen (xscreen));

selection_atom = gdk_x11_get_xatom_by_name (selection_atom_name);

g_free (selection_atom_name);

if (XGetSelectionOwner (DisplayOfScreen (xscreen), selection_atom)) {

return TRUE;

} else {

GError *error = NULL;

gboolean retval;

bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

textdomain (GETTEXT_PACKAGE);

g_option_context_set_translation_domain (option_context, GETTEXT_PACKAGE);

g_option_context_add_main_entries (option_context, options, GETTEXT_PACKAGE);

g_option_context_add_group (option_context, gtk_get_option_group (TRUE));

retval = g_option_context_parse (option_context, &argc, &argv, &error);

g_option_context_free (option_context);

if (!retval) {

"on your panel. You can add it by right-clicking on your "

"panel and choosing 'Add to panel', selecting 'Notification "

"area' and clicking 'Add'."));

gtk_dialog_run (GTK_DIALOG (dialog));

gtk_widget_destroy (dialog);

}

#endif /* HAVE_APP_INDICATOR */

drwright_new ();

gtk_main ();