From d1d93fafb9ef98fdd0c9a5a486c179c03cbbfb33 Mon Sep 17 00:00:00 2001 From: root Date: Tue, 23 Apr 2013 01:16:16 -0700 Subject: Tue Apr 23 01:16:16 PDT 2013 --- community/cinnamon/PKGBUILD | 47 +- community/cinnamon/cinnamon.install | 18 - community/cinnamon/fix-keyboard-settings.patch | 83 - community/cinnamon/gnome-3.8.patch | 3669 ++++++++++++++++++++++++ 4 files changed, 3685 insertions(+), 132 deletions(-) delete mode 100644 community/cinnamon/fix-keyboard-settings.patch create mode 100644 community/cinnamon/gnome-3.8.patch (limited to 'community/cinnamon') diff --git a/community/cinnamon/PKGBUILD b/community/cinnamon/PKGBUILD index f4fecd1a7..a16839508 100644 --- a/community/cinnamon/PKGBUILD +++ b/community/cinnamon/PKGBUILD @@ -1,11 +1,11 @@ -# $Id: PKGBUILD 87446 2013-03-31 19:54:32Z faidoc $ +# $Id: PKGBUILD 88709 2013-04-22 00:29:56Z bgyorgy $ # Maintainer: Alexandre Filgueira # Contributor: M0Rf30 # Contributor: unifiedlinux # Contributor: CReimer pkgname=cinnamon -pkgver=1.7.3 +pkgver=1.7.4 pkgrel=2 pkgdesc="Linux desktop which provides advanced innovative features and a traditional user experience" arch=('i686' 'x86_64') @@ -13,8 +13,9 @@ url="http://cinnamon.linuxmint.com/" license=('GPL2') depends=('accountsservice' 'caribou' 'clutter-gtk' 'gjs' 'gnome-bluetooth' 'gnome-icon-theme' 'gnome-menus' 'gnome-settings-daemon' 'gnome-session' - 'gnome-themes-standard' 'gstreamer0.10' 'networkmanager' 'muffin' 'python2-dbus' - 'python2-gconf' 'python2-imaging' 'python2-pyinotify' 'python2-lxml' 'webkitgtk3') + 'gnome-themes-standard' 'gstreamer0.10' 'libgnome-keyring' 'librsvg' + 'networkmanager' 'muffin' 'pygtk' 'python2-dbus' 'python2-imaging' + 'python2-pyinotify' 'python2-lxml' 'webkitgtk3') makedepends=('gnome-common' 'intltool') optdepends=('cinnamon-control-center: extended configurations for Cinnamon' 'cinnamon-screensaver: lock screen' @@ -26,15 +27,21 @@ install=${pkgname}.install source=("$pkgname-$pkgver.tar.gz::https://github.com/linuxmint/Cinnamon/tarball/$pkgver" "keyboard_applet.patch" "fix-control-center-check.patch" - "fix-keyboard-settings.patch") -md5sums=('c733e2a2280508aecf3ee010587e6743' + "gnome-3.8.patch") +md5sums=('95260dc968ca9be32c265b35df2dd49d' '2b1ece84416c3e4de030be15f1774d82' 'c3f25b06d345d9d36c197cd96e08f496' - 'c36138eddde544b5c27b66d19451e7a5') + 'cf2efbe1a5c48e1be53a0e8e4b7c3181') build() { cd ${srcdir}/linuxmint-Cinnamon* + # Python2 fix + sed -i 's|#! /usr/bin/python|#! /usr/bin/python2|' \ + files/usr/bin/$pkgname-menu-editor \ + files/usr/share/$pkgname/applets/panel-launchers@$pkgname.org/$pkgname-add-panel-launcher.py + find -type f | xargs sed -i 's@^#!.*python$@#!/usr/bin/python2@' + # Fix Keyboard applet # https://github.com/linuxmint/Cinnamon/issues/1337 patch -Np1 -i ${srcdir}/keyboard_applet.patch @@ -42,9 +49,8 @@ build() { # Check for the cc-panel path, not for the unneeded binary patch -Np1 -i ${srcdir}/fix-control-center-check.patch - # Fix Keyboard settings (https://bugs.archlinux.org/task/34472) - patch -Np1 -i ${srcdir}/fix-keyboard-settings.patch - + # https://github.com/linuxmint/Cinnamon/pull/1888 + patch -Np1 -i ${srcdir}/gnome-3.8.patch ./autogen.sh --prefix=/usr \ --sysconfdir=/etc \ @@ -54,31 +60,10 @@ build() { --disable-schemas-compile \ --enable-compile-warnings=yes \ --with-session-tracking=systemd - make } package() { cd ${srcdir}/linuxmint-Cinnamon* make DESTDIR="${pkgdir}" install - - # Install autostart files for gnome-fallback-mount-helper - install -Dm644 /etc/xdg/autostart/gnome-fallback-mount-helper.desktop \ - "${pkgdir}/etc/xdg/autostart/gnome-fallback-mount-helper-cinnamon.desktop" - sed -i 's/^AutostartCondition=.*/AutostartCondition=GNOME3 if-session cinnamon/' \ - "${pkgdir}/etc/xdg/autostart/gnome-fallback-mount-helper-cinnamon.desktop" - - install -Dm644 /etc/xdg/autostart/gnome-fallback-mount-helper.desktop \ - "${pkgdir}/etc/xdg/autostart/gnome-fallback-mount-helper-cinnamon2d.desktop" - sed -i 's/^AutostartCondition=.*/AutostartCondition=GNOME3 if-session cinnamon2d/' \ - "${pkgdir}/etc/xdg/autostart/gnome-fallback-mount-helper-cinnamon2d.desktop" - - # Python2 fix - sed -i 's|#! /usr/bin/python|#! /usr/bin/python2|' \ - "${pkgdir}/usr/bin/$pkgname-menu-editor" \ - "${pkgdir}/usr/share/$pkgname/applets/panel-launchers@$pkgname.org/$pkgname-add-panel-launcher.py" - - find "${pkgdir}" -type f | xargs sed -i 's@^#!.*python$@#!/usr/bin/python2@' } - - diff --git a/community/cinnamon/cinnamon.install b/community/cinnamon/cinnamon.install index 901fd95c9..326aa98a2 100644 --- a/community/cinnamon/cinnamon.install +++ b/community/cinnamon/cinnamon.install @@ -2,28 +2,10 @@ post_install() { glib-compile-schemas usr/share/glib-2.0/schemas } -pre_upgrade() { - if [ -f /usr/share/gconf/schemas/cinnamon.schemas ]; then - gconfpkg --uninstall cinnamon - fi - - if [ "$(vercmp 1.6.7-6 "$2")" -eq 1 ]; then - if [[ -h '/usr/lib/libgnome-desktop-3.so.2' ]]; then - if [[ $(uname -m) == 'i686' ]]; then - unlink /usr/lib/libgnome-desktop-3.so.2 - fi - fi - fi -} - post_upgrade() { post_install } -pre_remove() { - pre_upgrade -} - post_remove() { post_install } diff --git a/community/cinnamon/fix-keyboard-settings.patch b/community/cinnamon/fix-keyboard-settings.patch deleted file mode 100644 index b606939c9..000000000 --- a/community/cinnamon/fix-keyboard-settings.patch +++ /dev/null @@ -1,83 +0,0 @@ -From 034f9c886a4b08e214193576b11fb97ba3d62922 Mon Sep 17 00:00:00 2001 -From: Lusito -Date: Sun, 10 Mar 2013 21:01:07 +0100 -Subject: [PATCH] fix for broken keyboard settings - ---- - files/usr/lib/cinnamon-settings/bin/SettingsWidgets.py | 2 +- - files/usr/lib/cinnamon-settings/modules/cs_keyboard.py | 12 ++++++------ - 2 files changed, 7 insertions(+), 7 deletions(-) - -diff --git a/files/usr/lib/cinnamon-settings/bin/SettingsWidgets.py b/files/usr/lib/cinnamon-settings/bin/SettingsWidgets.py -index b8842fe..cdccf46 100644 ---- a/files/usr/lib/cinnamon-settings/bin/SettingsWidgets.py -+++ b/files/usr/lib/cinnamon-settings/bin/SettingsWidgets.py -@@ -9,7 +9,7 @@ - import gettext - from gi.repository import Gio, Gtk, GObject, Gdk - from gi.repository import GdkPixbuf --# import gconf -+ from gi.repository import GConf - import json - import dbus - import time -diff --git a/files/usr/lib/cinnamon-settings/modules/cs_keyboard.py b/files/usr/lib/cinnamon-settings/modules/cs_keyboard.py -index 27a75ae..1ea8fd9 100644 ---- a/files/usr/lib/cinnamon-settings/modules/cs_keyboard.py -+++ b/files/usr/lib/cinnamon-settings/modules/cs_keyboard.py -@@ -8,7 +8,7 @@ - gettext.install("cinnamon", "/usr/share/cinnamon/locale") - - # Keybindings page - check if we need to store custom --# keybindings to gsettings key as well as gconf (In Mint 14 this is changed) -+# keybindings to gsettings key as well as GConf (In Mint 14 this is changed) - CUSTOM_KEYS_BASENAME = "/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings" - CUSTOM_KEYS_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys.custom-keybinding" - CUSTOM_KEYBINDINGS_GSETTINGS = False -@@ -160,7 +160,7 @@ def __init__(self, content_box): - first_run_completed = schema.get_boolean("custom-keybindings-to-3-6") - - if CUSTOM_KEYBINDINGS_GSETTINGS and not first_run_completed: -- gclient = gconf.client_get_default() -+ gclient = GConf.Client.get_default() - path = "/desktop/gnome/keybindings" - subdirs = gclient.all_dirs(path) - for subdir in subdirs: -@@ -251,7 +251,7 @@ def setBinding(self, index, val): - self.writeSettings() - - def writeSettings(self): -- gclient = gconf.client_get_default() -+ gclient = GConf.Client.get_default() - gclient.set_string(self.path + "/name", self.label) - gclient.set_string(self.path + "/action", self.action) - gclient.set_string(self.path + "/binding", self.entries[0]) -@@ -537,7 +537,7 @@ def loadCustoms(self): - for category in self.main_store: - if category.int_name is "custom": - category.clear() -- gclient = gconf.client_get_default() -+ gclient = GConf.Client.get_default() - path = "/desktop/gnome/keybindings" - subdirs = gclient.all_dirs(path) - for subdir in subdirs: -@@ -645,7 +645,7 @@ def onAddCustomButtonClicked(self, button): - dialog.destroy() - return - -- gclient = gconf.client_get_default() -+ gclient = GConf.Client.get_default() - path = "/desktop/gnome/keybindings/custom" - i = 0 - while gclient.dir_exists(path + str(i)): -@@ -670,7 +670,7 @@ def onRemoveCustomButtonClicked(self, button): - keybindings, iter = self.kb_tree.get_selection().get_selected() - if iter: - keybinding = keybindings[iter][1] -- gclient = gconf.client_get_default() -+ gclient = GConf.Client.get_default() - if gclient.dir_exists(keybinding.path): - gclient.unset(keybinding.path + "/name") - gclient.unset(keybinding.path + "/action") --- -1.8.1.5 diff --git a/community/cinnamon/gnome-3.8.patch b/community/cinnamon/gnome-3.8.patch new file mode 100644 index 000000000..61cd9180f --- /dev/null +++ b/community/cinnamon/gnome-3.8.patch @@ -0,0 +1,3669 @@ +From f4020d3960fa96a101bdb1c3ac1e1a452dbbf48c Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Fri, 19 Apr 2013 13:19:50 -0400 +Subject: [PATCH 01/15] Disable XInput on cinnamon startup (for 3.8 compat) + This has no effect on < 1.14 clutter + +--- + src/main.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/main.c b/src/main.c +index 418fb60..ac90d91 100644 +--- a/src/main.c ++++ b/src/main.c +@@ -260,6 +260,7 @@ + meta_plugin_type_register (gnome_cinnamon_plugin_get_type ()); + + /* Prevent meta_init() from causing gtk to load gail and at-bridge */ ++ g_setenv ("CLUTTER_DISABLE_XINPUT", "1", TRUE); + g_setenv ("NO_GAIL", "1", TRUE); + g_setenv ("NO_AT_BRIDGE", "1", TRUE); + meta_init (); +-- +1.8.1.6 + + +From cc68659ecdd9e43128ec2b4555479f930c0d1ccd Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Fri, 19 Apr 2013 13:21:40 -0400 +Subject: [PATCH 02/15] Explain change + +--- + src/main.c | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/src/main.c b/src/main.c +index ac90d91..9d37975 100644 +--- a/src/main.c ++++ b/src/main.c +@@ -257,10 +257,12 @@ + + g_option_context_free (ctx); + ++ /* Disable XInput extension - required for 3.8 compatibility */ ++ g_setenv ("CLUTTER_DISABLE_XINPUT", "1", TRUE); ++ + meta_plugin_type_register (gnome_cinnamon_plugin_get_type ()); + + /* Prevent meta_init() from causing gtk to load gail and at-bridge */ +- g_setenv ("CLUTTER_DISABLE_XINPUT", "1", TRUE); + g_setenv ("NO_GAIL", "1", TRUE); + g_setenv ("NO_AT_BRIDGE", "1", TRUE); + meta_init (); +-- +1.8.1.6 + + +From f3777b3b2733b965bd348c7175ee67ee268aee06 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Tue, 16 Apr 2013 17:01:30 -0400 +Subject: [PATCH 03/15] Add backgroundManager - this is needed for gnome 3.8 + compatibility, as gnome-settings-daemon no longer handles the desktop + background. + +--- + configure.ac | 7 +- + data/org.cinnamon.gschema.xml.in | 71 +++- + .../cinnamon-settings/modules/cs_backgrounds.py | 31 +- + js/ui/main.js | 3 +- + src/Makefile.am | 2 + + src/cinnamon-background-manager.c | 411 +++++++++++++++++++++ + src/cinnamon-background-manager.h | 57 +++ + 7 files changed, 562 insertions(+), 20 deletions(-) + create mode 100644 src/cinnamon-background-manager.c + create mode 100644 src/cinnamon-background-manager.h + +diff --git a/configure.ac b/configure.ac +index 0aa47c5..a2a9479 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -68,6 +68,7 @@ GTK_MIN_VERSION=3.0.0 + GIO_MIN_VERSION=2.29.10 + POLKIT_MIN_VERSION=0.100 + STARTUP_NOTIFICATION_MIN_VERSION=0.11 ++GNOME_DESKTOP_MIN_VERSION=3.0.0 + + # Collect more than 20 libraries for a prize! + PKG_CHECK_MODULES(CINNAMON, gio-2.0 >= $GIO_MIN_VERSION +@@ -82,7 +83,8 @@ PKG_CHECK_MODULES(CINNAMON, gio-2.0 >= $GIO_MIN_VERSION + gobject-introspection-1.0 >= $GOBJECT_INTROSPECTION_MIN_VERSION + libcanberra + polkit-agent-1 >= $POLKIT_MIN_VERSION xfixes +- libnm-glib libnm-util gnome-keyring-1) ++ libnm-glib libnm-util gnome-keyring-1 ++ gnome-desktop-3.0 >= GNOME_DESKTOP_MIN_VERSION) + + PKG_CHECK_MODULES(CINNAMON_PERF_HELPER, gtk+-3.0 gio-2.0) + +@@ -106,7 +108,8 @@ AC_CHECK_FUNCS(JS_NewGlobalObject XFixesCreatePointerBarrier) + CFLAGS=$saved_CFLAGS + LIBS=$saved_LIBS + +-PKG_CHECK_MODULES(ST, clutter-1.0 gtk+-3.0 libcroco-0.6 >= 0.6.2 gnome-desktop-3.0 >= 2.90.0 x11) ++PKG_CHECK_MODULES(ST, clutter-1.0 gtk+-3.0 libcroco-0.6 >= 0.6.2 ++ gnome-desktop-3.0 >= GNOME_DESKTOP_MIN_VERSION x11) + PKG_CHECK_MODULES(GDMUSER, dbus-glib-1 gtk+-3.0) + PKG_CHECK_MODULES(TRAY, gtk+-3.0) + PKG_CHECK_MODULES(GVC, libpulse libpulse-mainloop-glib gobject-2.0) +diff --git a/data/org.cinnamon.gschema.xml.in b/data/org.cinnamon.gschema.xml.in +index ffbad92..6f55477 100644 +--- a/data/org.cinnamon.gschema.xml.in ++++ b/data/org.cinnamon.gschema.xml.in +@@ -720,6 +720,23 @@ + + + ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ + + + "wallpaper" +@@ -750,8 +767,60 @@ + This key defines the delay for the slideshow. + + ++ ++ true ++ <_summary>Draw Desktop Background ++ <_description>Have GNOME draw the desktop background. ++ ++ ++ 'zoom' ++ <_summary>Picture Options ++ <_description> ++ Determines how the image set by wallpaper_filename is rendered. ++ Possible values are "none", "wallpaper", "centered", "scaled", ++ "stretched", "zoom", "spanned". ++ ++ ++ ++ 'file://@datadir@/themes/Adwaita/backgrounds/adwaita-timed.xml' ++ <_summary>Picture URI ++ <_description> ++ URI to use for the background image. Not that the backend only supports ++ local (file://) URIs. ++ ++ ++ ++ ++ 100 ++ <_summary>Picture Opacity ++ <_description> ++ Opacity with which to draw the background picture. ++ ++ ++ ++ '#023c88' ++ <_summary>Primary Color ++ <_description> ++ Left or Top color when drawing gradients, or the solid color. ++ ++ ++ ++ '#5789ca' ++ <_summary>Secondary Color ++ <_description> ++ Right or Bottom color when drawing gradients, not used for solid color. ++ ++ ++ ++ 'solid' ++ <_summary>Color Shading Type ++ <_description> ++ How to shade the background color. Possible values are "horizontal", ++ "vertical", and "solid". ++ ++ + +- ++ + + + "" +diff --git a/files/usr/lib/cinnamon-settings/modules/cs_backgrounds.py b/files/usr/lib/cinnamon-settings/modules/cs_backgrounds.py +index f964aed..4a38c84 100644 +--- a/files/usr/lib/cinnamon-settings/modules/cs_backgrounds.py ++++ b/files/usr/lib/cinnamon-settings/modules/cs_backgrounds.py +@@ -232,11 +232,11 @@ def getFirstFileFromBackgroundXml(self, filename): + + + class BackgroundWallpaperPane (Gtk.VBox): +- def __init__(self, sidepage, gnome_background_schema): ++ def __init__(self, sidepage, cinnamon_background_schema): + Gtk.VBox.__init__(self) + self.set_spacing(5) + +- self._gnome_background_schema = gnome_background_schema ++ self._cinnamon_background_schema = cinnamon_background_schema + self._sidepage = sidepage + + scw = Gtk.ScrolledWindow() +@@ -263,15 +263,15 @@ def _on_selection_changed(self, iconview): + if wallpaper: + for key in wallpaper: + if key == "filename": +- self._gnome_background_schema.set_string("picture-uri", "file://" + wallpaper[key]) ++ self._cinnamon_background_schema.set_string("picture-uri", "file://" + wallpaper[key]) + elif key == "pcolor": +- self._gnome_background_schema.set_string("primary-color", wallpaper[key]) ++ self._cinnamon_background_schema.set_string("primary-color", wallpaper[key]) + elif key == "scolor": +- self._gnome_background_schema.set_string("secondary-color", wallpaper[key]) ++ self._cinnamon_background_schema.set_string("secondary-color", wallpaper[key]) + elif key == "shade_type": +- self._gnome_background_schema.set_string("color-shading-type", wallpaper[key]) ++ self._cinnamon_background_schema.set_string("color-shading-type", wallpaper[key]) + elif key == "options": +- self._gnome_background_schema.set_string("picture-options", wallpaper[key]) ++ self._cinnamon_background_schema.set_string("picture-options", wallpaper[key]) + if (not "metadataFile" in wallpaper) or (wallpaper["metadataFile"] == ""): + self._sidepage.remove_wallpaper_button.set_sensitive(True) + +@@ -364,7 +364,7 @@ def run(self): + return res + + class BackgroundSlideshowPane(Gtk.Table): +- def __init__(self, sidepage, gnome_background_schema, cinnamon_background_schema): ++ def __init__(self, sidepage, cinnamon_background_schema): + Gtk.Table.__init__(self) + self.set_col_spacings(5) + self.set_row_spacings(5) +@@ -445,12 +445,11 @@ def _do_update_list(self, folder, recursive, delay, transition_duration = 0): + f = open(filename, "w") + f.write(xml_data) + f.close() +- Gio.Settings("org.gnome.desktop.background").set_string("picture-uri", "file://" + filename) ++ Gio.Settings("org.cinnamon.background").set_string("picture-uri", "file://" + filename) + + class BackgroundSidePage (SidePage): + def __init__(self, name, icon, keywords, advanced, content_box): + SidePage.__init__(self, name, icon, keywords, advanced, content_box) +- self._gnome_background_schema = Gio.Settings("org.gnome.desktop.background") + self._cinnamon_background_schema = Gio.Settings("org.cinnamon.background") + self._add_wallpapers_dialog = AddWallpapersDialog() + +@@ -515,8 +514,8 @@ def build(self, advanced): + self.mainbox.set_visible_window(False) + self.content_box.pack_start(self.mainbox, True, True, 3) + +- self.wallpaper_pane = BackgroundWallpaperPane(self, self._gnome_background_schema) +- self.slideshow_pane = BackgroundSlideshowPane(self, self._gnome_background_schema, self._cinnamon_background_schema) ++ self.wallpaper_pane = BackgroundWallpaperPane(self, self._cinnamon_background_schema) ++ self.slideshow_pane = BackgroundSlideshowPane(self, self._cinnamon_background_schema) + if self._cinnamon_background_schema["mode"] == "slideshow": + self.mainbox.add(self.slideshow_pane) + else: +@@ -536,21 +535,21 @@ def build(self, advanced): + l = Gtk.Label(_("Picture aspect")) + l.set_alignment(0, 0.5) + advanced_options_box.pack_start(l, False, False, 0) +- self.picture_options = GSettingsComboBox("", "org.gnome.desktop.background", "picture-options", None, BACKGROUND_PICTURE_OPTIONS) ++ self.picture_options = GSettingsComboBox("", "org.cinnamon.background", "picture-options", None, BACKGROUND_PICTURE_OPTIONS) + advanced_options_box.pack_start(self.picture_options, False, False, 0) + + l = Gtk.Label(_("Gradient")) + l.set_alignment(0, 0.5) + advanced_options_box.pack_start(l, False, False, 0) +- self.color_shading_type = GSettingsComboBox("", "org.gnome.desktop.background", "color-shading-type", None, BACKGROUND_COLOR_SHADING_TYPES) ++ self.color_shading_type = GSettingsComboBox("", "org.cinnamon.background", "color-shading-type", None, BACKGROUND_COLOR_SHADING_TYPES) + advanced_options_box.pack_start(self.color_shading_type, False, False, 0) + + hbox = Gtk.HBox() + l = Gtk.Label(_("Colors")) + hbox.pack_start(l, False, False, 2) +- self.primary_color = GSettingsColorChooser("org.gnome.desktop.background", "primary-color", None) ++ self.primary_color = GSettingsColorChooser("org.cinnamon.background", "primary-color", None) + hbox.pack_start(self.primary_color, False, False, 2) +- self.secondary_color = GSettingsColorChooser("org.gnome.desktop.background", "secondary-color", None) ++ self.secondary_color = GSettingsColorChooser("org.cinnamon.background", "secondary-color", None) + hbox.pack_start(self.secondary_color, False, False, 2) + advanced_options_box.pack_start(hbox, False, False, 0) + self.content_box.show_all() +diff --git a/js/ui/main.js b/js/ui/main.js +index 11920a4..5cae372 100644 +--- a/js/ui/main.js ++++ b/js/ui/main.js +@@ -86,6 +86,7 @@ let _cssStylesheet = null; + let dynamicWorkspaces = null; + let nWorks = null; + let tracker = null; ++let backgroundManager = null; + let desktopShown; + + let workspace_names = []; +@@ -214,7 +215,7 @@ function start() { + // be predictable anyways. + tracker = Cinnamon.WindowTracker.get_default(); + Cinnamon.AppUsage.get_default(); +- ++ backgroundManager = Cinnamon.BackgroundManager.get_default(); + // The stage is always covered so Clutter doesn't need to clear it; however + // the color is used as the default contents for the Muffin root background + // actor so set it anyways. +diff --git a/src/Makefile.am b/src/Makefile.am +index 51413aa..6efce18 100644 +--- a/src/Makefile.am ++++ b/src/Makefile.am +@@ -105,6 +105,7 @@ cinnamon_public_headers_h = \ + cinnamon-app-system.h \ + cinnamon-app-usage.h \ + cinnamon-arrow.h \ ++ cinnamon-background-manager.h \ + cinnamon-doc-system.h \ + cinnamon-embedded-window.h \ + cinnamon-generic-container.h \ +@@ -142,6 +143,7 @@ libcinnamon_la_SOURCES = \ + cinnamon-app-system.c \ + cinnamon-app-usage.c \ + cinnamon-arrow.c \ ++ cinnamon-background-manager.c \ + cinnamon-doc-system.c \ + cinnamon-embedded-window.c \ + cinnamon-generic-container.c \ +diff --git a/src/cinnamon-background-manager.c b/src/cinnamon-background-manager.c +new file mode 100644 +index 0000000..9d95250 +--- /dev/null ++++ b/src/cinnamon-background-manager.c +@@ -0,0 +1,411 @@ ++/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- ++ * ++ * Copyright © 2001 Ximian, Inc. ++ * Copyright (C) 2007 William Jon McCann ++ * Copyright 2007 Red Hat, Inc. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ * ++ */ ++ ++#include "config.h" ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include ++ ++#include ++#include ++#include ++#include ++#include ++ ++#define GNOME_DESKTOP_USE_UNSTABLE_API ++#include ++#include ++ ++#include "cinnamon-background-manager.h" ++ ++#define CINNAMON_BACKGROUND_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), CINNAMON_TYPE_BACKGROUND_MANAGER, CinnamonBackgroundManagerPrivate)) ++ ++struct CinnamonBackgroundManagerPrivate ++{ ++ GSettings *settings; ++ GnomeBG *bg; ++ ++ GnomeBGCrossfade *fade; ++ ++ GDBusProxy *proxy; ++ guint proxy_signal_id; ++}; ++ ++static void cinnamon_background_manager_class_init (CinnamonBackgroundManagerClass *klass); ++static void cinnamon_background_manager_init (CinnamonBackgroundManager *background_manager); ++static void cinnamon_background_manager_finalize (GObject *object); ++ ++static void setup_bg (CinnamonBackgroundManager *manager); ++static void connect_screen_signals (CinnamonBackgroundManager *manager); ++ ++G_DEFINE_TYPE (CinnamonBackgroundManager, cinnamon_background_manager, G_TYPE_OBJECT) ++ ++static gpointer manager_object = NULL; ++ ++static gboolean ++dont_draw_background (CinnamonBackgroundManager *manager) ++{ ++ return !g_settings_get_boolean (manager->priv->settings, ++ "draw-background"); ++} ++ ++static void ++on_crossfade_finished (CinnamonBackgroundManager *manager) ++{ ++ g_object_unref (manager->priv->fade); ++ manager->priv->fade = NULL; ++} ++ ++static void ++draw_background (CinnamonBackgroundManager *manager, ++ gboolean use_crossfade) ++{ ++ GdkDisplay *display; ++ int n_screens; ++ int i; ++ ++ display = gdk_display_get_default (); ++ n_screens = gdk_display_get_n_screens (display); ++ ++ for (i = 0; i < n_screens; ++i) { ++ GdkScreen *screen; ++ GdkWindow *root_window; ++ cairo_surface_t *surface; ++ ++ screen = gdk_display_get_screen (display, i); ++ ++ root_window = gdk_screen_get_root_window (screen); ++ ++ surface = gnome_bg_create_surface (manager->priv->bg, ++ root_window, ++ gdk_screen_get_width (screen), ++ gdk_screen_get_height (screen), ++ TRUE); ++ ++ if (use_crossfade) { ++ ++ if (manager->priv->fade != NULL) { ++ g_object_unref (manager->priv->fade); ++ } ++ ++ manager->priv->fade = gnome_bg_set_surface_as_root_with_crossfade (screen, surface); ++ g_signal_connect_swapped (manager->priv->fade, "finished", ++ G_CALLBACK (on_crossfade_finished), ++ manager); ++ } else { ++ gnome_bg_set_surface_as_root (screen, surface); ++ } ++ ++ cairo_surface_destroy (surface); ++ } ++} ++ ++static void ++on_bg_transitioned (GnomeBG *bg, ++ CinnamonBackgroundManager *manager) ++{ ++ draw_background (manager, FALSE); ++} ++ ++static gboolean ++settings_change_event_cb (GSettings *settings, ++ gpointer keys, ++ gint n_keys, ++ CinnamonBackgroundManager *manager) ++{ ++ gnome_bg_load_from_preferences (manager->priv->bg, ++ manager->priv->settings); ++ return FALSE; ++} ++ ++static void ++on_screen_size_changed (GdkScreen *screen, ++ CinnamonBackgroundManager *manager) ++{ ++ draw_background (manager, FALSE); ++} ++ ++static void ++watch_bg_preferences (CinnamonBackgroundManager *manager) ++{ ++ g_signal_connect (manager->priv->settings, ++ "change-event", ++ G_CALLBACK (settings_change_event_cb), ++ manager); ++} ++ ++static void ++on_bg_changed (GnomeBG *bg, ++ CinnamonBackgroundManager *manager) ++{ ++ draw_background (manager, TRUE); ++} ++ ++static void ++setup_bg (CinnamonBackgroundManager *manager) ++{ ++ g_return_if_fail (manager->priv->bg == NULL); ++ ++ manager->priv->bg = gnome_bg_new (); ++ ++ g_signal_connect (manager->priv->bg, ++ "changed", ++ G_CALLBACK (on_bg_changed), ++ manager); ++ ++ g_signal_connect (manager->priv->bg, ++ "transitioned", ++ G_CALLBACK (on_bg_transitioned), ++ manager); ++ ++ connect_screen_signals (manager); ++ watch_bg_preferences (manager); ++ gnome_bg_load_from_preferences (manager->priv->bg, ++ manager->priv->settings); ++} ++ ++static void ++setup_bg_and_draw_background (CinnamonBackgroundManager *manager) ++{ ++ setup_bg (manager); ++ draw_background (manager, FALSE); ++} ++ ++static void ++disconnect_session_manager_listener (CinnamonBackgroundManager *manager) ++{ ++ if (manager->priv->proxy && manager->priv->proxy_signal_id) { ++ g_signal_handler_disconnect (manager->priv->proxy, ++ manager->priv->proxy_signal_id); ++ manager->priv->proxy_signal_id = 0; ++ } ++} ++ ++static void ++on_session_manager_signal (GDBusProxy *proxy, ++ const gchar *sender_name, ++ const gchar *signal_name, ++ GVariant *parameters, ++ gpointer user_data) ++{ ++ CinnamonBackgroundManager *manager = CINNAMON_BACKGROUND_MANAGER (user_data); ++ ++ if (g_strcmp0 (signal_name, "SessionRunning") == 0) { ++ setup_bg_and_draw_background (manager); ++ disconnect_session_manager_listener (manager); ++ } ++} ++ ++static void ++draw_background_after_session_loads (CinnamonBackgroundManager *manager) ++{ ++ GError *error = NULL; ++ GDBusProxyFlags flags; ++ ++ flags = G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | ++ G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START; ++ manager->priv->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, ++ flags, ++ NULL, /* GDBusInterfaceInfo */ ++ "org.gnome.SessionManager", ++ "/org/gnome/SessionManager", ++ "org.gnome.SessionManager", ++ NULL, /* GCancellable */ ++ &error); ++ if (manager->priv->proxy == NULL) { ++ g_warning ("Could not listen to session manager: %s", ++ error->message); ++ g_error_free (error); ++ return; ++ } ++ ++ manager->priv->proxy_signal_id = g_signal_connect (manager->priv->proxy, ++ "g-signal", ++ G_CALLBACK (on_session_manager_signal), ++ manager); ++} ++ ++ ++static void ++disconnect_screen_signals (CinnamonBackgroundManager *manager) ++{ ++ GdkDisplay *display; ++ int i; ++ int n_screens; ++ ++ display = gdk_display_get_default (); ++ n_screens = gdk_display_get_n_screens (display); ++ ++ for (i = 0; i < n_screens; ++i) { ++ GdkScreen *screen; ++ screen = gdk_display_get_screen (display, i); ++ g_signal_handlers_disconnect_by_func (screen, ++ G_CALLBACK (on_screen_size_changed), ++ manager); ++ } ++} ++ ++static void ++connect_screen_signals (CinnamonBackgroundManager *manager) ++{ ++ GdkDisplay *display; ++ int i; ++ int n_screens; ++ ++ display = gdk_display_get_default (); ++ n_screens = gdk_display_get_n_screens (display); ++ ++ for (i = 0; i < n_screens; ++i) { ++ GdkScreen *screen; ++ screen = gdk_display_get_screen (display, i); ++ g_signal_connect (screen, ++ "monitors-changed", ++ G_CALLBACK (on_screen_size_changed), ++ manager); ++ g_signal_connect (screen, ++ "size-changed", ++ G_CALLBACK (on_screen_size_changed), ++ manager); ++ } ++} ++ ++static void ++draw_background_changed (GSettings *settings, ++ const char *key, ++ CinnamonBackgroundManager *manager) ++{ ++ if (dont_draw_background (manager) == FALSE) ++ setup_bg_and_draw_background (manager); ++} ++ ++gboolean ++cinnamon_background_manager_start (CinnamonBackgroundManager *manager) ++{ ++ manager->priv->settings = g_settings_new ("org.cinnamon.background"); ++ g_signal_connect (manager->priv->settings, "changed::draw-background", ++ G_CALLBACK (draw_background_changed), manager); ++ ++ setup_bg_and_draw_background (manager); ++ //draw_background_after_session_loads (manager); ++ ++ ++ return TRUE; ++} ++ ++void ++cinnamon_background_manager_stop (CinnamonBackgroundManager *manager) ++{ ++ CinnamonBackgroundManagerPrivate *p = manager->priv; ++ ++ g_debug ("Stopping background manager"); ++ ++ disconnect_screen_signals (manager); ++ ++ if (manager->priv->proxy) { ++ disconnect_session_manager_listener (manager); ++ g_object_unref (manager->priv->proxy); ++ } ++ ++ g_signal_handlers_disconnect_by_func (manager->priv->settings, ++ settings_change_event_cb, ++ manager); ++ ++ if (p->settings != NULL) { ++ g_object_unref (p->settings); ++ p->settings = NULL; ++ } ++ ++ if (p->bg != NULL) { ++ g_object_unref (p->bg); ++ p->bg = NULL; ++ } ++} ++ ++/** ++ * cinnamon_background_manager_get_default: ++ * ++ * Return Value: (transfer none): The global #CinnamonBackgroundManager singleton ++ */ ++CinnamonBackgroundManager * ++cinnamon_background_manager_get_default () ++{ ++ static CinnamonBackgroundManager *instance = NULL; ++ ++ if (instance == NULL) ++ instance = g_object_new (CINNAMON_TYPE_BACKGROUND_MANAGER, NULL); ++ ++ return instance; ++} ++ ++static GObject * ++cinnamon_background_manager_constructor (GType type, ++ guint n_construct_properties, ++ GObjectConstructParam *construct_properties) ++{ ++ CinnamonBackgroundManager *background_manager; ++ ++ background_manager = CINNAMON_BACKGROUND_MANAGER (G_OBJECT_CLASS (cinnamon_background_manager_parent_class)->constructor (type, ++ n_construct_properties, ++ construct_properties)); ++ ++ return G_OBJECT (background_manager); ++} ++ ++static void ++cinnamon_background_manager_class_init (CinnamonBackgroundManagerClass *klass) ++{ ++ GObjectClass *object_class = G_OBJECT_CLASS (klass); ++ ++ object_class->constructor = cinnamon_background_manager_constructor; ++ object_class->finalize = cinnamon_background_manager_finalize; ++ ++ g_type_class_add_private (klass, sizeof (CinnamonBackgroundManagerPrivate)); ++} ++ ++static void ++cinnamon_background_manager_init (CinnamonBackgroundManager *manager) ++{ ++ manager->priv = CINNAMON_BACKGROUND_MANAGER_GET_PRIVATE (manager); ++ cinnamon_background_manager_start (manager); ++} ++ ++static void ++cinnamon_background_manager_finalize (GObject *object) ++{ ++ CinnamonBackgroundManager *background_manager; ++ ++ g_return_if_fail (object != NULL); ++ g_return_if_fail (CINNAMON_IS_BACKGROUND_MANAGER (object)); ++ ++ background_manager = CINNAMON_BACKGROUND_MANAGER (object); ++ ++ g_return_if_fail (background_manager->priv != NULL); ++ ++ G_OBJECT_CLASS (cinnamon_background_manager_parent_class)->finalize (object); ++} +diff --git a/src/cinnamon-background-manager.h b/src/cinnamon-background-manager.h +new file mode 100644 +index 0000000..9a56e32 +--- /dev/null ++++ b/src/cinnamon-background-manager.h +@@ -0,0 +1,57 @@ ++/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- ++ * ++ * Copyright (C) 2007 William Jon McCann ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. ++ * ++ */ ++ ++#ifndef __CINNAMON_BACKGROUND_MANAGER_H ++#define __CINNAMON_BACKGROUND_MANAGER_H ++ ++#include ++ ++G_BEGIN_DECLS ++ ++#define CINNAMON_TYPE_BACKGROUND_MANAGER (cinnamon_background_manager_get_type ()) ++#define CINNAMON_BACKGROUND_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), CINNAMON_TYPE_BACKGROUND_MANAGER, CinnamonBackgroundManager)) ++#define CINNAMON_BACKGROUND_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), CINNAMON_TYPE_BACKGROUND_MANAGER, CinnamonBackgroundManagerClass)) ++#define CINNAMON_IS_BACKGROUND_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), CINNAMON_TYPE_BACKGROUND_MANAGER)) ++#define CINNAMON_IS_BACKGROUND_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), CINNAMON_TYPE_BACKGROUND_MANAGER)) ++#define CINNAMON_BACKGROUND_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), CINNAMON_TYPE_BACKGROUND_MANAGER, CinnamonBackgroundManagerClass)) ++ ++typedef struct CinnamonBackgroundManagerPrivate CinnamonBackgroundManagerPrivate; ++ ++typedef struct ++{ ++ GObject parent; ++ CinnamonBackgroundManagerPrivate *priv; ++} CinnamonBackgroundManager; ++ ++typedef struct ++{ ++ GObjectClass parent_class; ++} CinnamonBackgroundManagerClass; ++ ++GType cinnamon_background_manager_get_type (void); ++ ++CinnamonBackgroundManager *cinnamon_background_manager_get_default (void); ++ ++gboolean cinnamon_background_manager_start (CinnamonBackgroundManager *manager); ++void cinnamon_background_manager_stop (CinnamonBackgroundManager *manager); ++ ++G_END_DECLS ++ ++#endif /* __CINNAMON_BACKGROUND_MANAGER_H */ +-- +1.8.1.6 + + +From 590a48961f2c7a1b18fb914a1d7212ffcdf03017 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Tue, 16 Apr 2013 18:28:16 -0400 +Subject: [PATCH 04/15] Change default background + +--- + data/org.cinnamon.gschema.xml.in | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/data/org.cinnamon.gschema.xml.in b/data/org.cinnamon.gschema.xml.in +index 6f55477..35b0972 100644 +--- a/data/org.cinnamon.gschema.xml.in ++++ b/data/org.cinnamon.gschema.xml.in +@@ -782,7 +782,7 @@ + + + +- 'file://@datadir@/themes/Adwaita/backgrounds/adwaita-timed.xml' ++ 'file:///usr/share/backgrounds/linuxmint/default_background.jpg' + <_summary>Picture URI + <_description> + URI to use for the background image. Not that the backend only supports +-- +1.8.1.6 + + +From ac8b0954c7506ae88059e488539f88d55329f070 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Tue, 16 Apr 2013 18:41:16 -0400 +Subject: [PATCH 05/15] Use distro-agnostic background.. + +--- + data/org.cinnamon.gschema.xml.in | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/data/org.cinnamon.gschema.xml.in b/data/org.cinnamon.gschema.xml.in +index 35b0972..0d01089 100644 +--- a/data/org.cinnamon.gschema.xml.in ++++ b/data/org.cinnamon.gschema.xml.in +@@ -782,7 +782,7 @@ + + + +- 'file:///usr/share/backgrounds/linuxmint/default_background.jpg' ++ 'file:///usr/share/themes/Adwaita/backgrounds/adwaita-timed.xml' + <_summary>Picture URI + <_description> + URI to use for the background image. Not that the backend only supports +-- +1.8.1.6 + + +From 81dbccb60231744999463a5b84c7c36358570929 Mon Sep 17 00:00:00 2001 +From: dalcde +Date: Mon, 15 Apr 2013 18:34:48 +0800 +Subject: [PATCH 06/15] [GDbus] Port DBus to GDBus (AltLinux patch) + +--- + .../applets/brightness@cinnamon.org/applet.js | 39 ++-- + .../cinnamon/applets/power@cinnamon.org/applet.js | 102 +++++---- + .../cinnamon/applets/sound@cinnamon.org/applet.js | 244 +++++---------------- + .../cinnamon/applets/xrandr@cinnamon.org/applet.js | 19 +- + js/misc/gnomeSession.js | 147 ++++--------- + js/misc/modemManager.js | 79 ++++--- + js/misc/screenSaver.js | 89 ++++---- + js/ui/appletManager.js | 1 - + js/ui/automountManager.js | 106 +++++---- + js/ui/autorunManager.js | 27 +-- + js/ui/calendar.js | 71 +++--- + js/ui/cinnamonDBus.js | 96 ++++---- + js/ui/endSessionDialog.js | 79 ++++--- + js/ui/keyboard.js | 48 ++-- + js/ui/layout.js | 14 +- + js/ui/magnifierDBus.js | 134 +++++++---- + js/ui/main.js | 6 - + js/ui/messageTray.js | 13 +- + js/ui/notificationDaemon.js | 193 ++++++++-------- + js/ui/scripting.js | 34 ++- + 20 files changed, 688 insertions(+), 853 deletions(-) + +diff --git a/files/usr/share/cinnamon/applets/brightness@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/brightness@cinnamon.org/applet.js +index 9cbda80..9087b25 100644 +--- a/files/usr/share/cinnamon/applets/brightness@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/brightness@cinnamon.org/applet.js +@@ -5,7 +5,6 @@ const St = imports.gi.St; + const PopupMenu = imports.ui.popupMenu; + const GLib = imports.gi.GLib; + const Gio = imports.gi.Gio; +-const DBus = imports.dbus; + + /* constants */ + const DimSettingsSchema = "org.gnome.settings-daemon.plugins.power"; +@@ -14,24 +13,25 @@ const DimSettingsBattery = "idle-dim-battery"; + const PowerBusName = 'org.gnome.SettingsDaemon'; + const PowerObjectPath = '/org/gnome/SettingsDaemon/Power'; + +-/* DBus interface */ +-const PowerManagerInterface = { +- name: 'org.gnome.SettingsDaemon.Power.Screen', +- methods: +- [ +- { name: 'GetPercentage', inSignature: '', outSignature: 'u' }, +- { name: 'SetPercentage', inSignature: 'u', outSignature: 'u' }, +- { name: 'StepUp', inSignature: '', outSignature: 'u' }, +- { name: 'StepDown', inSignature: '', outSignature: 'u' }, +- ], +- signals: +- [ +- { name: 'Changed', inSignature: '', outSignature: '' }, +- ] +-}; ++const PowerManagerInterface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + /* DBus magic */ +-let PowerManagerProxy = DBus.makeProxyClass(PowerManagerInterface); ++const PowerManagerProxy = Gio.DBusProxy.makeProxyWrapper(PowerManagerInterface); + + /* TextImageMenuItem taken from sound@cinnamon.org applet */ + let icon_path = "/usr/share/cinnamon/theme/"; +@@ -100,7 +100,7 @@ MyApplet.prototype = { + Applet.IconApplet.prototype._init.call(this, orientation, panel_height); + + try { +- this._proxy = new PowerManagerProxy(DBus.session, PowerBusName, PowerObjectPath); ++ this._proxy = new PowerManagerProxy(Gio.DBus.session, PowerBusName, PowerObjectPath); + + this.menuManager = new PopupMenu.PopupMenuManager(this); + this.menu = new Applet.AppletPopupMenu(this, orientation); +@@ -137,7 +137,8 @@ MyApplet.prototype = { + this.menu.addMenuItem(this._settingsMenu); + + //get notified +- this._proxy.connect('Changed', Lang.bind(this, this._getBrightness)); ++ this._proxy.connectSignal('Changed', Lang.bind(this, this._getBrightness)); ++ + this.actor.connect('scroll-event', Lang.bind(this, this._onScrollEvent)); + } else { + this.set_applet_tooltip(_("Brightness")); +diff --git a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +index c342fe7..b6b2bcd 100644 +--- a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +@@ -1,6 +1,5 @@ + const Applet = imports.ui.applet; + const Gio = imports.gi.Gio; +-const DBus = imports.dbus; + const Lang = imports.lang; + const St = imports.gi.St; + const PopupMenu = imports.ui.popupMenu; +@@ -42,34 +41,46 @@ const LabelDisplay = { + TIME: 'time' + }; + +-const PowerManagerInterface = { +- name: 'org.gnome.SettingsDaemon.Power', +- methods: [ +- { name: 'GetDevices', inSignature: '', outSignature: 'a(susdut)' }, +- { name: 'GetPrimaryDevice', inSignature: '', outSignature: '(susdut)' }, +- ], +- signals: [ +- { name: 'PropertiesChanged', inSignature: 's,a{sv},a[s]' }, +- ], +- properties: [ +- { name: 'Icon', signature: 's', access: 'read' }, +- ] +-}; +-let PowerManagerProxy = DBus.makeProxyClass(PowerManagerInterface); +- +-const SettingsManagerInterface = { +- name: 'org.freedesktop.DBus.Properties', +- methods: [ +- { name: 'Get', inSignature: 's,s', outSignature: 'v' }, +- { name: 'GetAll', inSignature: 's', outSignature: 'a{sv}' }, +- { name: 'Set', inSignature: 's,s,v', outSignature: '' } +- ], +- signals: [ +- {name: 'PropertiesChanged', inSignature:'s,a{sv},a[s]', outSignature:''} +- ] +-}; +- +-let SettingsManagerProxy = DBus.makeProxyClass(SettingsManagerInterface); ++const PowerManagerInterface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const PowerManagerProxy = Gio.DBusProxy.makeProxyWrapper(PowerManagerInterface); ++ ++const SettingsManagerInterface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const SettingsManagerProxy = Gio.DBusProxy.makeProxyWrapper(SettingsManagerInterface); + + function DeviceItem() { + this._init.apply(this, arguments); +@@ -143,11 +154,11 @@ MyApplet.prototype = { + this.menuManager = new PopupMenu.PopupMenuManager(this); + this.menu = new Applet.AppletPopupMenu(this, orientation); + this.menuManager.addMenu(this.menu); +- +- this.set_applet_icon_symbolic_name('battery-missing'); +- this._proxy = new PowerManagerProxy(DBus.session, BUS_NAME, OBJECT_PATH); +- this._smProxy = new SettingsManagerProxy(DBus.session, BUS_NAME, OBJECT_PATH); +- ++ ++ //this.set_applet_icon_symbolic_name('battery-missing'); ++ this._proxy = new PowerManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH); ++ this._smProxy = new SettingsManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH); ++ + let icon = this.actor.get_children()[0]; + this.actor.remove_actor(icon); + let box = new St.BoxLayout({ name: 'batteryBox' }); +@@ -306,18 +317,19 @@ MyApplet.prototype = { + this._devicesChanged(); + }, + +- _devicesChanged: function() { +- this.set_applet_icon_symbolic_name('battery-missing'); +- this._proxy.GetRemote('Icon', Lang.bind(this, function(icon, error) { +- if (icon) { +- let gicon = Gio.icon_new_for_string(icon); +- this._applet_icon.gicon = gicon; +- this.actor.show(); +- } else { +- this.menu.close(); +- this.actor.hide(); +- } +- })); ++ ++ _devicesChanged: function() { ++ this.set_applet_icon_symbolic_name('battery-missing'); ++ let icon = this._proxy.Icon; ++ if (icon) { ++ let gicon = Gio.icon_new_for_string(icon); ++ this.setGIcon(gicon); ++ this.actor.show(); ++ } else { ++ this.menu.close(); ++ this.actor.hide(); ++ } ++ + this._readPrimaryDevice(); + this._readOtherDevices(); + this._updateLabel(); +diff --git a/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js +index 1113b1e..5bfaf26 100644 +--- a/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js +@@ -1,7 +1,6 @@ + const Applet = imports.ui.applet; + const Mainloop = imports.mainloop; + const Gio = imports.gi.Gio; +-const DBus = imports.dbus; + const Lang = imports.lang; + const Cinnamon = imports.gi.Cinnamon; + const Clutter = imports.gi.Clutter; +@@ -12,90 +11,45 @@ const Gvc = imports.gi.Gvc; + const Pango = imports.gi.Pango; + const Tooltips = imports.ui.tooltips; + +-const PropIFace = { +- name: 'org.freedesktop.DBus.Properties', +- signals: [{ name: 'PropertiesChanged', +- inSignature: 'a{sv}'}] +-}; +- +-const MediaServer2IFace = { +- name: 'org.mpris.MediaPlayer2', +- methods: [{ name: 'Raise', +- inSignature: '', +- outSignature: '' }, +- { name: 'Quit', +- inSignature: '', +- outSignature: '' }], +- properties: [{ name: 'CanRaise', +- signature: 'b', +- access: 'read'}, +- { name: 'CanQuit', +- signature: 'b', +- access: 'read'}], +-}; +- +-const MediaServer2PlayerIFace = { +- name: 'org.mpris.MediaPlayer2.Player', +- methods: [{ name: 'PlayPause', +- inSignature: '', +- outSignature: '' }, +- { name: 'Pause', +- inSignature: '', +- outSignature: '' }, +- { name: 'Play', +- inSignature: '', +- outSignature: '' }, +- { name: 'Stop', +- inSignature: '', +- outSignature: '' }, +- { name: 'Next', +- inSignature: '', +- outSignature: '' }, +- { name: 'Previous', +- inSignature: '', +- outSignature: '' }, +- { name: 'SetPosition', +- inSignature: 'a{ov}', +- outSignature: '' }], +- properties: [{ name: 'Metadata', +- signature: 'a{sv}', +- access: 'read'}, +- { name: 'Shuffle', +- signature: 'b', +- access: 'readwrite'}, +- { name: 'Rate', +- signature: 'd', +- access: 'readwrite'}, +- { name: 'LoopStatus', +- signature: 'b', +- access: 'readwrite'}, +- { name: 'Volume', +- signature: 'd', +- access: 'readwrite'}, +- { name: 'PlaybackStatus', +- signature: 's', +- access: 'read'}, +- { name: 'Position', +- signature: 'x', +- access: 'read'}, +- { name: 'CanGoNext', +- signature: 'b', +- access: 'read'}, +- { name: 'CanGoPrevious', +- signature: 'b', +- access: 'read'}, +- { name: 'CanPlay', +- signature: 'b', +- access: 'read'}, +- { name: 'CanPause', +- signature: 'b', +- access: 'read'}, +- { name: 'CanSeek', +- signature: 'b', +- access: 'read'}], +- signals: [{ name: 'Seeked', +- inSignature: 'x' }] +-}; ++const PropIFace = ++ ++ ++ ++; ++ ++const MediaServer2IFace = ++ ++ ++ ++ ++; ++ ++const MediaServer2PlayerIFace = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + /* global values */ + let icon_path = "/usr/share/cinnamon/theme/"; +@@ -112,120 +66,20 @@ const VOLUME_ADJUSTMENT_STEP = 0.05; /* Volume adjustment step in % */ + const ICON_SIZE = 28; + + +-function Prop() { +- this._init.apply(this, arguments); ++var PropProxy = Gio.DBusProxy.makeProxyWrapper(PropIFace); ++function Prop(owner, initCallback, cancellable) { ++ return new PropProxy(Gio.DBus.session, owner, '/org/mpris/MediaPlayer2', initCallback, cancellable); + } + +-Prop.prototype = { +- _init: function(owner) { +- DBus.session.proxifyObject(this, owner, '/org/mpris/MediaPlayer2', this); +- } ++var MediaServer2Proxy = Gio.DBusProxy.makeProxyWrapper(MediaServer2IFace); ++function MediaServer2(owner, initCallback, cancellable) { ++ return new MediaServer2Proxy(Gio.DBus.session, owner, '/org/mpris/MediaPlayer2', initCallback, cancellable); + } +-DBus.proxifyPrototype(Prop.prototype, PropIFace) + +-function MediaServer2() { +- this._init.apply(this, arguments); +-} +- +-MediaServer2.prototype = { +- _init: function(owner) { +- DBus.session.proxifyObject(this, owner, '/org/mpris/MediaPlayer2', this); +- }, +- getRaise: function(callback) { +- this.GetRemote('CanRaise', Lang.bind(this, +- function(raise, ex) { +- if (!ex) +- callback(this, raise); +- })); +- }, +- getQuit: function(callback) { +- this.GetRemote('CanQuit', Lang.bind(this, +- function(quit, ex) { +- if (!ex) +- callback(this, quit); +- })); +- } +-} +-DBus.proxifyPrototype(MediaServer2.prototype, MediaServer2IFace) +- +-function MediaServer2Player() { +- this._init.apply(this, arguments); +-} +- +-MediaServer2Player.prototype = { +- _init: function(owner) { +- this._owner = owner; +- DBus.session.proxifyObject(this, owner, '/org/mpris/MediaPlayer2', this); +- }, +- getMetadata: function(callback) { +- this.GetRemote('Metadata', Lang.bind(this, +- function(metadata, ex) { +- if (!ex) +- callback(this, metadata); +- })); +- }, +- getPlaybackStatus: function(callback) { +- this.GetRemote('PlaybackStatus', Lang.bind(this, +- function(status, ex) { +- if (!ex) +- callback(this, status); +- })); +- }, +- getRate: function(callback) { +- this.GetRemote('Rate', Lang.bind(this, +- function(rate, ex) { +- if (!ex) +- callback(this, rate); +- })); +- }, +- getPosition: function(callback) { +- this.GetRemote('Position', Lang.bind(this, +- function(position, ex) { +- if (!ex) +- callback(this, position); +- })); +- }, +- getShuffle: function(callback) { +- this.GetRemote('Shuffle', Lang.bind(this, +- function(shuffle, ex) { +- if (!ex) +- callback(this, shuffle); +- })); +- }, +- setShuffle: function(value) { +- this.SetRemote('Shuffle', value); +- }, +- getVolume: function(callback) { +- this.GetRemote('Volume', Lang.bind(this, +- function(volume, ex) { +- if (!ex) +- callback(this, volume); +- })); +- }, +- setVolume: function(value) { +- this.SetRemote('Volume', parseFloat(value)); +- }, +- getRepeat: function(callback) { +- this.GetRemote('LoopStatus', Lang.bind(this, +- function(repeat, ex) { +- if (!ex) { +- if (repeat == "None") +- repeat = false +- else +- repeat = true +- callback(this, repeat); +- } +- })); +- }, +- setRepeat: function(value) { +- if (value) +- value = "Playlist" +- else +- value = "None" +- this.SetRemote('LoopStatus', value); +- } ++var MediaServer2PlayerProxy = Gio.DBusProxy.makeProxyWrapper(MediaServer2PlayerIFace); ++function MediaServer2Player(owner, initCallback, cancellable) { ++ return new MediaServer2PlayerProxy(Gio.DBus.session, owner, '/org/mpris/MediaPlayer2', initCallback, cancellable); + } +-DBus.proxifyPrototype(MediaServer2Player.prototype, MediaServer2PlayerIFace) + + function TrackInfo() { + this._init.apply(this, arguments); +@@ -715,7 +569,7 @@ MyApplet.prototype = { + this._players = {}; + // watch players + for (var p=0; p ++ ++ ++ ++ ++; ++ ++const XRandr2 = Gio.DBusProxy.makeProxyWrapper(XRandr2Iface); + + function MyApplet(orientation, panel_height) { + this._init(orientation, panel_height); +@@ -48,7 +49,7 @@ MyApplet.prototype = { + this.menu = new Applet.AppletPopupMenu(this, orientation); + this.menuManager.addMenu(this.menu); + +- this._proxy = new XRandr2(DBus.session, 'org.gnome.SettingsDaemon', '/org/gnome/SettingsDaemon/XRANDR'); ++ this._proxy = new XRandr2(Gio.DBus.session, 'org.gnome.SettingsDaemon', '/org/gnome/SettingsDaemon/XRANDR'); + + try { + this._screen = new GnomeDesktop.RRScreen({ gdk_screen: Gdk.Screen.get_default() }); +diff --git a/js/misc/gnomeSession.js b/js/misc/gnomeSession.js +index a2b61fd..e21d3a8 100644 +--- a/js/misc/gnomeSession.js ++++ b/js/misc/gnomeSession.js +@@ -1,20 +1,18 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; ++const Gio = imports.gi.Gio; + const Lang = imports.lang; + const Signals = imports.signals; + +-const PresenceIface = { +- name: 'org.gnome.SessionManager.Presence', +- methods: [{ name: 'SetStatus', +- inSignature: 'u', +- outSignature: '' }], +- properties: [{ name: 'status', +- signature: 'u', +- access: 'readwrite' }], +- signals: [{ name: 'StatusChanged', +- inSignature: 'u' }] +-}; ++const PresenceIface = ++ ++ ++ ++ ++ ++ ++ ++; + + const PresenceStatus = { + AVAILABLE: 0, +@@ -23,104 +21,37 @@ const PresenceStatus = { + IDLE: 3 + }; + +-function Presence() { +- this._init(); ++var PresenceProxy = Gio.DBusProxy.makeProxyWrapper(PresenceIface); ++function Presence(initCallback, cancellable) { ++ return new PresenceProxy(Gio.DBus.session, 'org.gnome.SessionManager', ++ '/org/gnome/SessionManager/Presence', initCallback, cancellable); + } + +-Presence.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, 'org.gnome.SessionManager', '/org/gnome/SessionManager/Presence', this); +- }, +- +- getStatus: function(callback) { +- this.GetRemote('status', Lang.bind(this, +- function(status, ex) { +- if (!ex) +- callback(this, status); +- })); +- }, +- +- setStatus: function(status) { +- this.SetStatusRemote(status); +- } +-}; +-DBus.proxifyPrototype(Presence.prototype, PresenceIface); +- +-// Note inhibitors are immutable objects, so they don't +-// change at runtime (changes always come in the form +-// of new inhibitors) +-const InhibitorIface = { +- name: 'org.gnome.SessionManager.Inhibitor', +- properties: [{ name: 'app_id', +- signature: 's', +- access: 'readonly' }, +- { name: 'client_id', +- signature: 's', +- access: 'readonly' }, +- { name: 'reason', +- signature: 's', +- access: 'readonly' }, +- { name: 'flags', +- signature: 'u', +- access: 'readonly' }, +- { name: 'toplevel_xid', +- signature: 'u', +- access: 'readonly' }, +- { name: 'cookie', +- signature: 'u', +- access: 'readonly' }], +-}; +- +-function Inhibitor(objectPath) { +- this._init(objectPath); ++const InhibitorIface = ++ ++ ++ ++ ++ ++ ++; ++ ++var InhibitorProxy = Gio.DBusProxy.makeProxyWrapper(InhibitorIface); ++function Inhibitor(objectPath, initCallback, cancellable) { ++ return new InhibitorProxy(Gio.DBus.session, 'org.gnome.SessionManager', objectPath, initCallback, cancellable); + } + +-Inhibitor.prototype = { +- _init: function(objectPath) { +- DBus.session.proxifyObject(this, +- 'org.gnome.SessionManager', +- objectPath); +- this.isLoaded = false; +- this._loadingPropertiesCount = InhibitorIface.properties.length; +- for (let i = 0; i < InhibitorIface.properties.length; i++) { +- let propertyName = InhibitorIface.properties[i].name; +- this.GetRemote(propertyName, Lang.bind(this, +- function(value, exception) { +- if (exception) +- return; +- +- this[propertyName] = value; +- this._loadingPropertiesCount--; +- +- if (this._loadingPropertiesCount == 0) { +- this.isLoaded = true; +- this.emit('is-loaded'); +- } +- })); +- } +- }, +-}; +-DBus.proxifyPrototype(Inhibitor.prototype, InhibitorIface); +-Signals.addSignalMethods(Inhibitor.prototype); +- +- +-// Not the full interface, only the methods we use +-const SessionManagerIface = { +- name: 'org.gnome.SessionManager', +- methods: [ +- { name: 'Logout', inSignature: 'u', outSignature: '' }, +- { name: 'Shutdown', inSignature: '', outSignature: '' }, +- { name: 'CanShutdown', inSignature: '', outSignature: 'b' } +- ] +-}; +- +-function SessionManager() { +- this._init(); ++const SessionManagerIface = ++ ++ ++ ++ ++ ++ ++ ++; ++ ++var SessionManagerProxy = Gio.DBusProxy.makeProxyWrapper(SessionManagerIface); ++function SessionManager(initCallback, cancellable) { ++ return new SessionManagerProxy(Gio.DBus.session, 'org.gnome.SessionManager', '/org/gnome/SessionManager', initCallback, cancellable); + } +- +-SessionManager.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, 'org.gnome.SessionManager', '/org/gnome/SessionManager'); +- } +-}; +-DBus.proxifyPrototype(SessionManager.prototype, SessionManagerIface); +\ No newline at end of file +diff --git a/js/misc/modemManager.js b/js/misc/modemManager.js +index befd142..f35f925 100644 +--- a/js/misc/modemManager.js ++++ b/js/misc/modemManager.js +@@ -1,6 +1,6 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; ++const Gio = imports.gi.Gio; + const Lang = imports.lang; + const Cinnamon = imports.gi.Cinnamon; + const Signals = imports.signals; +@@ -8,33 +8,43 @@ const Signals = imports.signals; + // The following are not the complete interfaces, just the methods we need + // (or may need in the future) + +-const ModemGsmNetworkInterface = { +- name: 'org.freedesktop.ModemManager.Modem.Gsm.Network', +- methods: [ +- { name: 'GetRegistrationInfo', inSignature: '', outSignature: 'uss' }, +- { name: 'GetSignalQuality', inSignature: '', outSignature: 'u' } +- ], +- properties: [ +- { name: 'AccessTechnology', signature: 'u', access: 'read' } +- ], +- signals: [ +- { name: 'SignalQuality', inSignature: 'u' }, +- { name: 'RegistrationInfo', inSignature: 'uss' } +- ] +-}; +-const ModemGsmNetworkProxy = DBus.makeProxyClass(ModemGsmNetworkInterface); +- +-const ModemCdmaInterface = { +- name: 'org.freedesktop.ModemManager.Modem.Cdma', +- methods: [ +- { name: 'GetSignalQuality', inSignature: '', outSignature: 'u' }, +- { name: 'GetServingSystem', inSignature: '', outSignature: 'usu' } +- ], +- signals: [ +- { name: 'SignalQuality', inSignature: 'u' } +- ] +-}; +-const ModemCdmaProxy = DBus.makeProxyClass(ModemCdmaInterface); ++const ModemGsmNetworkInterface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const ModemGsmNetworkProxy = Gio.DBusProxy.makeProxyWrapper(ModemGsmNetworkInterface); ++ ++const ModemCdmaInterface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const ModemCdmaProxy = Gio.DBusProxy.makeProxyWrapper(ModemCdmaInterface); + + let _providersTable; + function _getProvidersTable() { +@@ -50,17 +60,17 @@ function ModemGsm() { + + ModemGsm.prototype = { + _init: function(path) { +- this._proxy = new ModemGsmNetworkProxy(DBus.system, 'org.freedesktop.ModemManager', path); ++ this._proxy = new ModemGsmNetworkProxy(Gio.DBus.system, 'org.freedesktop.ModemManager', path); + + this.signal_quality = 0; + this.operator_name = null; + + // Code is duplicated because the function have different signatures +- this._proxy.connect('SignalQuality', Lang.bind(this, function(proxy, quality) { ++ this._proxy.connectSignal('SignalQuality', Lang.bind(this, function(proxy, sender, [quality]) { + this.signal_quality = quality; + this.emit('notify::signal-quality'); + })); +- this._proxy.connect('RegistrationInfo', Lang.bind(this, function(proxy, status, code, name) { ++ this._proxy.connectSignal('RegistrationInfo', Lang.bind(this, function(proxy, sender, [status, code, name]) { + this.operator_name = this._findOperatorName(name, code); + this.emit('notify::operator-name'); + })); +@@ -154,12 +164,13 @@ function ModemCdma() { + } + + ModemCdma.prototype = { +- _init: function(path) { +- this._proxy = new ModemCdmaProxy(DBus.system, 'org.freedesktop.ModemManager', path); ++ _init: function(path) { ++ this._proxy = new ModemCdmaProxy(Gio.DBus.system, 'org.freedesktop.ModemManager', path); + + this.signal_quality = 0; + this.operator_name = null; +- this._proxy.connect('SignalQuality', Lang.bind(this, function(proxy, quality) { ++ this._proxy.connect('SignalQuality', Lang.bind(this, function(proxy, sender, params) { ++ this.signal_quality = params[0]; + this.signal_quality = quality; + this.emit('notify::signal-quality'); + +diff --git a/js/misc/screenSaver.js b/js/misc/screenSaver.js +index c471856..aec883f 100644 +--- a/js/misc/screenSaver.js ++++ b/js/misc/screenSaver.js +@@ -1,53 +1,48 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; + const Lang = imports.lang; +- +-const ScreenSaverIface = { +- name: 'org.gnome.ScreenSaver', +- methods: [{ name: 'GetActive', +- inSignature: '', +- outSignature: 'b' }, +- { name: 'Lock', +- inSignature: '' }, +- { name: 'SetActive', +- inSignature: 'b' }], +- signals: [{ name: 'ActiveChanged', +- inSignature: 'b' }] +-}; ++const Gio = imports.gi.Gio; ++ ++const ScreenSaverIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const ScreenSaverInfo = Gio.DBusInterfaceInfo.new_for_xml(ScreenSaverIface); + + function ScreenSaverProxy() { +- this._init(); ++ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.session, ++ g_interface_name: ScreenSaverInfo.name, ++ g_interface_info: ScreenSaverInfo, ++ g_name: 'org.gnome.ScreenSaver', ++ g_object_path: '/org/gnome/ScreenSaver', ++ g_flags: (Gio.DBusProxyFlags.DO_NOT_AUTO_START | ++ Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES) }); ++ self.init(null); ++ self.screenSaverActive = false; ++ ++ self.connectSignal('ActiveChanged', function(proxy, senderName, [isActive]) { ++ self.screenSaverActive = isActive; ++ }); ++ self.connect('notify::g-name-owner', function() { ++ if (self.g_name_owner) { ++ self.GetActiveRemote(function(result, excp) { ++ if (result) { ++ let [isActive] = result; ++ self.screenSaverActive = isActive; ++ } ++ }); ++ } else ++ self.screenSaverActive = false; ++ }); ++ ++ return self; + } +- +-ScreenSaverProxy.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, +- 'org.gnome.ScreenSaver', +- '/org/gnome/ScreenSaver'); +- +- DBus.session.watch_name('org.gnome.ScreenSaver', +- false, // do not launch a name-owner if none exists +- Lang.bind(this, this._onSSAppeared), +- Lang.bind(this, this._onSSVanished)); +- +- this.screenSaverActive = false; +- this.connect('ActiveChanged', +- Lang.bind(this, this._onActiveChanged)); +- }, +- +- _onSSAppeared: function(owner) { +- this.GetActiveRemote(Lang.bind(this, function(isActive) { +- this.screenSaverActive = isActive; +- })) +- }, +- +- _onSSVanished: function(oldOwner) { +- this.screenSaverActive = false; +- }, +- +- _onActiveChanged: function(object, isActive) { +- this.screenSaverActive = isActive; +- } +-}; +-DBus.proxifyPrototype(ScreenSaverProxy.prototype, ScreenSaverIface); +diff --git a/js/ui/appletManager.js b/js/ui/appletManager.js +index abf8136..830d80d 100644 +--- a/js/ui/appletManager.js ++++ b/js/ui/appletManager.js +@@ -7,7 +7,6 @@ const Cinnamon = imports.gi.Cinnamon; + const Main = imports.ui.main; + const Applet = imports.ui.applet; + const Extension = imports.ui.extension; +-const DBus = imports.dbus; + + // Maps uuid -> metadata object + var appletMeta; +diff --git a/js/ui/automountManager.js b/js/ui/automountManager.js +index fa73bfe..f29f9f3 100644 +--- a/js/ui/automountManager.js ++++ b/js/ui/automountManager.js +@@ -1,7 +1,6 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + + const Lang = imports.lang; +-const DBus = imports.dbus; + const Mainloop = imports.mainloop; + const Gio = imports.gi.Gio; + const Params = imports.misc.params; +@@ -15,63 +14,57 @@ const SETTING_ENABLE_AUTOMOUNT = 'automount'; + + const AUTORUN_EXPIRE_TIMEOUT_SECS = 10; + +-const ConsoleKitSessionIface = { +- name: 'org.freedesktop.ConsoleKit.Session', +- methods: [{ name: 'IsActive', +- inSignature: '', +- outSignature: 'b' }], +- signals: [{ name: 'ActiveChanged', +- inSignature: 'b' }] +-}; ++const ConsoleKitSessionIface = ++ ++ ++ ++ ++ ++ ++; + +-const ConsoleKitSessionProxy = DBus.makeProxyClass(ConsoleKitSessionIface); ++const ConsoleKitSessionProxy = Gio.DBusProxy.makeProxyWrapper(ConsoleKitSessionIface); + +-const ConsoleKitManagerIface = { +- name: 'org.freedesktop.ConsoleKit.Manager', +- methods: [{ name: 'GetCurrentSession', +- inSignature: '', +- outSignature: 'o' }] +-}; ++const ConsoleKitManagerIface = ++ ++ ++ ++; + +-function ConsoleKitManager() { +- this._init(); +-}; +- +-ConsoleKitManager.prototype = { +- _init: function() { +- this.sessionActive = true; +- +- DBus.system.proxifyObject(this, +- 'org.freedesktop.ConsoleKit', +- '/org/freedesktop/ConsoleKit/Manager'); ++const ConsoleKitManagerInfo = Gio.DBusInterfaceInfo.new_for_xml(ConsoleKitManagerIface); + +- DBus.system.watch_name('org.freedesktop.ConsoleKit', +- false, // do not launch a name-owner if none exists +- Lang.bind(this, this._onManagerAppeared), +- Lang.bind(this, this._onManagerVanished)); +- }, +- +- _onManagerAppeared: function(owner) { +- this.GetCurrentSessionRemote(Lang.bind(this, this._onCurrentSession)); +- }, +- +- _onManagerVanished: function(oldOwner) { +- this.sessionActive = true; +- }, +- +- _onCurrentSession: function(session) { +- this._ckSession = new ConsoleKitSessionProxy(DBus.system, 'org.freedesktop.ConsoleKit', session); +- +- this._ckSession.connect +- ('ActiveChanged', Lang.bind(this, function(object, isActive) { +- this.sessionActive = isActive; +- })); +- this._ckSession.IsActiveRemote(Lang.bind(this, function(isActive) { +- this.sessionActive = isActive; +- })); ++function ConsoleKitManager() { ++ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.system, ++ g_interface_name: ConsoleKitManagerInfo.name, ++ g_interface_info: ConsoleKitManagerInfo, ++ g_name: 'org.freedesktop.ConsoleKit', ++ g_object_path: '/org/freedesktop/ConsoleKit/Manager', ++ g_flags: (Gio.DBusProxyFlags.DO_NOT_AUTO_START | ++ Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES) }); ++ ++ self._updateSessionActive = function() { ++ if (self.g_name_owner) { ++ self.GetCurrentSessionRemote(function([session]) { ++ self._ckSession = new ConsoleKitSessionProxy(Gio.DBus.system, 'org.freedesktop.ConsoleKit', session); ++ ++ self._ckSession.connectSignal('ActiveChanged', function(object, senderName, [isActive]) { ++ self.sessionActive = isActive; ++ }); ++ self._ckSession.IsActiveRemote(function([isActive]) { ++ self.sessionActive = isActive; ++ }); ++ }); ++ } else { ++ self.sessionActive = true; ++ } + } +-}; +-DBus.proxifyPrototype(ConsoleKitManager.prototype, ConsoleKitManagerIface); ++ self.connect('notify::g-name-owner', ++ Lang.bind(self, self._updateSessionActive)); ++ ++ self._updateSessionActive(); ++ self.init(null); ++ return self; ++} + + function AutomountManager() { + this._init(); +@@ -85,9 +78,8 @@ AutomountManager.prototype = { + this.ckListener = new ConsoleKitManager(); + + this._ssProxy = new ScreenSaver.ScreenSaverProxy(); +- this._ssProxy.connect('ActiveChanged', +- Lang.bind(this, +- this._screenSaverActiveChanged)); ++ this._ssProxy.connectSignal('ActiveChanged', ++ Lang.bind(this, this._screenSaverActiveChanged)); + + this._volumeMonitor = Gio.VolumeMonitor.get(); + +@@ -110,7 +102,7 @@ AutomountManager.prototype = { + Mainloop.idle_add(Lang.bind(this, this._startupMountAll)); + }, + +- _screenSaverActiveChanged: function(object, isActive) { ++ _screenSaverActiveChanged: function(object, senderName, [isActive]) { + if (!isActive) { + this._volumeQueue.forEach(Lang.bind(this, function(volume) { + this._checkAndMountVolume(volume); +diff --git a/js/ui/autorunManager.js b/js/ui/autorunManager.js +index 02cd4da..99b6fbe 100644 +--- a/js/ui/autorunManager.js ++++ b/js/ui/autorunManager.js +@@ -1,7 +1,6 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + + const Lang = imports.lang; +-const DBus = imports.dbus; + const Gio = imports.gi.Gio; + const St = imports.gi.St; + +@@ -61,25 +60,19 @@ function startAppForMount(app, mount) { + + /******************************************/ + +-const HotplugSnifferIface = { +- name: 'org.Cinnamon.HotplugSniffer', +- methods: [{ name: 'SniffURI', +- inSignature: 's', +- outSignature: 'as' }] +-}; +- +-const HotplugSniffer = function() { +- this._init(); +-}; ++const HotplugSnifferIface = ++ ++ ++ ++ ++; + +-HotplugSniffer.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, ++const HotplugSnifferProxy = Gio.DBusProxy.makeProxyWrapper(HotplugSnifferIface); ++function HotplugSniffer() { ++ return new HotplugSnifferProxy(Gio.DBus.session, + 'org.Cinnamon.HotplugSniffer', + '/org/Cinnamon/HotplugSniffer'); +- }, +-}; +-DBus.proxifyPrototype(HotplugSniffer.prototype, HotplugSnifferIface); ++} + + function ContentTypeDiscoverer(callback) { + this._init(callback); +diff --git a/js/ui/calendar.js b/js/ui/calendar.js +index ff4777a..a97e2a9 100644 +--- a/js/ui/calendar.js ++++ b/js/ui/calendar.js +@@ -1,6 +1,5 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; + const Clutter = imports.gi.Clutter; + const Gio = imports.gi.Gio; + const Lang = imports.lang; +@@ -194,30 +193,34 @@ EmptyEventSource.prototype = { + }; + Signals.addSignalMethods(EmptyEventSource.prototype); + +-const CalendarServerIface = { +- name: 'org.Cinnamon.CalendarServer', +- methods: [{ name: 'GetEvents', +- inSignature: 'xxb', +- outSignature: 'a(sssbxxa{sv})' }], +- signals: [{ name: 'Changed', +- inSignature: '' }] +-}; +- +-const CalendarServer = function () { +- this._init(); +-}; +- +-CalendarServer.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, 'org.Cinnamon.CalendarServer', '/org/Cinnamon/CalendarServer'); +- } +-}; +- +-DBus.proxifyPrototype(CalendarServer.prototype, CalendarServerIface); ++const CalendarServerIface = ++ ++ ++ ++ ++ ++ ++ ++; ++ ++const CalendarServerInfo = Gio.DBusInterfaceInfo.new_for_xml(CalendarServerIface); ++ ++function CalendarServer() { ++ var self = new Gio.DBusProxy({ g_connection: Gio.DBus.session, ++ g_interface_name: CalendarServerInfo.name, ++ g_interface_info: CalendarServerInfo, ++ g_name: 'org.Cinnamon.CalendarServer', ++ g_object_path: '/org/Cinnamon/CalendarServer', ++ g_flags: (Gio.DBusProxyFlags.DO_NOT_AUTO_START | ++ Gio.DBusProxyFlags.DO_NOT_LOAD_PROPERTIES) }); ++ ++ self.init(null); ++ return self; ++} + + // an implementation that reads data from a session bus service +-function DBusEventSource(owner) { +- this._init(owner); ++function DBusEventSource() { ++ this._init(); + } + + function _datesEqual(a, b) { +@@ -240,16 +243,18 @@ function _dateIntervalsOverlap(a0, a1, b0, b1) + + + DBusEventSource.prototype = { +- _init: function(owner) { ++ _init: function() { + this._resetCache(); + +- this._dbusProxy = new CalendarServer(owner); +- this._dbusProxy.connect('Changed', Lang.bind(this, this._onChanged)); ++ this._dbusProxy = new CalendarServer(); ++ this._dbusProxy.connectSignal('Changed', Lang.bind(this, this._onChanged)); + +- DBus.session.watch_name('org.Cinnamon.CalendarServer', +- false, // do not launch a name-owner if none exists +- Lang.bind(this, this._onNameAppeared), +- Lang.bind(this, this._onNameVanished)); ++ this._dbusProxy.connect('notify::g-name-owner', Lang.bind(this, function() { ++ if (this._dbusProxy.g_name_owner) ++ this._onNameAppeared(); ++ else ++ this._onNameVanished(); ++ })); + }, + + _resetCache: function() { +@@ -272,7 +277,7 @@ DBusEventSource.prototype = { + this._loadEvents(false); + }, + +- _onEventsReceived: function(appointments) { ++ _onEventsReceived: function([appointments]) { + let newEvents = []; + if (appointments != null) { + for (let n = 0; n < appointments.length; n++) { +@@ -295,9 +300,9 @@ DBusEventSource.prototype = { + + _loadEvents: function(forceReload) { + if (this._curRequestBegin && this._curRequestEnd){ +- let callFlags = 0; ++ let callFlags = Gio.DBusCallFlags.NO_AUTO_START; + if (forceReload) +- callFlags |= DBus.CALL_FLAG_START; ++ callFlags = Gio.DBusCallFlags.NONE; + this._dbusProxy.GetEventsRemote(this._curRequestBegin.getTime() / 1000, + this._curRequestEnd.getTime() / 1000, + forceReload, +diff --git a/js/ui/cinnamonDBus.js b/js/ui/cinnamonDBus.js +index 600e92f..5d4eb1c 100644 +--- a/js/ui/cinnamonDBus.js ++++ b/js/ui/cinnamonDBus.js +@@ -1,7 +1,7 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; + const Lang = imports.lang; ++const Gio = imports.gi.Gio; + + const Config = imports.misc.config; + const Flashspot = imports.ui.flashspot; +@@ -9,48 +9,53 @@ const Main = imports.ui.main; + const AppletManager = imports.ui.appletManager; + const DeskletManager = imports.ui.deskletManager; + +-const CinnamonIface = { +- name: 'org.Cinnamon', +- methods: [{ name: 'Eval', +- inSignature: 's', +- outSignature: 'bs' +- }, +- { name: 'ScreenshotArea', +- inSignature: 'biiiibs', +- outSignature: '' +- }, +- { name: 'ScreenshotWindow', +- inSignature: 'bbbs', +- outSignature: '' +- }, +- { name: 'Screenshot', +- inSignature: 'bbs', +- outSignature: '' +- }, +- { +- name: 'FlashArea', +- inSignature: 'iiii', +- outSignature: '' +- }, +- { +- name: 'highlightApplet', +- inSignature: 'sb', +- outSignature: '' +- }, +- { +- name: 'activateCallback', +- inSignature: 'ssb', +- outSignature: '' +- } +- ], +- signals: [], +- properties: [{ name: 'OverviewActive', +- signature: 'b', +- access: 'readwrite' }, +- { name: 'CinnamonVersion', +- signature: 's', +- access: 'read' }] +-}; ++ ++const CinnamonIface = ++ ++ ++ ++ ++ ++ ++include_cursor ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++include_cursor ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + function Cinnamon() { + this._init(); +@@ -58,7 +63,8 @@ function Cinnamon() { + + Cinnamon.prototype = { + _init: function() { +- DBus.session.exportObject('/org/Cinnamon', this); ++ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(CinnamonIface, this); ++ this._dbusImpl.export(Gio.DBus.session, '/org/Cinnamon'); + }, + + /** +@@ -215,5 +221,3 @@ Cinnamon.prototype = { + CinnamonVersion: Config.PACKAGE_VERSION + }; + +-DBus.conformExport(Cinnamon.prototype, CinnamonIface); +- +diff --git a/js/ui/endSessionDialog.js b/js/ui/endSessionDialog.js +index e909f5f..4f1f7d0 100644 +--- a/js/ui/endSessionDialog.js ++++ b/js/ui/endSessionDialog.js +@@ -18,19 +18,19 @@ + * 02110-1335, USA. + */ + +-const DBus = imports.dbus; + const Lang = imports.lang; + const Signals = imports.signals; + + const AccountsService = imports.gi.AccountsService; + const Clutter = imports.gi.Clutter; ++const Gio = imports.gi.Gio; + const GLib = imports.gi.GLib; + const Gtk = imports.gi.Gtk; + const Pango = imports.gi.Pango; + const St = imports.gi.St; + const Cinnamon = imports.gi.Cinnamon; + +-const GnomeSession = imports.misc.gnomeSession ++const GnomeSession = imports.misc.gnomeSession; + const ModalDialog = imports.ui.modalDialog; + const Tweener = imports.ui.tweener; + +@@ -40,20 +40,20 @@ const _ITEM_ICON_SIZE = 48; + const _DIALOG_ICON_SIZE = 32; + + const GSM_SESSION_MANAGER_LOGOUT_FORCE = 2; +- +-const EndSessionDialogIface = { +- name: 'org.gnome.SessionManager.EndSessionDialog', +- methods: [{ name: 'Open', +- inSignature: 'uuuao', +- outSignature: '' +- } +- ], +- signals: [{ name: 'Canceled', +- inSignature: '', +- }], +- properties: [] +-}; +- ++const EndSessionDialogIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ + const logoutDialogContent = { + subjectWithUser: _("Log Out %s"), + subject: _("Log Out"), +@@ -230,8 +230,6 @@ function _setLabelText(label, text) { + function EndSessionDialog() { + if (_endSessionDialog == null) { + this._init(); +- DBus.session.exportObject('/org/gnome/SessionManager/EndSessionDialog', +- this); + _endSessionDialog = this; + } + +@@ -328,6 +326,9 @@ EndSessionDialog.prototype = { + if (this._applicationList.get_children().length == 0) + scrollView.hide(); + })); ++ ++ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(EndSessionDialogIface, this); ++ this._dbusImpl.export(Gio.DBus.session, '/org/gnome/SessionManager/EndSessionDialog'); + }, + + _onDestroy: function() { +@@ -442,25 +443,19 @@ EndSessionDialog.prototype = { + + close: function() { + ModalDialog.ModalDialog.prototype.close.call(this); +- DBus.session.emit_signal('/org/gnome/SessionManager/EndSessionDialog', +- 'org.gnome.SessionManager.EndSessionDialog', +- 'Closed', '', []); ++ this._dbusImpl.emit_signal('Closed', null); + }, + + cancel: function() { + this._stopTimer(); +- DBus.session.emit_signal('/org/gnome/SessionManager/EndSessionDialog', +- 'org.gnome.SessionManager.EndSessionDialog', +- 'Canceled', '', []); ++ this._dbusImpl.emit_signal('Canceled', null); + this.close(global.get_current_time()); + }, + + _confirm: function(signal) { + this._fadeOutDialog(); + this._stopTimer(); +- DBus.session.emit_signal('/org/gnome/SessionManager/EndSessionDialog', +- 'org.gnome.SessionManager.EndSessionDialog', +- signal, '', []); ++ this._dbusImpl.emit_signal(signal, null); + }, + + _onOpened: function() { +@@ -512,39 +507,41 @@ EndSessionDialog.prototype = { + this._updateContent(); + }, + +- OpenAsync: function(type, timestamp, totalSecondsToStayOpen, inhibitorObjectPaths, callback) { ++ OpenAsync: function(parameters, invocation) { ++ let [type, timestamp, totalSecondsToStayOpen, inhibitorObjectPaths] = parameters; + this._totalSecondsToStayOpen = totalSecondsToStayOpen; + this._inhibitors = []; + this._applicationList.destroy_children(); + this._type = type; + +- if (!(this._type in DialogContent)) +- throw new DBus.DBusError('org.Cinnamon.ModalDialog.TypeError', +- "Unknown dialog type requested"); ++ if (!(this._type in DialogContent)) { ++ invocation.report_dbus_error('org.Cinnamon.ModalDialog.TypeError', ++ "Unknown dialog type requested"); ++ return; ++ } + + for (let i = 0; i < inhibitorObjectPaths.length; i++) { +- let inhibitor = new GnomeSession.Inhibitor(inhibitorObjectPaths[i]); ++ let inhibitor = new GnomeSession.Inhibitor(inhibitorObjectPaths[i], Lang.bind(this, function(proxy, error) { ++ this._onInhibitorLoaded(proxy); ++ })); + +- inhibitor.connect('is-loaded', +- Lang.bind(this, function() { +- this._onInhibitorLoaded(inhibitor); +- })); + this._inhibitors.push(inhibitor); + } + + this._updateButtons(); + +- if (!this.open(timestamp)) +- throw new DBus.DBusError('org.Cinnamon.ModalDialog.GrabError', +- "Cannot grab pointer and keyboard"); ++ if (!this.open(timestamp)) { ++ invocation.report_dbus_error('org.Cinnamon.ModalDialog.GrabError', ++ "Cannot grab pointer and keyboard"); ++ return; ++ } + + this._updateContent(); + + let signalId = this.connect('opened', + Lang.bind(this, function() { +- callback(); ++ invocation.return_value(null); + this.disconnect(signalId); + })); + } + }; +-DBus.conformExport(EndSessionDialog.prototype, EndSessionDialogIface); +diff --git a/js/ui/keyboard.js b/js/ui/keyboard.js +index f55cf93..69edb51 100644 +--- a/js/ui/keyboard.js ++++ b/js/ui/keyboard.js +@@ -2,7 +2,6 @@ + + const Caribou = imports.gi.Caribou; + const Clutter = imports.gi.Clutter; +-const DBus = imports.dbus; + const Gdk = imports.gi.Gdk; + const Gio = imports.gi.Gio; + const GLib = imports.gi.GLib; +@@ -38,28 +37,27 @@ const PRETTY_KEYS = { + 'Alt_L': 'Alt' + }; + +-const CaribouKeyboardIface = { +- name: 'org.gnome.Caribou.Keyboard', +- methods: [ { name: 'Show', +- inSignature: 'u', +- outSignature: '' +- }, +- { name: 'Hide', +- inSignature: 'u', +- outSignature: '' +- }, +- { name: 'SetCursorLocation', +- inSignature: 'iiii', +- outSignature: '' +- }, +- { name: 'SetEntryLocation', +- inSignature: 'iiii', +- outSignature: '' +- } ], +- properties: [ { name: 'Name', +- signature: 's', +- access: 'read' } ] +-}; ++const CaribouKeyboardIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + function Key() { + this._init.apply(this, arguments); +@@ -199,7 +197,8 @@ function Keyboard() { + + Keyboard.prototype = { + _init: function () { +- DBus.session.exportObject('/org/gnome/Caribou/Keyboard', this); ++ this._impl = Gio.DBusExportedObject.wrapJSObject(CaribouKeyboardIface, this); ++ this._impl.export(Gio.DBus.session, '/org/gnome/Caribou/Keyboard'); + + this.actor = null; + +@@ -541,7 +540,6 @@ Keyboard.prototype = { + return 'cinnamon'; + } + }; +-DBus.conformExport(Keyboard.prototype, CaribouKeyboardIface); + + function KeyboardSource() { + this._init.apply(this, arguments); +diff --git a/js/ui/layout.js b/js/ui/layout.js +index 76303b9..b97459e 100644 +--- a/js/ui/layout.js ++++ b/js/ui/layout.js +@@ -488,12 +488,14 @@ Chrome.prototype = { + + this._screenSaverActive = false; + this._screenSaverProxy = new ScreenSaver.ScreenSaverProxy(); +- this._screenSaverProxy.connect('ActiveChanged', Lang.bind(this, this._onScreenSaverActiveChanged)); +- this._screenSaverProxy.GetActiveRemote(Lang.bind(this, +- function(result, err) { +- if (!err) +- this._onScreenSaverActiveChanged(this._screenSaverProxy, result); +- })); ++ this._screenSaverProxy.connectSignal('ActiveChanged', Lang.bind(this, function(proxy, senderName, [isActive]) { ++ this._onScreenSaverActiveChanged(isActive); ++ })); ++ this._screenSaverProxy.GetActiveRemote(Lang.bind(this, function(result, err) { ++ if (!err) ++ this._onScreenSaverActiveChanged(result[0]); ++ })); ++ + + this._relayout(); + }, +diff --git a/js/ui/magnifierDBus.js b/js/ui/magnifierDBus.js +index 72bba26..4d21797 100644 +--- a/js/ui/magnifierDBus.js ++++ b/js/ui/magnifierDBus.js +@@ -1,6 +1,6 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; ++const Gio = imports.gi.Gio; + const Main = imports.ui.main; + + const MAG_SERVICE_NAME = 'org.gnome.Magnifier'; +@@ -10,47 +10,85 @@ const ZOOM_SERVICE_PATH = '/org/gnome/Magnifier/ZoomRegion'; + + // Subset of gnome-mag's Magnifier dbus interface -- to be expanded. See: + // http://git.gnome.org/browse/gnome-mag/tree/xml/...Magnifier.xml +-const MagnifierIface = { +- name: MAG_SERVICE_NAME, +- methods: [ +- { name: 'setActive', inSignature: 'b', outSignature: '' }, +- { name: 'isActive', inSignature: '', outSignature: 'b' }, +- { name: 'showCursor', inSignature: '', outSignature: '' }, +- { name: 'hideCursor', inSignature: '', outSignature: '' }, +- { name: 'createZoomRegion', inSignature: 'ddaiai', outSignature: 'o' }, +- { name: 'addZoomRegion', inSignature: 'o', outSignature: 'b' }, +- { name: 'getZoomRegions', inSignature: '', outSignature: 'ao' }, +- { name: 'clearAllZoomRegions', inSignature: '', outSignature: '' }, +- { name: 'fullScreenCapable', inSignature: '', outSignature: 'b' }, +- +- { name: 'setCrosswireSize', inSignature: 'i', outSignature: '' }, +- { name: 'getCrosswireSize', inSignature: '', outSignature: 'i' }, +- { name: 'setCrosswireLength', inSignature: 'i', outSignature: '' }, +- { name: 'getCrosswireLength', inSignature: '', outSignature: 'i' }, +- { name: 'setCrosswireClip', inSignature: 'b', outSignature: '' }, +- { name: 'getCrosswireClip', inSignature: '', outSignature: 'b' }, +- { name: 'setCrosswireColor', inSignature: 'u', outSignature: '' }, +- { name: 'getCrosswireColor', inSignature: '', outSignature: 'u' } +- ], +- signals: [], +- properties: [] +-}; ++const MagnifierIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + // Subset of gnome-mag's ZoomRegion dbus interface -- to be expanded. See: + // http://git.gnome.org/browse/gnome-mag/tree/xml/...ZoomRegion.xml +-const ZoomRegionIface = { +- name: ZOOM_SERVICE_NAME, +- methods: [ +- { name: 'setMagFactor', inSignature: 'dd', outSignature: ''}, +- { name: 'getMagFactor', inSignature: '', outSignature: 'dd' }, +- { name: 'setRoi', inSignature: 'ai', outSignature: '' }, +- { name: 'getRoi', inSignature: '', outSignature: 'ai' }, +- { name: 'shiftContentsTo', inSignature: 'ii', outSignature: 'b' }, +- { name: 'moveResize', inSignature: 'ai', outSignature: '' } +- ], +- signals: [], +- properties: [] +-}; ++const ZoomRegionIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + // For making unique ZoomRegion DBus proxy object paths of the form: + // '/org/gnome/Magnifier/ZoomRegion/zoomer0', +@@ -64,7 +102,9 @@ function CinnamonMagnifier() { + CinnamonMagnifier.prototype = { + _init: function() { + this._zoomers = {}; +- DBus.session.exportObject(MAG_SERVICE_PATH, this); ++ ++ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(MagnifierIface, this); ++ this._dbusImpl.export(Gio.DBus.session, MAG_SERVICE_PATH); + }, + + /** +@@ -195,10 +235,10 @@ CinnamonMagnifier.prototype = { + Main.magnifier.clearAllZoomRegions(); + for (let objectPath in this._zoomers) { + let proxyAndZoomer = this._zoomers[objectPath]; ++ proxyAndZoomer.proxy.destroy(); + proxyAndZoomer.proxy = null; + proxyAndZoomer.zoomRegion = null; + delete this._zoomers[objectPath]; +- DBus.session.unexportObject(proxyAndZoomer); + } + this._zoomers = {}; + }, +@@ -300,8 +340,9 @@ function CinnamonMagnifierZoomRegion(zoomerObjectPath, zoomRegion) { + CinnamonMagnifierZoomRegion.prototype = { + _init: function(zoomerObjectPath, zoomRegion) { + this._zoomRegion = zoomRegion; +- DBus.session.proxifyObject(this, ZOOM_SERVICE_NAME, zoomerObjectPath); +- DBus.session.exportObject(zoomerObjectPath, this); ++ ++ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(ZoomRegionIface, this); ++ this._dbusImpl.export(Gio.DBus.session, zoomerObjectPath); + }, + + /** +@@ -376,8 +417,9 @@ CinnamonMagnifierZoomRegion.prototype = { + moveResize: function(viewPort) { + let viewRect = { x: viewPort[0], y: viewPort[1], width: viewPort[2] - viewPort[0], height: viewPort[3] - viewPort[1] }; + this._zoomRegion.setViewPort(viewRect); ++ }, ++ ++ destroy: function() { ++ this._dbusImpl.unexport(); + } + }; +- +-DBus.conformExport(CinnamonMagnifier.prototype, MagnifierIface); +-DBus.conformExport(CinnamonMagnifierZoomRegion.prototype, ZoomRegionIface); +diff --git a/js/ui/main.js b/js/ui/main.js +index 5cae372..180db5c 100644 +--- a/js/ui/main.js ++++ b/js/ui/main.js +@@ -1,7 +1,6 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + + const Clutter = imports.gi.Clutter; +-const DBus = imports.dbus; + const Gio = imports.gi.Gio; + const GLib = imports.gi.GLib; + const Gtk = imports.gi.Gtk; +@@ -199,11 +198,6 @@ function start() { + + cinnamonDBusService = new CinnamonDBus.Cinnamon(); + lookingGlassDBusService = new LookingGlassDBus.CinnamonLookingGlass(); +- // Force a connection now; dbus.js will do this internally +- // if we use its name acquisition stuff but we aren't right +- // now; to do so we'd need to convert from its async calls +- // back into sync ones. +- DBus.session.flush(); + + // Ensure CinnamonWindowTracker and CinnamonAppUsage are initialized; this will + // also initialize CinnamonAppSystem first. CinnamonAppSystem +diff --git a/js/ui/messageTray.js b/js/ui/messageTray.js +index 18d6615..8bed028 100644 +--- a/js/ui/messageTray.js ++++ b/js/ui/messageTray.js +@@ -1388,12 +1388,17 @@ function MessageTray() { + + MessageTray.prototype = { + _init: function() { +- this._presence = new GnomeSession.Presence(); ++ this._presence = new GnomeSession.Presence(Lang.bind(this, function(proxy, error) { ++ this._onStatusChanged(proxy.status); ++ })); ++ + this._userStatus = GnomeSession.PresenceStatus.AVAILABLE; + this._busy = false; + this._backFromAway = false; +- this._presence.connect('StatusChanged', Lang.bind(this, this._onStatusChanged)); +- this._presence.getStatus(Lang.bind(this, this._onStatusChanged)); ++ this._presence.connectSignal('StatusChanged', Lang.bind(this, function(proxy, senderName, [status]) { ++ this._onStatusChanged(status); ++ })); ++ + + this._notificationBin = new St.Bin(); + this._notificationBin.hide(); +@@ -1548,7 +1553,7 @@ MessageTray.prototype = { + this._updateState(); + }, + +- _onStatusChanged: function(presence, status) { ++ _onStatusChanged: function(status) { + this._backFromAway = (this._userStatus == GnomeSession.PresenceStatus.IDLE && this._userStatus != status); + this._userStatus = status; + +diff --git a/js/ui/notificationDaemon.js b/js/ui/notificationDaemon.js +index bee8ffd..b037e07 100644 +--- a/js/ui/notificationDaemon.js ++++ b/js/ui/notificationDaemon.js +@@ -1,7 +1,7 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + + const Clutter = imports.gi.Clutter; +-const DBus = imports.dbus; ++const Gio = imports.gi.Gio; + const GLib = imports.gi.GLib; + const Lang = imports.lang; + const Cinnamon = imports.gi.Cinnamon; +@@ -14,49 +14,52 @@ const Params = imports.misc.params; + + let nextNotificationId = 1; + +-// Should really be defined in dbus.js +-const BusIface = { +- name: 'org.freedesktop.DBus', +- methods: [{ name: 'GetConnectionUnixProcessID', +- inSignature: 's', +- outSignature: 'i' }] +-}; +- +-const Bus = function () { +- this._init(); +-}; +- +-Bus.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, 'org.freedesktop.DBus', '/org/freedesktop/DBus'); +- } +-}; ++// Should really be defined in Gio.js ++const BusIface = ++ ++ ++ ++ ++; ++ ++var BusProxy = Gio.DBusProxy.makeProxyWrapper(BusIface); ++function Bus() { ++ return new BusProxy(Gio.DBus.session, 'org.freedesktop.DBus', '/org/freedesktop/DBus'); ++} + +-DBus.proxifyPrototype(Bus.prototype, BusIface); +- +-const NotificationDaemonIface = { +- name: 'org.freedesktop.Notifications', +- methods: [{ name: 'Notify', +- inSignature: 'susssasa{sv}i', +- outSignature: 'u' +- }, +- { name: 'CloseNotification', +- inSignature: 'u', +- outSignature: '' +- }, +- { name: 'GetCapabilities', +- inSignature: '', +- outSignature: 'as' +- }, +- { name: 'GetServerInformation', +- inSignature: '', +- outSignature: 'ssss' +- }], +- signals: [{ name: 'NotificationClosed', +- inSignature: 'uu' }, +- { name: 'ActionInvoked', +- inSignature: 'us' }] +-}; ++const NotificationDaemonIface = ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++; + + const NotificationClosedReason = { + EXPIRED: 1, +@@ -88,7 +91,8 @@ function NotificationDaemon() { + + NotificationDaemon.prototype = { + _init: function() { +- DBus.session.exportObject('/org/freedesktop/Notifications', this); ++ this._dbusImpl = Gio.DBusExportedObject.wrapJSObject(NotificationDaemonIface, this); ++ this._dbusImpl.export(Gio.DBus.session, '/org/freedesktop/Notifications'); + + this._sources = []; + this._senderToPid = {}; +@@ -213,8 +217,8 @@ NotificationDaemon.prototype = { + return source; + }, + +- Notify: function(appName, replacesId, icon, summary, body, +- actions, hints, timeout) { ++ NotifyAsync: function(params, invocation) { ++ let [appName, replacesId, icon, summary, body, actions, hints, timeout] = params; + let id; + + let rewrites = rewriteRules[appName]; +@@ -257,51 +261,55 @@ NotificationDaemon.prototype = { + } + this._notifications[id] = ndata; + +- let sender = DBus.getCurrentMessageContext().sender; ++ let sender = invocation.get_sender(); + let pid = this._senderToPid[sender]; + + let source = this._getSource(appName, pid, ndata, sender, null); + + if (source) { + this._notifyForSource(source, ndata); +- return id; ++ return invocation.return_value(GLib.Variant.new('(u)', [id])); + } + + if (replacesId) { + // There's already a pending call to GetConnectionUnixProcessID, + // which will see the new notification data when it finishes, + // so we don't have to do anything. +- return id; ++ return invocation.return_value(GLib.Variant.new('(u)', [id])); + } + +- this._busProxy.GetConnectionUnixProcessIDRemote(sender, Lang.bind(this, +- function (pid, ex) { +- // The app may have updated or removed the notification +- ndata = this._notifications[id]; +- if (!ndata) +- return; +- +- source = this._getSource(appName, pid, ndata, sender, null); +- +- // We only store sender-pid entries for persistent sources. +- // Removing the entries once the source is destroyed +- // would result in the entries associated with transient +- // sources removed once the notification is shown anyway. +- // However, keeping these pairs would mean that we would +- // possibly remove an entry associated with a persistent +- // source when a transient source for the same sender is +- // distroyed. +- if (!source.isTransient) { +- this._senderToPid[sender] = pid; +- source.connect('destroy', Lang.bind(this, +- function() { +- delete this._senderToPid[sender]; +- })); +- } +- this._notifyForSource(source, ndata); +- })); ++ this._busProxy.GetConnectionUnixProcessIDRemote(sender, Lang.bind(this, function (result, excp) { ++ // The app may have updated or removed the notification ++ ndata = this._notifications[id]; ++ if (!ndata) ++ return; + +- return id; ++ if (excp) { ++ logError(excp, 'Call to GetConnectionUnixProcessID failed'); ++ return; ++ } ++ ++ let [pid] = result; ++ source = this._getSource(appName, pid, ndata, sender); ++ ++ // We only store sender-pid entries for persistent sources. ++ // Removing the entries once the source is destroyed ++ // would result in the entries associated with transient ++ // sources removed once the notification is shown anyway. ++ // However, keeping these pairs would mean that we would ++ // possibly remove an entry associated with a persistent ++ // source when a transient source for the same sender is ++ // distroyed. ++ if (!source.isTransient) { ++ this._senderToPid[sender] = pid; ++ source.connect('destroy', Lang.bind(this, function() { ++ delete this._senderToPid[sender]; ++ })); ++ } ++ this._notifyForSource(source, ndata); ++ })); ++ ++ return invocation.return_value(GLib.Variant.new('(u)', [id])); + }, + + _notifyForSource: function(source, ndata) { +@@ -441,17 +449,13 @@ NotificationDaemon.prototype = { + }, + + _emitNotificationClosed: function(id, reason) { +- DBus.session.emit_signal('/org/freedesktop/Notifications', +- 'org.freedesktop.Notifications', +- 'NotificationClosed', 'uu', +- [id, reason]); ++ this._dbusImpl.emit_signal('NotificationClosed', ++ GLib.Variant.new('(uu)', [id, reason])); + }, + + _emitActionInvoked: function(id, action) { +- DBus.session.emit_signal('/org/freedesktop/Notifications', +- 'org.freedesktop.Notifications', +- 'ActionInvoked', 'us', +- [id, action]); ++ this._dbusImpl.emit_signal('ActionInvoked', ++ GLib.Variant.new('(us)', [id, action])); + }, + + _onTrayIconAdded: function(o, icon) { +@@ -465,8 +469,6 @@ NotificationDaemon.prototype = { + } + }; + +-DBus.conformExport(NotificationDaemon.prototype, NotificationDaemonIface); +- + function Source(title, pid, sender, trayIcon) { + this._init(title, pid, sender, trayIcon); + } +@@ -481,15 +483,12 @@ Source.prototype = { + + this.pid = pid; + if (sender) +- // TODO: dbus-glib implementation of watch_name() doesn’t return an id to be used for +- // unwatch_name() or implement unwatch_name(), however when we move to using GDBus implementation, +- // we should save the id here and call unwatch_name() with it in destroy(). +- // Moving to GDBus is the work in progress: https://bugzilla.gnome.org/show_bug.cgi?id=648651 +- // and https://bugzilla.gnome.org/show_bug.cgi?id=622921 . +- DBus.session.watch_name(sender, +- false, +- null, +- Lang.bind(this, this._onNameVanished)); ++ this._nameWatcherId = Gio.DBus.session.watch_name(sender, ++ Gio.BusNameWatcherFlags.NONE, ++ null, ++ Lang.bind(this, this._onNameVanished)); ++ else ++ this._nameWatcherId = 0; + + this._setApp(); + if (this.app) +@@ -596,6 +595,10 @@ Source.prototype = { + }, + + destroy: function() { ++ if (this._nameWatcherId) { ++ Gio.DBus.session.unwatch_name(this._nameWatcherId); ++ this._nameWatcherId = 0; ++ } + MessageTray.Source.prototype.destroy.call(this); + } + }; +diff --git a/js/ui/scripting.js b/js/ui/scripting.js +index 42c4f6d..9163d29 100644 +--- a/js/ui/scripting.js ++++ b/js/ui/scripting.js +@@ -1,6 +1,5 @@ + // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*- + +-const DBus = imports.dbus; + const Gio = imports.gi.Gio; + const Mainloop = imports.mainloop; + const Meta = imports.gi.Meta; +@@ -70,24 +69,21 @@ function waitLeisure() { + }; + } + +-const PerfHelperIface = { +- name: 'org.Cinnamon.PerfHelper', +- methods: [{ name: 'CreateWindow', inSignature: 'iibb', outSignature: '' }, +- { name: 'WaitWindows', inSignature: '', outSignature: '' }, +- { name: 'DestroyWindows', inSignature: '', outSignature: ''}] +-}; +- +-const PerfHelper = function () { +- this._init(); +-}; +- +-PerfHelper.prototype = { +- _init: function() { +- DBus.session.proxifyObject(this, 'org.Cinnamon.PerfHelper', '/org/Cinnamon/PerfHelper'); +- } +-}; +- +-DBus.proxifyPrototype(PerfHelper.prototype, PerfHelperIface); ++const PerfHelperIface = ++ ++ ++ ++ ++ ++ ++ ++ ++; ++ ++var PerfHelperProxy = Gio.DBusProxy.makeProxyWrapper(PerfHelperIface); ++function PerfHelper() { ++ return new PerfHelperProxy(Gio.DBus.session, 'org.gnome.Shell.PerfHelper', '/org/gnome/Shell/PerfHelper'); ++} + + let _perfHelper = null; + function _getPerfHelper() { +-- +1.8.1.6 + + +From d85e078c0ed09a8b9f8d3ea2ebec1043b6d150c1 Mon Sep 17 00:00:00 2001 +From: dalcde +Date: Tue, 16 Apr 2013 16:58:30 +0800 +Subject: [PATCH 07/15] [GDBus][Sound/Power Applet] Fix dbus port issues + +--- + .../cinnamon/applets/power@cinnamon.org/applet.js | 2 +- + .../cinnamon/applets/sound@cinnamon.org/applet.js | 83 ++++++++++------------ + 2 files changed, 37 insertions(+), 48 deletions(-) + +diff --git a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +index b6b2bcd..fad39ab 100644 +--- a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +@@ -212,7 +212,7 @@ MyApplet.prototype = { + this.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem()); + this.menu.addSettingsAction(_("Power Settings"), 'power'); + +- this._smProxy.connect('PropertiesChanged', Lang.bind(this, this._devicesChanged)); ++ this._smProxy.connectSignal('PropertiesChanged', Lang.bind(this, this._devicesChanged)); + this._devicesChanged(); + } + catch (e) { +diff --git a/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js +index 5bfaf26..52b8cde 100644 +--- a/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/sound@cinnamon.org/applet.js +@@ -37,7 +37,7 @@ const MediaServer2PlayerIFace = + + + +- ++ + + + +@@ -256,23 +256,20 @@ Player.prototype = { + this._trackControls.set_child(this.controls); + this.addActor(this._trackControls); + +- this._mediaServer.getRaise(Lang.bind(this, function(sender, raise) { +- if (raise) { +- this._raiseButton = new ControlButton('go-up', +- Lang.bind(this, function () { this._mediaServer.RaiseRemote(); this._system_status_button.menu.actor.hide(); })); +- this._raiseButtonTooltip = new Tooltips.Tooltip(this._raiseButton.button, _("Open Player")); +- this.controls.add_actor(this._raiseButton.getActor()); +- } +- })); +- +- this._mediaServer.getQuit(Lang.bind(this, function(sender, quit) { +- if (quit) { +- this._quitButton = new ControlButton('window-close', +- Lang.bind(this, function () { this._mediaServer.QuitRemote(); })); +- this.controls.add_actor(this._quitButton.getActor()); +- this._quitButtonTooltip = new Tooltips.Tooltip(this._quitButton.button, _("Quit Player")); +- } +- })); ++ let CanRaise = this._mediaServer.CanRaise; ++ let CanQuit = this._mediaServer.CanQuit; ++ if (CanRaise) { ++ this._raiseButton = new ControlButton('go-up', ++ Lang.bind(this, function () { this._mediaServer.RaiseRemote(); this._system_status_button.menu.actor.hide(); })); ++ this._raiseButtonTooltip = new Tooltips.Tooltip(this._raiseButton.button, _("Open Player")); ++ this.controls.add_actor(this._raiseButton.getActor()); ++ } ++ if (CanQuit) { ++ this._quitButton = new ControlButton('window-close', ++ Lang.bind(this, function () { this._mediaServer.QuitRemote(); })); ++ this.controls.add_actor(this._quitButton.getActor()); ++ this._quitButtonTooltip = new Tooltips.Tooltip(this._quitButton.button, _("Quit Player")); ++ } + + /* this players don't support seek */ + if (support_seek.indexOf(this._name) == -1) +@@ -283,14 +280,14 @@ Player.prototype = { + this._currentTime = 0; + this._getPosition(); + +- this._prop.connect('PropertiesChanged', Lang.bind(this, function(sender, iface, value) { ++ this._prop.connectSignal('PropertiesChanged', Lang.bind(this, function(sender, iface, value) { + if (value["PlaybackStatus"]) +- this._setStatus(iface, value["PlaybackStatus"]); ++ this._setStatus(value["PlaybackStatus"]); + if (value["Metadata"]) +- this._setMetadata(iface, value["Metadata"]); ++ this._setMetadata(value["Metadata"]); + })); + +- this._mediaServerPlayer.connect('Seeked', Lang.bind(this, function(sender, value) { ++ this._mediaServerPlayer.connectSignal('Seeked', Lang.bind(this, function(sender, iface, [value]) { + this._setPosition(sender, value); + })); + +@@ -315,19 +312,17 @@ Player.prototype = { + }, + + _getPosition: function() { +- this._mediaServerPlayer.getPosition(Lang.bind(this, +- this._setPosition +- )); ++ this._setPosition(this._mediaServerPlayer.Position); + Mainloop.timeout_add(1000, Lang.bind(this, this._getPosition)); + }, + +- _setMetadata: function(sender, metadata) { ++ _setMetadata: function(metadata) { + if (metadata["mpris:length"]) { + // song length in secs +- this._songLength = metadata["mpris:length"] / 1000000; ++ this._songLength = metadata["mpris:length"].unpack() / 1000000; + // FIXME upstream + if (this._name == "quodlibet") +- this._songLength = metadata["mpris:length"] / 1000; ++ this._songLength = metadata["mpris:length"].unpack() / 1000; + // reset timer + this._stopTimer(); + if (this._playerStatus == "Playing") +@@ -338,15 +333,15 @@ Player.prototype = { + this._stopTimer(); + } + if (metadata["xesam:artist"]) +- this._artist.setLabel(metadata["xesam:artist"].toString()); ++ this._artist.setLabel(metadata["xesam:artist"].unpack()); + else + this._artist.setLabel(_("Unknown Artist")); + if (metadata["xesam:album"]) +- this._album.setLabel(metadata["xesam:album"].toString()); ++ this._album.setLabel(metadata["xesam:album"].unpack()); + else + this._album.setLabel(_("Unknown Album")); + if (metadata["xesam:title"]) +- this._title.setLabel(metadata["xesam:title"].toString()); ++ this._title.setLabel(metadata["xesam:title"].unpack()); + else + this._title.setLabel(_("Unknown Title")); + /*if (metadata["mpris:trackid"]) { +@@ -359,8 +354,8 @@ Player.prototype = { + + let change = false; + if (metadata["mpris:artUrl"]) { +- if (this._trackCoverFile != metadata["mpris:artUrl"].toString()) { +- this._trackCoverFile = metadata["mpris:artUrl"].toString(); ++ if (this._trackCoverFile != metadata["mpris:artUrl"].unpack()) { ++ this._trackCoverFile = metadata["mpris:artUrl"].unpack(); + change = true; + } + } +@@ -392,12 +387,10 @@ Player.prototype = { + }, + + _getMetadata: function() { +- this._mediaServerPlayer.getMetadata(Lang.bind(this, +- this._setMetadata +- )); ++ this._setMetadata(this._mediaServerPlayer.Metadata); + }, + +- _setStatus: function(sender, status) { ++ _setStatus: function(status) { + this._playerStatus = status; + if (status == "Playing") { + this._playButton.setIcon("media-playback-pause"); +@@ -416,15 +409,11 @@ Player.prototype = { + }, + + _getStatus: function() { +- this._mediaServerPlayer.getPlaybackStatus(Lang.bind(this, +- this._setStatus +- )); ++ this._setStatus(this._mediaServerPlayer.PlaybackStatus); + }, + + _updateRate: function() { +- this._mediaServerPlayer.getRate(Lang.bind(this, function(sender, rate) { +- this._rate = rate; +- })); ++ this._rate = this._mediaServerPlayer.Rate; + }, + + _updateTimer: function() { +@@ -569,7 +558,7 @@ MyApplet.prototype = { + this._players = {}; + // watch players + for (var p=0; p +Date: Fri, 19 Apr 2013 19:09:18 -0400 +Subject: [PATCH 08/15] Fix gicon error - power applet + +--- + files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +index fad39ab..3a13eab 100644 +--- a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +@@ -323,7 +323,7 @@ MyApplet.prototype = { + let icon = this._proxy.Icon; + if (icon) { + let gicon = Gio.icon_new_for_string(icon); +- this.setGIcon(gicon); ++ this._applet_icon.gicon = gicon + this.actor.show(); + } else { + this.menu.close(); +-- +1.8.1.6 + + +From 3d78b5c929e7e3b0ee24d4b537492740e7bebf2f Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Fri, 19 Apr 2013 19:44:33 -0400 +Subject: [PATCH 09/15] Remove unused + +--- + src/cinnamon-background-manager.c | 34 ---------------------------------- + 1 file changed, 34 deletions(-) + +diff --git a/src/cinnamon-background-manager.c b/src/cinnamon-background-manager.c +index 9d95250..67427ed 100644 +--- a/src/cinnamon-background-manager.c ++++ b/src/cinnamon-background-manager.c +@@ -66,8 +66,6 @@ struct CinnamonBackgroundManagerPrivate + + G_DEFINE_TYPE (CinnamonBackgroundManager, cinnamon_background_manager, G_TYPE_OBJECT) + +-static gpointer manager_object = NULL; +- + static gboolean + dont_draw_background (CinnamonBackgroundManager *manager) + { +@@ -223,36 +221,6 @@ struct CinnamonBackgroundManagerPrivate + } + + static void +-draw_background_after_session_loads (CinnamonBackgroundManager *manager) +-{ +- GError *error = NULL; +- GDBusProxyFlags flags; +- +- flags = G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | +- G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START; +- manager->priv->proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION, +- flags, +- NULL, /* GDBusInterfaceInfo */ +- "org.gnome.SessionManager", +- "/org/gnome/SessionManager", +- "org.gnome.SessionManager", +- NULL, /* GCancellable */ +- &error); +- if (manager->priv->proxy == NULL) { +- g_warning ("Could not listen to session manager: %s", +- error->message); +- g_error_free (error); +- return; +- } +- +- manager->priv->proxy_signal_id = g_signal_connect (manager->priv->proxy, +- "g-signal", +- G_CALLBACK (on_session_manager_signal), +- manager); +-} +- +- +-static void + disconnect_screen_signals (CinnamonBackgroundManager *manager) + { + GdkDisplay *display; +@@ -312,8 +280,6 @@ struct CinnamonBackgroundManagerPrivate + G_CALLBACK (draw_background_changed), manager); + + setup_bg_and_draw_background (manager); +- //draw_background_after_session_loads (manager); +- + + return TRUE; + } +-- +1.8.1.6 + + +From d08b882470b135591fb99bd9ff7c63619fcaea82 Mon Sep 17 00:00:00 2001 +From: dalcde +Date: Sat, 20 Apr 2013 15:42:13 +0800 +Subject: [PATCH 10/15] [GDBus][Power applet] Some fixes and cleanup + +--- + .../cinnamon/applets/power@cinnamon.org/applet.js | 52 ++++++---------------- + 1 file changed, 14 insertions(+), 38 deletions(-) + +diff --git a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +index 3a13eab..5f81d91 100644 +--- a/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js ++++ b/files/usr/share/cinnamon/applets/power@cinnamon.org/applet.js +@@ -48,40 +48,11 @@ const PowerManagerInterface = + + + +- +- +- +- +- + + ; + + const PowerManagerProxy = Gio.DBusProxy.makeProxyWrapper(PowerManagerInterface); + +-const SettingsManagerInterface = +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +- +-; +- +-const SettingsManagerProxy = Gio.DBusProxy.makeProxyWrapper(SettingsManagerInterface); +- + function DeviceItem() { + this._init.apply(this, arguments); + } +@@ -156,8 +127,16 @@ MyApplet.prototype = { + this.menuManager.addMenu(this.menu); + + //this.set_applet_icon_symbolic_name('battery-missing'); +- this._proxy = new PowerManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH); +- this._smProxy = new SettingsManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH); ++ this._proxy = new PowerManagerProxy(Gio.DBus.session, BUS_NAME, OBJECT_PATH, ++ Lang.bind(this, function(proxy, error) { ++ if (error) { ++ global.log(error.message); ++ ++ return; ++ } ++ this._proxy.connect('g-properties-changed', Lang.bind(this, this._devicesChanged)); ++ this._devicesChanged(); ++ })); + + let icon = this.actor.get_children()[0]; + this.actor.remove_actor(icon); +@@ -211,9 +190,6 @@ MyApplet.prototype = { + + this.menu.addMenuItem(new PopupMenu.PopupSeparatorMenuItem()); + this.menu.addSettingsAction(_("Power Settings"), 'power'); +- +- this._smProxy.connectSignal('PropertiesChanged', Lang.bind(this, this._devicesChanged)); +- this._devicesChanged(); + } + catch (e) { + global.logError(e); +@@ -245,14 +221,14 @@ MyApplet.prototype = { + }, + + _readPrimaryDevice: function() { +- this._proxy.GetPrimaryDeviceRemote(Lang.bind(this, function(device, error) { ++ this._proxy.GetPrimaryDeviceRemote(Lang.bind(this, function(result, error) { + if (error) { + this._hasPrimary = false; + this._primaryDeviceId = null; + this._batteryItem.actor.hide(); + return; + } +- let [device_id, device_type, icon, percentage, state, seconds] = device; ++ let [[device_id, device_type, icon, percentage, state, seconds]] = result; + if (device_type == UPDeviceType.BATTERY) { + this._hasPrimary = true; + let time = Math.round(seconds / 60); +@@ -290,7 +266,7 @@ MyApplet.prototype = { + }, + + _readOtherDevices: function() { +- this._proxy.GetDevicesRemote(Lang.bind(this, function(devices, error) { ++ this._proxy.GetDevicesRemote(Lang.bind(this, function([devices], error) { + this._deviceItems.forEach(function(i) { i.destroy(); }); + this._deviceItems = []; + +@@ -336,7 +312,7 @@ MyApplet.prototype = { + }, + + _updateLabel: function() { +- this._proxy.GetDevicesRemote(Lang.bind(this, function(devices, error) { ++ this._proxy.GetDevicesRemote(Lang.bind(this, function([devices], error) { + if (error) { + this._mainLabel.set_text(""); + return; +-- +1.8.1.6 + + +From c93e9746b321ad6d0aa38ec28c15fe7b3f18f8f7 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Sat, 20 Apr 2013 10:59:54 -0400 +Subject: [PATCH 11/15] Move CLUTTER_DISABLE_XINPUT to session startup file + +--- + files/usr/bin/gnome-session-cinnamon | 2 +- + src/main.c | 3 --- + 2 files changed, 1 insertion(+), 4 deletions(-) + +diff --git a/files/usr/bin/gnome-session-cinnamon b/files/usr/bin/gnome-session-cinnamon +index 315f135..56c37f5 100755 +--- a/files/usr/bin/gnome-session-cinnamon ++++ b/files/usr/bin/gnome-session-cinnamon +@@ -1,3 +1,3 @@ + #! /bin/sh +-exec gnome-session --session cinnamon "$@" ++exec CLUTTER_DISABLE_XINPUT=1 gnome-session --session cinnamon "$@" + +diff --git a/src/main.c b/src/main.c +index 9d37975..418fb60 100644 +--- a/src/main.c ++++ b/src/main.c +@@ -257,9 +257,6 @@ + + g_option_context_free (ctx); + +- /* Disable XInput extension - required for 3.8 compatibility */ +- g_setenv ("CLUTTER_DISABLE_XINPUT", "1", TRUE); +- + meta_plugin_type_register (gnome_cinnamon_plugin_get_type ()); + + /* Prevent meta_init() from causing gtk to load gail and at-bridge */ +-- +1.8.1.6 + + +From de1719e63518884cad6c9d63d508f737eab35d49 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Sat, 20 Apr 2013 12:23:29 -0400 +Subject: [PATCH 12/15] Add Xinput disable to cinnamon2d + +--- + files/usr/bin/cinnamon2d | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/files/usr/bin/cinnamon2d b/files/usr/bin/cinnamon2d +index 1eced99..7f42517 100755 +--- a/files/usr/bin/cinnamon2d ++++ b/files/usr/bin/cinnamon2d +@@ -1,2 +1,2 @@ + #!/bin/bash +-CLUTTER_PAINT=disable-clipped-redraws:disable-culling LIBGL_ALWAYS_SOFTWARE=1 CINNAMON_SOFTWARE_RENDERING=1 CINNAMON_SLOWDOWN_FACTOR=0.0001 MUFFIN_NO_SHADOWS=1 CLUTTER_DEFAULT_FPS=15 cinnamon $@ ++CLUTTER_DISABLE_XINPUT=1 CLUTTER_PAINT=disable-clipped-redraws:disable-culling LIBGL_ALWAYS_SOFTWARE=1 CINNAMON_SOFTWARE_RENDERING=1 CINNAMON_SLOWDOWN_FACTOR=0.0001 MUFFIN_NO_SHADOWS=1 CLUTTER_DEFAULT_FPS=15 cinnamon $@ +-- +1.8.1.6 + + +From 15d57d1c15f34d44b23f74b21929d996d4465afb Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Sat, 20 Apr 2013 12:29:43 -0400 +Subject: [PATCH 13/15] Fix session file + +--- + files/usr/bin/gnome-session-cinnamon | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/files/usr/bin/gnome-session-cinnamon b/files/usr/bin/gnome-session-cinnamon +index 56c37f5..31c9eff 100755 +--- a/files/usr/bin/gnome-session-cinnamon ++++ b/files/usr/bin/gnome-session-cinnamon +@@ -1,3 +1,3 @@ + #! /bin/sh +-exec CLUTTER_DISABLE_XINPUT=1 gnome-session --session cinnamon "$@" ++CLUTTER_DISABLE_XINPUT=1 exec gnome-session --session cinnamon "$@" + +-- +1.8.1.6 + + +From 03436393c322fd97d8216c3481d28cd34833c656 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Sat, 20 Apr 2013 12:36:45 -0400 +Subject: [PATCH 14/15] Add cinnamon3d command + +--- + files/usr/bin/cinnamon3d | 2 ++ + 1 file changed, 2 insertions(+) + create mode 100644 files/usr/bin/cinnamon3d + +diff --git a/files/usr/bin/cinnamon3d b/files/usr/bin/cinnamon3d +new file mode 100644 +index 0000000..4891783 +--- /dev/null ++++ b/files/usr/bin/cinnamon3d +@@ -0,0 +1,2 @@ ++#!/bin/bash ++CLUTTER_DISABLE_XINPUT=1 cinnamon $@ +-- +1.8.1.6 + + +From 850da270967622b95be9e0c5edd8e230eb4be5a1 Mon Sep 17 00:00:00 2001 +From: Michael Webster +Date: Sat, 20 Apr 2013 12:37:26 -0400 +Subject: [PATCH 15/15] Fix perms + +--- + files/usr/bin/cinnamon3d | 0 + 1 file changed, 0 insertions(+), 0 deletions(-) + mode change 100644 => 100755 files/usr/bin/cinnamon3d + +diff --git a/files/usr/bin/cinnamon3d b/files/usr/bin/cinnamon3d +old mode 100644 +new mode 100755 +-- +1.8.1.6 + -- cgit v1.2.3-54-g00ecf