Merge lp:~kalgasnik/lightdm-gtk-greeter/new_panel_layout into lp:~lightdm-gtk-greeter-team/lightdm-gtk-greeter/trunk

Proposed by Andrew P.
Status: Merged
Merged at revision: 287
Proposed branch: lp:~kalgasnik/lightdm-gtk-greeter/new_panel_layout
Merge into: lp:~lightdm-gtk-greeter-team/lightdm-gtk-greeter/trunk
Diff against target: 1097 lines (+729/-61) (has conflicts)
6 files modified
src/Makefile.am (+2/-1)
src/greeter_menu_bar.xml (+8/-0)
src/greetermenubar.c (+342/-0)
src/greetermenubar.h (+37/-0)
src/lightdm-gtk-greeter.c (+198/-59)
src/lightdm-gtk-greeter.glade (+142/-1)
Text conflict in src/lightdm-gtk-greeter.c
Text conflict in src/lightdm-gtk-greeter.glade
To merge this branch: bzr merge lp:~kalgasnik/lightdm-gtk-greeter/new_panel_layout
Reviewer Review Type Date Requested Status
LightDM Gtk+ Greeter Development Team Pending
Review via email: mp+222461@code.launchpad.net

Description of the change

New panel items:
"~spacer"
"~separator"
"~host"
"~clock"

"show-clock" option is deprecated.

Styling notes:

"panel-item" - class for all panel items
"panel-item-indicator" - indicators (builtin and external)
"panel-item-spacer" - ~spacer
"panel-item-separator" - ~separator
"panel-item-text" - ~~text (maybe ~clock and ~host too)

"panel-item-hovered" - replacement for ":hover". Only for "panel-item-indicator" items.

Usage:

#power_menuitem.indicator-hovered
{
    color: red;
}

#power_menuitem:hover
{
    color: orange;
}

To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'src/Makefile.am'
2--- src/Makefile.am 2014-05-21 17:44:19 +0000
3+++ src/Makefile.am 2014-06-08 14:43:42 +0000
4@@ -7,7 +7,8 @@
5
6 lightdm_gtk_greeter_SOURCES = \
7 $(lightdm_gtk_greeter_built_sources) \
8- lightdm-gtk-greeter.c
9+ lightdm-gtk-greeter.c \
10+ greetermenubar.c
11
12 AM_CPPFLAGS = \
13 -I$(top_srcdir) \
14
15=== added file 'src/greeter_menu_bar.xml'
16--- src/greeter_menu_bar.xml 1970-01-01 00:00:00 +0000
17+++ src/greeter_menu_bar.xml 2014-06-08 14:43:42 +0000
18@@ -0,0 +1,8 @@
19+<glade-catalog name="greeter_menu_bar" domain="glade-3"
20+ depends="gtk+" version="1.0">
21+ <glade-widget-classes>
22+ <glade-widget-class title="Greeter MenuBar" name="GreeterMenuBar"
23+ generic-name="GreeterMenuBar" parent="GtkMenuBar"
24+ icon-name="widget-gtk-window"/>
25+ </glade-widget-classes>
26+</glade-catalog>
27
28=== added file 'src/greetermenubar.c'
29--- src/greetermenubar.c 1970-01-01 00:00:00 +0000
30+++ src/greetermenubar.c 2014-06-08 14:43:42 +0000
31@@ -0,0 +1,342 @@
32+#include <gtk/gtk.h>
33+#include "greetermenubar.h"
34+
35+
36+static void greeter_menu_bar_size_allocate(GtkWidget* widget, GtkAllocation* allocation);
37+
38+G_DEFINE_TYPE(GreeterMenuBar, greeter_menu_bar, GTK_TYPE_MENU_BAR);
39+
40+static void
41+greeter_menu_bar_class_init(GreeterMenuBarClass* klass)
42+{
43+ GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
44+ widget_class->size_allocate = greeter_menu_bar_size_allocate;
45+}
46+
47+static void
48+greeter_menu_bar_init(GreeterMenuBar* square)
49+{
50+
51+}
52+
53+GtkWidget*
54+greeter_menu_bar_new()
55+{
56+ return GTK_WIDGET(g_object_new(greeter_menu_bar_get_type(), NULL));
57+}
58+
59+#if GTK_CHECK_VERSION (3, 0, 0)
60+static gint
61+sort_minimal_size(gconstpointer a, gconstpointer b, GtkRequestedSize* sizes)
62+{
63+ gint a_size = sizes[GPOINTER_TO_INT(a)].natural_size;
64+ gint b_size = sizes[GPOINTER_TO_INT(b)].natural_size;
65+ return a_size == b_size ? 0 : a_size > b_size ? -1 : +1;
66+}
67+
68+static void
69+greeter_menu_bar_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
70+{
71+ GList* item;
72+ GList* shell_children;
73+ GList* expand_nums = NULL;
74+ guint visible_count = 0, expand_count = 0;
75+
76+ g_return_if_fail(allocation != NULL);
77+ g_return_if_fail(GREETER_IS_MENU_BAR(widget));
78+
79+ gtk_widget_set_allocation(widget, allocation);
80+
81+ GtkPackDirection pack_direction = gtk_menu_bar_get_pack_direction(GTK_MENU_BAR(widget));
82+ g_return_if_fail(pack_direction == GTK_PACK_DIRECTION_LTR || pack_direction == GTK_PACK_DIRECTION_RTL);
83+
84+ shell_children = gtk_container_get_children(GTK_CONTAINER(widget));
85+
86+ for(item = shell_children; item; item = g_list_next(item))
87+ if(gtk_widget_get_visible(item->data))
88+ {
89+ if(gtk_widget_compute_expand(item->data, GTK_ORIENTATION_HORIZONTAL))
90+ {
91+ expand_nums = g_list_prepend(expand_nums, GINT_TO_POINTER(visible_count));
92+ expand_count++;
93+ }
94+ visible_count++;
95+ }
96+
97+ if(gtk_widget_get_realized(widget))
98+ gdk_window_move_resize(gtk_widget_get_window(widget),
99+ allocation->x, allocation->y,
100+ allocation->width, allocation->height);
101+
102+ if(visible_count > 0)
103+ {
104+ GtkAllocation remaining_space;
105+ GtkStyleContext* context = gtk_widget_get_style_context(widget);
106+ GtkStateFlags flags = gtk_widget_get_state_flags(widget);
107+ GtkRequestedSize* requested_sizes = g_newa(GtkRequestedSize, visible_count);
108+ guint border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
109+ GtkShadowType shadow_type = GTK_SHADOW_OUT;
110+ GtkBorder border;
111+ gint toggle_size;
112+
113+ gtk_style_context_get_padding(context, flags, &border);
114+ gtk_widget_style_get(widget, "shadow-type", &shadow_type, NULL);
115+
116+ remaining_space.x = (border_width + border.left);
117+ remaining_space.y = (border_width + border.top);
118+ remaining_space.width = allocation->width -
119+ 2 * border_width - border.left - border.right;
120+ remaining_space.height = allocation->height -
121+ 2 * border_width - border.top - border.bottom;
122+
123+ if (shadow_type != GTK_SHADOW_NONE)
124+ {
125+ gtk_style_context_get_border(context, flags, &border);
126+
127+ remaining_space.x += border.left;
128+ remaining_space.y += border.top;
129+ remaining_space.width -= border.left + border.right;
130+ remaining_space.height -= border.top + border.bottom;
131+ }
132+
133+ GtkRequestedSize* request = requested_sizes;
134+ int size = remaining_space.width;
135+ gboolean ltr = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_LTR) == (pack_direction == GTK_PACK_DIRECTION_LTR);
136+
137+ for(item = shell_children; item; item = g_list_next(item))
138+ {
139+ if (!gtk_widget_get_visible(item->data))
140+ continue;
141+
142+ request->data = item->data;
143+ gtk_widget_get_preferred_width_for_height(item->data, remaining_space.height,
144+ &request->minimum_size,
145+ &request->natural_size);
146+ gtk_menu_item_toggle_size_request(GTK_MENU_ITEM(item->data),
147+ &toggle_size);
148+ request->minimum_size += toggle_size;
149+ request->natural_size += toggle_size;
150+
151+ gtk_menu_item_toggle_size_allocate(GTK_MENU_ITEM(item->data), toggle_size);
152+
153+ size -= request->minimum_size;
154+ request++;
155+ }
156+
157+ size = gtk_distribute_natural_allocation(size, visible_count, requested_sizes);
158+
159+ /* Distribution extra space for widgets with expand=True */
160+ if(size > 0 && expand_nums)
161+ {
162+ expand_nums = g_list_sort_with_data(expand_nums, (GCompareDataFunc)sort_minimal_size,
163+ requested_sizes);
164+ GList* first_item = expand_nums;
165+ gint needed_size = -1;
166+ gint max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
167+ gint total_needed_size = 0;
168+
169+
170+ /* Free space that all widgets need to have the same (max_size) width
171+ * [___max_width___][widget ][widget____ ]
172+ * total_needed_size := [] + [ ] + [ ]
173+ * total_needed_size = [ ]
174+ */
175+ for(item = g_list_next(expand_nums); item; item = g_list_next(item))
176+ total_needed_size += max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
177+
178+ while(first_item)
179+ {
180+ if(size >= total_needed_size)
181+ {
182+ /* total_needed_size is enough for all remaining widgets */
183+ needed_size = max_size + (size - total_needed_size)/expand_count;
184+ break;
185+ }
186+ /* Removing current maximal widget from list */
187+ total_needed_size -= max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
188+ first_item = g_list_next(first_item);
189+ if(first_item)
190+ max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
191+ }
192+
193+ for(item = first_item; item; item = g_list_next(item))
194+ {
195+ request = &requested_sizes[GPOINTER_TO_INT(item->data)];
196+ gint dsize = needed_size - request->natural_size;
197+ if(size < dsize)
198+ dsize = size;
199+ size -= dsize;
200+ request->natural_size += dsize;
201+ }
202+ }
203+
204+ gint i;
205+ for(i = 0; i < visible_count; i++)
206+ {
207+ GtkAllocation child_allocation = remaining_space;
208+ request = &requested_sizes[i];
209+
210+ child_allocation.width = request->natural_size;
211+ remaining_space.width -= request->natural_size;
212+ if (ltr)
213+ remaining_space.x += request->natural_size;
214+ else
215+ child_allocation.x += remaining_space.width;
216+ gtk_widget_size_allocate(request->data, &child_allocation);
217+ }
218+ g_list_free(expand_nums);
219+ }
220+ g_list_free(shell_children);
221+}
222+#else
223+static gboolean
224+widget_get_expand (GtkWidget* widget)
225+{
226+ return g_object_get_data(G_OBJECT(widget),
227+ GREETER_MENU_BAR_EXPAND_PROP) != NULL;
228+}
229+
230+struct RequestedSize
231+{
232+ GtkWidget* child;
233+ GtkRequisition size;
234+};
235+
236+static gint
237+sort_minimal_size(gconstpointer a, gconstpointer b, struct RequestedSize* sizes)
238+{
239+ gint a_size = sizes[GPOINTER_TO_INT(a)].size.width;
240+ gint b_size = sizes[GPOINTER_TO_INT(b)].size.width;
241+ return a_size == b_size ? 0 : a_size > b_size ? -1 : +1;
242+}
243+
244+static void
245+greeter_menu_bar_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
246+{
247+ GList* item;
248+ GList* shell_children;
249+ GList* expand_nums = NULL;
250+ guint visible_count = 0, expand_count = 0;
251+
252+ g_return_if_fail (GTK_IS_MENU_BAR (widget));
253+ g_return_if_fail (allocation != NULL);
254+
255+ GtkPackDirection pack_direction = gtk_menu_bar_get_pack_direction(GTK_MENU_BAR(widget));
256+ g_return_if_fail(pack_direction == GTK_PACK_DIRECTION_LTR || pack_direction == GTK_PACK_DIRECTION_RTL);
257+
258+ shell_children = GTK_MENU_SHELL (widget)->children;
259+
260+ for(item = shell_children; item; item = g_list_next(item))
261+ if(gtk_widget_get_visible(item->data))
262+ {
263+ if(widget_get_expand(item->data))
264+ {
265+ expand_nums = g_list_prepend(expand_nums, GINT_TO_POINTER(visible_count));
266+ expand_count++;
267+ }
268+ visible_count++;
269+ }
270+
271+ widget->allocation = *allocation;
272+ if (gtk_widget_get_realized (widget))
273+ gdk_window_move_resize (widget->window,
274+ allocation->x, allocation->y,
275+ allocation->width, allocation->height);
276+
277+ if (visible_count)
278+ {
279+ gint toggle_size, ipadding;
280+ GtkTextDirection direction = gtk_widget_get_direction (widget);
281+ GtkShadowType shadow_type = GTK_SHADOW_OUT;
282+ GtkAllocation remaining_space;
283+
284+ gtk_widget_style_get (widget, "shadow-type", &shadow_type, NULL);
285+ gtk_widget_style_get (widget, "internal-padding", &ipadding, NULL);
286+
287+ remaining_space.x = (GTK_CONTAINER (widget)->border_width + ipadding);
288+ remaining_space.y = (GTK_CONTAINER (widget)->border_width);
289+ remaining_space.width = allocation->width - 2 * remaining_space.x;
290+ remaining_space.height = allocation->height - 2 * remaining_space.y;
291+
292+ if (shadow_type != GTK_SHADOW_NONE)
293+ {
294+ remaining_space.x += widget->style->xthickness;
295+ remaining_space.y += widget->style->ythickness;
296+ remaining_space.width -= 2 * widget->style->xthickness;
297+ remaining_space.height -= 2 * widget->style->ythickness;
298+ }
299+
300+ struct RequestedSize* requested_sizes = g_newa(struct RequestedSize, visible_count);
301+ struct RequestedSize* request = requested_sizes;
302+ int size = remaining_space.width;
303+
304+ for(item = shell_children; item; item = g_list_next(item))
305+ {
306+ if (!gtk_widget_get_visible (item->data))
307+ continue;
308+ request->child = item->data;
309+ gtk_menu_item_toggle_size_request (GTK_MENU_ITEM (request->child), &toggle_size);
310+ gtk_menu_item_toggle_size_allocate (GTK_MENU_ITEM (request->child), toggle_size);
311+ gtk_widget_get_child_requisition (request->child, &request->size);
312+ request->size.width += toggle_size;
313+ request->size.height += toggle_size;
314+ size -= request->size.width;
315+ ++request;
316+ }
317+
318+ if(size > 0 && expand_nums)
319+ {
320+ expand_nums = g_list_sort_with_data(expand_nums, (GCompareDataFunc)sort_minimal_size,
321+ requested_sizes);
322+ GList* first_item = expand_nums;
323+ gint needed_size = -1;
324+ gint max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].size.width;
325+ gint total_needed_size = 0;
326+
327+ for(item = g_list_next(expand_nums); item; item = g_list_next(item))
328+ total_needed_size += max_size - requested_sizes[GPOINTER_TO_INT(item->data)].size.width;
329+
330+ while(first_item)
331+ {
332+ if(size >= total_needed_size)
333+ {
334+ needed_size = max_size + (size - total_needed_size)/expand_count;
335+ break;
336+ }
337+ total_needed_size -= max_size - requested_sizes[GPOINTER_TO_INT(item->data)].size.width;
338+ first_item = g_list_next(first_item);
339+ if(first_item)
340+ max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].size.width;
341+ }
342+
343+ for(item = first_item; item; item = g_list_next(item))
344+ {
345+ request = &requested_sizes[GPOINTER_TO_INT(item->data)];
346+ gint dsize = needed_size - request->size.width;
347+ if(size < dsize)
348+ dsize = size;
349+ size -= dsize;
350+ request->size.width += dsize;
351+ }
352+ }
353+
354+ gboolean ltr = (direction == GTK_TEXT_DIR_LTR) == (pack_direction == GTK_PACK_DIRECTION_LTR);
355+ GtkAllocation child_allocation;
356+ gint i;
357+ for(i = 0; i < visible_count; i++)
358+ {
359+ child_allocation = remaining_space;
360+ request = &requested_sizes[i];
361+
362+ child_allocation.width = request->size.width;
363+ remaining_space.width -= request->size.width;
364+ if (ltr)
365+ remaining_space.x += request->size.width;
366+ else
367+ child_allocation.x += remaining_space.width;
368+ gtk_widget_size_allocate(request->child, &child_allocation);
369+ }
370+ g_list_free(expand_nums);
371+ }
372+}
373+#endif
374
375=== added file 'src/greetermenubar.h'
376--- src/greetermenubar.h 1970-01-01 00:00:00 +0000
377+++ src/greetermenubar.h 2014-06-08 14:43:42 +0000
378@@ -0,0 +1,37 @@
379+#ifndef GREETER_MENU_BAR_H
380+#define GREETER_MENU_BAR_H
381+
382+#include <glib-object.h>
383+#include <gtk/gtk.h>
384+
385+#if !GTK_CHECK_VERSION (3, 0, 0)
386+#define GREETER_MENU_BAR_EXPAND_PROP "gtk2-fallback-expand"
387+#endif
388+
389+G_BEGIN_DECLS
390+
391+#define GREETER_MENU_BAR_TYPE (greeter_menu_bar_get_type())
392+#define GREETER_MENU_BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GREETER_MENU_BAR_TYPE, GreeterMenuBar))
393+#define GREETER_MENU_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GREETER_MENU_BAR_TYPE, GreeterMenuBarClass))
394+#define GREETER_IS_MENU_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GREETER_MENU_BAR_TYPE))
395+#define GREETER_IS_MENU_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GREETER_MENU_BAR_TYPE))
396+
397+typedef struct _GreeterMenuBar GreeterMenuBar;
398+typedef struct _GreeterMenuBarClass GreeterMenuBarClass;
399+
400+struct _GreeterMenuBar
401+{
402+ GtkMenuBar parent_instance;
403+};
404+
405+struct _GreeterMenuBarClass
406+{
407+ GtkMenuBarClass parent_class;
408+};
409+
410+GType greeter_menu_bar_get_type(void) G_GNUC_CONST;
411+GtkWidget *greeter_menu_bar_new(void);
412+
413+G_END_DECLS
414+
415+#endif /* GREETER_MENU_BAR_H */
416
417=== modified file 'src/lightdm-gtk-greeter.c'
418--- src/lightdm-gtk-greeter.c 2014-06-06 06:56:00 +0000
419+++ src/lightdm-gtk-greeter.c 2014-06-08 14:43:42 +0000
420@@ -55,7 +55,8 @@
421
422 #include <lightdm.h>
423
424-#include <src/lightdm-gtk-greeter-ui.h>
425+#include "src/greetermenubar.h"
426+#include "src/lightdm-gtk-greeter-ui.h"
427
428 #if GTK_CHECK_VERSION (3, 0, 0)
429 #include <src/lightdm-gtk-greeter-css-fallback.h>
430@@ -73,12 +74,22 @@
431
432 /* Panel Widgets */
433 static GtkWindow *panel_window;
434+<<<<<<< TREE
435 static GtkWidget *clock_label;
436 static GtkWidget *menubar, *power_menuitem, *session_menuitem, *language_menuitem, *a11y_menuitem,
437 *layout_menuitem, *session_badge;
438+=======
439+static GtkWidget *menubar;
440+static GtkWidget *power_menuitem, *language_menuitem, *a11y_menuitem, *session_menuitem, *session_badge;
441+>>>>>>> MERGE-SOURCE
442 static GtkWidget *suspend_menuitem, *hibernate_menuitem, *restart_menuitem, *shutdown_menuitem;
443+<<<<<<< TREE
444 static GtkWidget *keyboard_menuitem;
445 static GtkMenu *session_menu, *language_menu, *layout_menu;
446+=======
447+static GtkWidget *keyboard_menuitem, *clock_menuitem, *clock_label, *host_menuitem;
448+static GtkMenu *session_menu, *language_menu;
449+>>>>>>> MERGE-SOURCE
450
451 /* Login Window Widgets */
452 static GtkWindow *login_window;
453@@ -165,6 +176,36 @@
454 #endif
455
456
457+typedef enum
458+{
459+ PANEL_ITEM_INDICATOR,
460+ PANEL_ITEM_SPACER,
461+ PANEL_ITEM_SEPARATOR,
462+ PANEL_ITEM_TEXT
463+} GreeterPanelItemType;
464+
465+#if GTK_CHECK_VERSION (3, 0, 0)
466+static const gchar *PANEL_ITEM_STYLE = "panel-item";
467+static const gchar *PANEL_ITEM_STYLE_HOVERED = "panel-item-hovered";
468+
469+static const gchar *PANEL_ITEM_STYLES[] =
470+{
471+ "panel-item-indicator",
472+ "panel-item-spacer",
473+ "panel-item-separator",
474+ "panel-item-text"
475+};
476+#endif
477+
478+static const gchar *PANEL_ITEM_DATA_INDEX = "panel-item-data-index";
479+
480+#ifdef HAVE_LIBINDICATOR
481+static const gchar *INDICATOR_ITEM_DATA_OBJECT = "indicator-item-data-object";
482+static const gchar *INDICATOR_ITEM_DATA_ENTRY = "indicator-item-data-entry";
483+static const gchar *INDICATOR_ITEM_DATA_BOX = "indicator-item-data-box";
484+static const gchar *INDICATOR_DATA_MENUITEMS = "indicator-data-menuitems";
485+#endif
486+
487 static void
488 pam_message_finalize (PAMConversationMessage *message)
489 {
490@@ -172,34 +213,63 @@
491 g_free (message);
492 }
493
494+<<<<<<< TREE
495+=======
496+#if GTK_CHECK_VERSION (3, 0, 0)
497+static gboolean
498+panel_item_enter_notify_cb (GtkWidget *widget, GdkEvent *event, gpointer enter)
499+{
500+ GtkStyleContext *context = gtk_widget_get_style_context (widget);
501+ if (GPOINTER_TO_INT (enter))
502+ gtk_style_context_add_class (context, PANEL_ITEM_STYLE_HOVERED);
503+ else
504+ gtk_style_context_remove_class (context, PANEL_ITEM_STYLE_HOVERED);
505+ return FALSE;
506+}
507+#endif
508+
509+>>>>>>> MERGE-SOURCE
510 static void
511-add_indicator_to_panel (GtkWidget *indicator_item, gint index)
512+panel_add_item (GtkWidget *widget, gint index, GreeterPanelItemType item_type)
513 {
514 gint insert_pos = 0;
515 GList* items = gtk_container_get_children (GTK_CONTAINER (menubar));
516 GList* item;
517 for (item = items; item; item = item->next)
518 {
519- if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item->data), "indicator-custom-index-data")) < index)
520+ if (GPOINTER_TO_INT (g_object_get_data (G_OBJECT (item->data), PANEL_ITEM_DATA_INDEX)) < index)
521 break;
522 insert_pos++;
523 }
524 g_list_free (items);
525
526- gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), GTK_WIDGET (indicator_item), insert_pos);
527+ #if GTK_CHECK_VERSION (3, 0, 0)
528+ gtk_style_context_add_class (gtk_widget_get_style_context (widget), PANEL_ITEM_STYLE);
529+ gtk_style_context_add_class (gtk_widget_get_style_context (widget), PANEL_ITEM_STYLES[item_type]);
530+ if (item_type == PANEL_ITEM_INDICATOR)
531+ {
532+ g_signal_connect (G_OBJECT (widget), "enter-notify-event",
533+ G_CALLBACK (panel_item_enter_notify_cb), GINT_TO_POINTER(TRUE));
534+ g_signal_connect (G_OBJECT (widget), "leave-notify-event",
535+ G_CALLBACK (panel_item_enter_notify_cb), GINT_TO_POINTER(FALSE));
536+ }
537+ #endif
538+
539+ gtk_widget_show (widget);
540+ gtk_menu_shell_insert (GTK_MENU_SHELL (menubar), widget, insert_pos);
541 }
542
543 #ifdef HAVE_LIBINDICATOR
544 static gboolean
545-entry_scrolled (GtkWidget *menuitem, GdkEventScroll *event, gpointer data)
546+indicator_entry_scrolled_cb (GtkWidget *menuitem, GdkEventScroll *event, gpointer data)
547 {
548 IndicatorObject *io;
549 IndicatorObjectEntry *entry;
550
551 g_return_val_if_fail (GTK_IS_WIDGET (menuitem), FALSE);
552
553- io = g_object_get_data (G_OBJECT (menuitem), "indicator-custom-object-data");
554- entry = g_object_get_data (G_OBJECT (menuitem), "indicator-custom-entry-data");
555+ io = g_object_get_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_OBJECT);
556+ entry = g_object_get_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_ENTRY);
557
558 g_return_val_if_fail (INDICATOR_IS_OBJECT (io), FALSE);
559
560@@ -210,15 +280,15 @@
561 }
562
563 static void
564-entry_activated (GtkWidget *widget, gpointer user_data)
565+indicator_entry_activated_cb (GtkWidget *widget, gpointer user_data)
566 {
567 IndicatorObject *io;
568 IndicatorObjectEntry *entry;
569
570 g_return_if_fail (GTK_IS_WIDGET (widget));
571
572- io = g_object_get_data (G_OBJECT (widget), "indicator-custom-object-data");
573- entry = g_object_get_data (G_OBJECT (widget), "indicator-custom-entry-data");
574+ io = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_OBJECT);
575+ entry = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_ENTRY);
576
577 g_return_if_fail (INDICATOR_IS_OBJECT (io));
578
579@@ -226,10 +296,10 @@
580 }
581
582 static GtkWidget*
583-create_menuitem (IndicatorObject *io, IndicatorObjectEntry *entry, GtkWidget *menubar)
584+indicator_entry_create_menuitem (IndicatorObject *io, IndicatorObjectEntry *entry, GtkWidget *menubar)
585 {
586 GtkWidget *box, *menuitem;
587- gint index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (io), "indicator-custom-index-data"));
588+ gint index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (io), PANEL_ITEM_DATA_INDEX));
589
590 #if GTK_CHECK_VERSION (3, 0, 0)
591 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
592@@ -240,13 +310,13 @@
593
594 gtk_widget_add_events(GTK_WIDGET(menuitem), GDK_SCROLL_MASK);
595
596- g_object_set_data (G_OBJECT (menuitem), "indicator-custom-box-data", box);
597- g_object_set_data (G_OBJECT (menuitem), "indicator-custom-object-data", io);
598- g_object_set_data (G_OBJECT (menuitem), "indicator-custom-entry-data", entry);
599- g_object_set_data (G_OBJECT (menuitem), "indicator-custom-index-data", GINT_TO_POINTER (index));
600+ g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_BOX, box);
601+ g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_OBJECT, io);
602+ g_object_set_data (G_OBJECT (menuitem), INDICATOR_ITEM_DATA_ENTRY, entry);
603+ g_object_set_data (G_OBJECT (menuitem), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (index));
604
605- g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (entry_activated), NULL);
606- g_signal_connect (G_OBJECT (menuitem), "scroll-event", G_CALLBACK (entry_scrolled), NULL);
607+ g_signal_connect (G_OBJECT (menuitem), "activate", G_CALLBACK (indicator_entry_activated_cb), NULL);
608+ g_signal_connect (G_OBJECT (menuitem), "scroll-event", G_CALLBACK (indicator_entry_scrolled_cb), NULL);
609
610 if (entry->image)
611 gtk_box_pack_start (GTK_BOX(box), GTK_WIDGET(entry->image), FALSE, FALSE, 1);
612@@ -259,24 +329,24 @@
613
614 gtk_container_add (GTK_CONTAINER (menuitem), box);
615 gtk_widget_show (box);
616- add_indicator_to_panel (menuitem, index);
617+ panel_add_item(menuitem, index, PANEL_ITEM_INDICATOR);
618
619 return menuitem;
620 }
621
622 static void
623-entry_added (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)
624+indicator_entry_added_cb (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)
625 {
626 GHashTable *menuitem_lookup;
627 GtkWidget *menuitem;
628
629 /* if the menuitem doesn't already exist, create it now */
630- menuitem_lookup = g_object_get_data (G_OBJECT (io), "indicator-custom-menuitems-data");
631+ menuitem_lookup = g_object_get_data (G_OBJECT (io), INDICATOR_DATA_MENUITEMS);
632 g_return_if_fail (menuitem_lookup);
633 menuitem = g_hash_table_lookup (menuitem_lookup, entry);
634 if (!GTK_IS_WIDGET (menuitem))
635 {
636- menuitem = create_menuitem (io, entry, GTK_WIDGET (user_data));
637+ menuitem = indicator_entry_create_menuitem (io, entry, GTK_WIDGET (user_data));
638 g_hash_table_insert (menuitem_lookup, entry, menuitem);
639 }
640
641@@ -284,22 +354,22 @@
642 }
643
644 static void
645-entry_removed_cb (GtkWidget *widget, gpointer userdata)
646+remove_indicator_entry_cb (GtkWidget *widget, gpointer userdata)
647 {
648 IndicatorObject *io;
649 GHashTable *menuitem_lookup;
650 GtkWidget *menuitem;
651 gpointer entry;
652
653- io = g_object_get_data (G_OBJECT (widget), "indicator-custom-object-data");
654+ io = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_OBJECT);
655 if (!INDICATOR_IS_OBJECT (io))
656 return;
657
658- entry = g_object_get_data (G_OBJECT (widget), "indicator-custom-entry-data");
659+ entry = g_object_get_data (G_OBJECT (widget), INDICATOR_ITEM_DATA_ENTRY);
660 if (entry != userdata)
661 return;
662
663- menuitem_lookup = g_object_get_data (G_OBJECT (io), "indicator-custom-menuitems-data");
664+ menuitem_lookup = g_object_get_data (G_OBJECT (io), INDICATOR_DATA_MENUITEMS);
665 g_return_if_fail (menuitem_lookup);
666 menuitem = g_hash_table_lookup (menuitem_lookup, entry);
667 if (GTK_IS_WIDGET (menuitem))
668@@ -309,13 +379,13 @@
669 }
670
671 static void
672-entry_removed (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)
673+indicator_entry_removed_cb (IndicatorObject *io, IndicatorObjectEntry *entry, gpointer user_data)
674 {
675- gtk_container_foreach (GTK_CONTAINER (user_data), entry_removed_cb, entry);
676+ gtk_container_foreach (GTK_CONTAINER (user_data), remove_indicator_entry_cb, entry);
677 }
678
679 static void
680-menu_show (IndicatorObject *io, IndicatorObjectEntry *entry, guint32 timestamp, gpointer user_data)
681+indicator_menu_show_cb (IndicatorObject *io, IndicatorObjectEntry *entry, guint32 timestamp, gpointer user_data)
682 {
683 IndicatorObjectEntry *entrydata;
684 GtkWidget *menuitem;
685@@ -403,9 +473,14 @@
686 GHashTable *builtin_items = NULL;
687 GHashTableIter iter;
688 gpointer iter_value;
689+ #ifdef HAVE_LIBINDICATOR
690 gboolean inited = FALSE;
691+ #endif
692 gboolean fallback = FALSE;
693
694+ const gchar *DEFAULT_LAYOUT[] = {"~host", "~spacer", "~clock", "~spacer",
695+ "~session", "~language", "~a11y", "~power", NULL};
696+
697 #ifdef START_INDICATOR_SERVICES
698 GError *error = NULL;
699 gchar *AT_SPI_CMD[] = {"/usr/lib/at-spi2-core/at-spi-bus-launcher", "--launch-immediately", NULL};
700@@ -423,8 +498,9 @@
701 fallback = TRUE;
702 }
703
704- if (names && !fallback)
705+ if (!names || fallback)
706 {
707+<<<<<<< TREE
708 builtin_items = g_hash_table_new (g_str_hash, g_str_equal);
709
710 g_hash_table_insert (builtin_items, "~power", power_menuitem);
711@@ -436,15 +512,66 @@
712 g_hash_table_iter_init (&iter, builtin_items);
713 while (g_hash_table_iter_next (&iter, NULL, &iter_value))
714 gtk_container_remove (GTK_CONTAINER (menubar), iter_value);
715+=======
716+ names = (gchar**)DEFAULT_LAYOUT;
717+ length = g_strv_length (names);
718+>>>>>>> MERGE-SOURCE
719 }
720
721+ builtin_items = g_hash_table_new (g_str_hash, g_str_equal);
722+
723+ g_hash_table_insert (builtin_items, "~power", power_menuitem);
724+ g_hash_table_insert (builtin_items, "~session", session_menuitem);
725+ g_hash_table_insert (builtin_items, "~language", language_menuitem);
726+ g_hash_table_insert (builtin_items, "~a11y", a11y_menuitem);
727+ g_hash_table_insert (builtin_items, "~host", host_menuitem);
728+ g_hash_table_insert (builtin_items, "~clock", clock_menuitem);
729+
730+ g_hash_table_iter_init (&iter, builtin_items);
731+ while (g_hash_table_iter_next (&iter, NULL, &iter_value))
732+ gtk_container_remove (GTK_CONTAINER (menubar), iter_value);
733+
734 for (i = 0; i < length; ++i)
735 {
736- if (names[i][0] == '~' && g_hash_table_lookup_extended (builtin_items, names[i], NULL, &iter_value))
737+ if (names[i][0] == '~')
738 { /* Built-in indicators */
739- g_object_set_data (G_OBJECT (iter_value), "indicator-custom-index-data", GINT_TO_POINTER (i));
740- add_indicator_to_panel (iter_value, i);
741- g_hash_table_remove (builtin_items, (gconstpointer)names[i]);
742+ GreeterPanelItemType item_type = PANEL_ITEM_INDICATOR;
743+ if (g_hash_table_lookup_extended (builtin_items, names[i], NULL, &iter_value))
744+ g_hash_table_remove (builtin_items, (gconstpointer)names[i]);
745+ else if (g_strcmp0 (names[i], "~separator") == 0)
746+ {
747+ #if GTK_CHECK_VERSION (3, 0, 0)
748+ GtkWidget *separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
749+ #else
750+ GtkWidget *separator = gtk_vseparator_new ();
751+ #endif
752+ item_type = PANEL_ITEM_SEPARATOR;
753+ iter_value = gtk_separator_menu_item_new ();
754+ gtk_widget_show (separator);
755+ gtk_container_add (iter_value, separator);
756+ }
757+ else if (g_strcmp0 (names[i], "~spacer") == 0)
758+ {
759+ item_type = PANEL_ITEM_SPACER;
760+ iter_value = gtk_separator_menu_item_new ();
761+ gtk_menu_item_set_label (iter_value, "");
762+ #if GTK_CHECK_VERSION (3, 0, 0)
763+ gtk_widget_set_hexpand (iter_value, TRUE);
764+ #else
765+ g_object_set_data(G_OBJECT(iter_value), GREETER_MENU_BAR_EXPAND_PROP, "1");
766+ #endif
767+ }
768+ else if (names[i][1] == '~')
769+ {
770+ item_type = PANEL_ITEM_TEXT;
771+ iter_value = gtk_separator_menu_item_new ();
772+ gtk_menu_item_set_label (iter_value, &names[i][2]);
773+ }
774+ else
775+ continue;
776+
777+ g_object_set_data (G_OBJECT (iter_value), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (i));
778+ panel_add_item (iter_value, i, item_type);
779 continue;
780 }
781
782@@ -497,21 +624,21 @@
783 GList *entries, *lp;
784
785 /* used to store/fetch menu entries */
786- g_object_set_data_full (G_OBJECT (io), "indicator-custom-menuitems-data",
787+ g_object_set_data_full (G_OBJECT (io), INDICATOR_DATA_MENUITEMS,
788 g_hash_table_new (g_direct_hash, g_direct_equal),
789 (GDestroyNotify) g_hash_table_destroy);
790- g_object_set_data (G_OBJECT (io), "indicator-custom-index-data", GINT_TO_POINTER (i));
791+ g_object_set_data (G_OBJECT (io), PANEL_ITEM_DATA_INDEX, GINT_TO_POINTER (i));
792
793 g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
794- G_CALLBACK (entry_added), menubar);
795+ G_CALLBACK (indicator_entry_added_cb), menubar);
796 g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,
797- G_CALLBACK (entry_removed), menubar);
798+ G_CALLBACK (indicator_entry_removed_cb), menubar);
799 g_signal_connect (G_OBJECT (io), INDICATOR_OBJECT_SIGNAL_MENU_SHOW,
800- G_CALLBACK (menu_show), menubar);
801+ G_CALLBACK (indicator_menu_show_cb), menubar);
802
803 entries = indicator_object_get_entries (io);
804 for (lp = entries; lp; lp = g_list_next (lp))
805- entry_added (io, lp->data, menubar);
806+ indicator_entry_added_cb (io, lp->data, menubar);
807 g_list_free (entries);
808 }
809 else
810@@ -522,7 +649,7 @@
811 g_free (path);
812 #endif
813 }
814- if (names)
815+ if (names && names != (gchar**)DEFAULT_LAYOUT)
816 g_strfreev (names);
817
818 if (builtin_items)
819@@ -1691,9 +1818,6 @@
820 gchar *font_name, **tokens;
821 guint length;
822
823- /* Hide the clock since indicators are about to eat the screen. */
824- gtk_widget_hide(GTK_WIDGET(clock_label));
825-
826 g_object_get (gtk_settings_get_default (), "gtk-font-name", &font_name, NULL);
827 tokens = g_strsplit (font_name, " ", -1);
828 length = g_strv_length (tokens);
829@@ -1715,8 +1839,6 @@
830 else
831 {
832 g_object_set (gtk_settings_get_default (), "gtk-font-name", default_font_name, NULL);
833- /* Show the clock as needed */
834- gtk_widget_show_all(GTK_WIDGET(clock_label));
835 }
836 }
837
838@@ -2166,8 +2288,8 @@
839
840 strftime(time_str, 50, clock_format, timeinfo);
841 markup = g_markup_printf_escaped("<b>%s</b>", time_str);
842- if (g_strcmp0(markup, gtk_label_get_label(GTK_LABEL(clock_label))) != 0)
843- gtk_label_set_markup( GTK_LABEL(clock_label), markup );
844+ if (g_strcmp0(markup, gtk_label_get_label (GTK_LABEL (clock_label))) != 0)
845+ gtk_label_set_markup (GTK_LABEL (clock_label), markup);
846 g_free(markup);
847
848 return TRUE;
849@@ -2646,11 +2768,13 @@
850 gtk_style_context_add_class(GTK_STYLE_CONTEXT(gtk_widget_get_style_context(GTK_WIDGET(panel_window))), GTK_STYLE_CLASS_MENUBAR);
851 g_signal_connect (G_OBJECT (panel_window), "draw", G_CALLBACK (background_window_draw), NULL);
852 #endif
853- gtk_label_set_text (GTK_LABEL (gtk_builder_get_object (builder, "hostname_label")), lightdm_get_hostname ());
854 session_menu = GTK_MENU(gtk_builder_get_object (builder, "session_menu"));
855 language_menu = GTK_MENU(gtk_builder_get_object (builder, "language_menu"));
856+<<<<<<< TREE
857 layout_menu = GTK_MENU(gtk_builder_get_object (builder, "layout_menu"));
858 clock_label = GTK_WIDGET(gtk_builder_get_object (builder, "clock_label"));
859+=======
860+>>>>>>> MERGE-SOURCE
861 menubar = GTK_WIDGET (gtk_builder_get_object (builder, "menubar"));
862
863 /* Login window */
864@@ -2707,8 +2831,13 @@
865 language_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "language_menuitem"));
866 a11y_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "a11y_menuitem"));
867 power_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "power_menuitem"));
868+<<<<<<< TREE
869 layout_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "layout_menuitem"));
870 keyboard_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "keyboard_menuitem"));
871+=======
872+ clock_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "clock_menuitem"));
873+ host_menuitem = GTK_WIDGET (gtk_builder_get_object (builder, "host_menuitem"));
874+>>>>>>> MERGE-SOURCE
875
876 gtk_accel_map_add_entry ("<Login>/a11y/font", GDK_KEY_F1, 0);
877 gtk_accel_map_add_entry ("<Login>/a11y/contrast", GDK_KEY_F2, 0);
878@@ -2738,15 +2867,6 @@
879 g_free (value);
880 }
881
882- /* Clock */
883- gtk_widget_set_no_show_all(GTK_WIDGET(clock_label),
884- !g_key_file_get_boolean (config, "greeter", "show-clock", NULL));
885- gtk_widget_show_all(GTK_WIDGET(clock_label));
886- clock_format = g_key_file_get_value (config, "greeter", "clock-format", NULL);
887- if (!clock_format)
888- clock_format = "%a, %H:%M";
889- clock_timeout_thread();
890-
891 /* Session menu */
892 if (gtk_widget_get_visible (session_menuitem))
893 {
894@@ -2852,6 +2972,7 @@
895 g_signal_connect (G_OBJECT (power_menuitem),"activate", G_CALLBACK(power_menu_cb), NULL);
896 }
897
898+<<<<<<< TREE
899 /* Layout menu */
900 if (gtk_widget_get_visible (layout_menuitem))
901 {
902@@ -2899,6 +3020,25 @@
903 fallback_css_priority);
904 #endif
905
906+=======
907+
908+ /* Host label */
909+ if (gtk_widget_get_visible (host_menuitem))
910+ gtk_menu_item_set_label (GTK_MENU_ITEM (host_menuitem), lightdm_get_hostname ());
911+
912+ /* Clock label */
913+ if (gtk_widget_get_visible (clock_menuitem))
914+ {
915+ gtk_menu_item_set_label (GTK_MENU_ITEM (clock_menuitem), "");
916+ clock_label = gtk_bin_get_child (GTK_BIN (clock_menuitem));
917+ clock_format = g_key_file_get_value (config, "greeter", "clock-format", NULL);
918+ if (!clock_format)
919+ clock_format = "%a, %H:%M";
920+ clock_timeout_thread ();
921+ gdk_threads_add_timeout (1000, (GSourceFunc) clock_timeout_thread, NULL);
922+ }
923+
924+>>>>>>> MERGE-SOURCE
925 /* Users combobox */
926 renderer = gtk_cell_renderer_text_new();
927 gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (user_combo), renderer, TRUE);
928@@ -3011,7 +3151,6 @@
929 }
930 gtk_widget_set_sensitive (keyboard_menuitem, a11y_keyboard_command != NULL);
931 gtk_widget_set_visible (keyboard_menuitem, a11y_keyboard_command != NULL);
932- gdk_threads_add_timeout (1000, (GSourceFunc) clock_timeout_thread, NULL);
933
934 /* focus fix (source: unity-greeter) */
935 GdkWindow* root_window = gdk_get_default_root_window ();
936
937=== modified file 'src/lightdm-gtk-greeter.glade'
938--- src/lightdm-gtk-greeter.glade 2014-05-06 23:20:09 +0000
939+++ src/lightdm-gtk-greeter.glade 2014-06-08 14:43:42 +0000
940@@ -12,8 +12,10 @@
941 <group name="power_accelgroup"/>
942 </accel-groups>
943 <child>
944- <object class="GtkHBox" id="box3">
945+ <object class="GreeterMenuBar" id="menubar">
946+ <property name="name">menubar</property>
947 <property name="visible">True</property>
948+<<<<<<< TREE
949 <property name="can_focus">False</property>
950 <property name="homogeneous">True</property>
951 <child>
952@@ -186,6 +188,145 @@
953 <property name="pack_type">end</property>
954 <property name="position">2</property>
955 </packing>
956+=======
957+ <property name="can_focus">True</property>
958+ <property name="halign">fill</property>
959+ <property name="pack_direction">rtl</property>
960+ <signal name="key-press-event" handler="menubar_key_press_cb" swapped="no"/>
961+ <child>
962+ <object class="GtkMenuItem" id="power_menuitem">
963+ <property name="name">power_menuitem</property>
964+ <property name="visible">True</property>
965+ <property name="can_focus">True</property>
966+ <child type="submenu">
967+ <object class="GtkMenu" id="power_menu">
968+ <property name="visible">True</property>
969+ <property name="can_focus">False</property>
970+ <property name="accel_group">power_accelgroup</property>
971+ <child>
972+ <object class="GtkMenuItem" id="suspend_menuitem">
973+ <property name="visible">True</property>
974+ <property name="can_focus">False</property>
975+ <property name="label" translatable="yes">Suspend</property>
976+ <signal name="activate" handler="suspend_cb" swapped="no"/>
977+ </object>
978+ </child>
979+ <child>
980+ <object class="GtkMenuItem" id="hibernate_menuitem">
981+ <property name="visible">True</property>
982+ <property name="can_focus">False</property>
983+ <property name="label" translatable="yes">Hibernate</property>
984+ <signal name="activate" handler="hibernate_cb" swapped="no"/>
985+ </object>
986+ </child>
987+ <child>
988+ <object class="GtkMenuItem" id="restart_menuitem">
989+ <property name="visible">True</property>
990+ <property name="can_focus">False</property>
991+ <property name="label" translatable="yes">Restart...</property>
992+ <signal name="activate" handler="restart_cb" swapped="no"/>
993+ </object>
994+ </child>
995+ <child>
996+ <object class="GtkMenuItem" id="shutdown_menuitem">
997+ <property name="use_action_appearance">False</property>
998+ <property name="visible">True</property>
999+ <property name="can_focus">False</property>
1000+ <property name="accel_path">&lt;Login&gt;/power/shutdown</property>
1001+ <property name="label" translatable="yes">Shut Down...</property>
1002+ <signal name="activate" handler="shutdown_cb" swapped="no"/>
1003+ </object>
1004+ </child>
1005+ </object>
1006+ </child>
1007+ </object>
1008+ </child>
1009+ <child>
1010+ <object class="GtkMenuItem" id="a11y_menuitem">
1011+ <property name="name">a11y_menuitem</property>
1012+ <property name="visible">True</property>
1013+ <property name="can_focus">True</property>
1014+ <child type="submenu">
1015+ <object class="GtkMenu" id="a11y_menu">
1016+ <property name="visible">True</property>
1017+ <property name="can_focus">False</property>
1018+ <property name="accel_group">a11y_accelgroup</property>
1019+ <child>
1020+ <object class="GtkCheckMenuItem" id="large_font_menuitem">
1021+ <property name="use_action_appearance">False</property>
1022+ <property name="visible">True</property>
1023+ <property name="can_focus">False</property>
1024+ <property name="accel_path">&lt;Login&gt;/a11y/font</property>
1025+ <property name="label" translatable="yes">Large Font</property>
1026+ <signal name="toggled" handler="a11y_font_cb" swapped="no"/>
1027+ </object>
1028+ </child>
1029+ <child>
1030+ <object class="GtkCheckMenuItem" id="high_contrast_menuitem">
1031+ <property name="use_action_appearance">False</property>
1032+ <property name="visible">True</property>
1033+ <property name="can_focus">False</property>
1034+ <property name="accel_path">&lt;Login&gt;/a11y/contrast</property>
1035+ <property name="label" translatable="yes">High Contrast</property>
1036+ <signal name="toggled" handler="a11y_contrast_cb" swapped="no"/>
1037+ </object>
1038+ </child>
1039+ <child>
1040+ <object class="GtkCheckMenuItem" id="keyboard_menuitem">
1041+ <property name="use_action_appearance">False</property>
1042+ <property name="visible">True</property>
1043+ <property name="can_focus">False</property>
1044+ <property name="accel_path">&lt;Login&gt;/a11y/keyboard</property>
1045+ <property name="label" translatable="yes">On Screen Keyboard</property>
1046+ <property name="use_underline">True</property>
1047+ <signal name="toggled" handler="a11y_keyboard_cb" swapped="no"/>
1048+ </object>
1049+ </child>
1050+ </object>
1051+ </child>
1052+ </object>
1053+ </child>
1054+ <child>
1055+ <object class="GtkMenuItem" id="language_menuitem">
1056+ <property name="name">language_menuitem</property>
1057+ <property name="visible">True</property>
1058+ <property name="can_focus">True</property>
1059+ <property name="label">[language_code]</property>
1060+ <child type="submenu">
1061+ <object class="GtkMenu" id="language_menu">
1062+ <property name="visible">True</property>
1063+ <property name="can_focus">False</property>
1064+ </object>
1065+ </child>
1066+ </object>
1067+ </child>
1068+ <child>
1069+ <object class="GtkMenuItem" id="session_menuitem">
1070+ <property name="name">session_menuitem</property>
1071+ <property name="visible">True</property>
1072+ <property name="can_focus">True</property>
1073+ <child type="submenu">
1074+ <object class="GtkMenu" id="session_menu">
1075+ <property name="visible">True</property>
1076+ <property name="can_focus">False</property>
1077+ </object>
1078+ </child>
1079+ </object>
1080+ </child>
1081+ <child>
1082+ <object class="GtkSeparatorMenuItem" id="clock_menuitem">
1083+ <property name="name">clock_menuitem</property>
1084+ <property name="visible">False</property>
1085+ <property name="can_focus">False</property>
1086+ </object>
1087+ </child>
1088+ <child>
1089+ <object class="GtkSeparatorMenuItem" id="host_menuitem">
1090+ <property name="name">host_menuitem</property>
1091+ <property name="visible">False</property>
1092+ <property name="can_focus">False</property>
1093+ </object>
1094+>>>>>>> MERGE-SOURCE
1095 </child>
1096 </object>
1097 </child>

Subscribers

People subscribed via source and target branches