Merge lp:~3v1n0/unity/trash-volumes-illumination into lp:unity

[Marco Trevisan (Treviño)]

{Trash,Volume}Icon: enable running state if the location is opened in the filemanager

GnomeFileManager is now monitoring the nautilus' OpenLocations property and emitting changes when this value is updated.

TrashLauncherIcon and VolumeLauncherIcon checks if their location is opened in the filemanager to toggle the icon illumination.

The pips support is disabled for now since this needs some other nautilus changes (done and pending merge) and a major refactoring for windows handling.

[Brandon Schaefer (brandontschaefer)]

Looks good, but what happens when you set the backlight to always on? Possibly make the indicator arrow 1 when its open? Also its no illuminated for me (like what happens when things are urgent), but im not sure if thats what you intended (I don't see it in the code).

review: Needs Information

[Marco Trevisan (Treviño) (3v1n0)]

> Looks good, but what happens when you set the backlight to always on? Possibly
> make the indicator arrow 1 when its open?

I thought about that, but it could be confusing since it wouldn't be aware of the window position (monitor or workspace side), so I'd prefer to keep it in this way for now (in the worst case, there's no regression).

However the pips support is something I've alredy been working on and I've opened the bug #1161323 to track it.

> Also its no illuminated for me (like what happens when things are urgent),
> but im not sure if thats what you intended (I don't see it in the code).

This is what I meant by illumination: http://ubuntuone.com/4WdBG8RSg0bbU4f1rHoZee
Per se the trash/device icons would have a white background and I don't think this is what we want to see when they're opened.

[Brandon Schaefer (brandontschaefer)]

LGTM.

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'launcher/DeviceLauncherSection.cpp'
--- launcher/DeviceLauncherSection.cpp	2013-03-21 16:22:34 +0000
+++ launcher/DeviceLauncherSection.cpp	2013-03-28 12:05:12 +0000
@@ -32,7 +32,7 @@
                                              DevicesSettings::Ptr devices_settings)
   : monitor_(volume_monitor)
   , devices_settings_(devices_settings)
-  , file_manager_(std::make_shared<GnomeFileManager>())
+  , file_manager_(GnomeFileManager::Get())
   , device_notification_display_(std::make_shared<DeviceNotificationDisplayImp>())
 {
   monitor_->volume_added.connect(sigc::mem_fun(this, &DeviceLauncherSection::OnVolumeAdded));

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2013-03-19 18:47:01 +0000
+++ launcher/Launcher.cpp	2013-03-28 12:05:12 +0000
@@ -851,6 +851,13 @@
       arg.window_indicators = std::max<int> (icon->WindowsOnViewport().size(), 1);
     else
       arg.window_indicators = std::max<int> (icon->WindowsForMonitor(monitor).size(), 1);
+
+    if (icon->GetIconType() == AbstractLauncherIcon::IconType::TRASH ||
+        icon->GetIconType() == AbstractLauncherIcon::IconType::DEVICE)
+    {
+      // TODO: also these icons should respect the actual windows they have
+      arg.window_indicators = 0;
+    }
   }
 
   arg.backlight_intensity = IconBackgroundIntensity(icon, current);

=== modified file 'launcher/TrashLauncherIcon.cpp'
--- launcher/TrashLauncherIcon.cpp	2013-03-21 20:39:55 +0000
+++ launcher/TrashLauncherIcon.cpp	2013-03-28 12:05:12 +0000
@@ -23,12 +23,10 @@
 
 #include "config.h"
 #include <glib/gi18n-lib.h>
-#include <Nux/WindowCompositor.h>
 #include <NuxCore/Logger.h>
 #include <zeitgeist.h>
+#include <UnityCore/DesktopUtilities.h>
 
-#include "Launcher.h"
-#include "QuicklistManager.h"
 #include "QuicklistMenuItemLabel.h"
 #include "unity-shared/GnomeFileManager.h"
 
@@ -41,17 +39,18 @@
 {
   const std::string ZEITGEIST_UNITY_ACTOR = "application://compiz.desktop";
   const std::string TRASH_URI = "trash:";
+  const std::string TRASH_PATH = "file://" + DesktopUtilities::GetUserDataDirectory() + "/Trash/files";
 }
 
 TrashLauncherIcon::TrashLauncherIcon(FileManager::Ptr const& fmo)
   : SimpleLauncherIcon(IconType::TRASH)
-  , file_manager_(fmo ? fmo : std::make_shared<GnomeFileManager>())
+  , file_manager_(fmo ? fmo : GnomeFileManager::Get())
 {
   tooltip_text = _("Trash");
   icon_name = "user-trash";
   position = Position::END;
   SetQuirk(Quirk::VISIBLE, true);
-  SetQuirk(Quirk::RUNNING, false);
+  SetQuirk(Quirk::RUNNING, IsOpened());
   SetShortcut('t');
 
   glib::Object<GFile> location(g_file_new_for_uri(TRASH_URI.c_str()));
@@ -72,6 +71,10 @@
     });
   }
 
+  file_manager_->locations_changed.connect([this] {
+    SetQuirk(Quirk::RUNNING, IsOpened());
+  });
+
   UpdateTrashIcon();
 }
 
@@ -94,11 +97,23 @@
   return result;
 }
 
+bool TrashLauncherIcon::IsOpened() const
+{
+  return (file_manager_->IsPrefixOpened(TRASH_URI) || file_manager_->IsPrefixOpened(TRASH_PATH));
+}
+
 void TrashLauncherIcon::ActivateLauncherIcon(ActionArg arg)
 {
   SimpleLauncherIcon::ActivateLauncherIcon(arg);
 
-  file_manager_->Open(TRASH_URI.c_str(), arg.timestamp);
+  if (file_manager_->IsPrefixOpened(TRASH_PATH))
+  {
+    file_manager_->OpenActiveChild(TRASH_PATH.c_str(), arg.timestamp);
+  }
+  else
+  {
+    file_manager_->OpenActiveChild(TRASH_URI.c_str(), arg.timestamp);
+  }
 }
 
 void TrashLauncherIcon::UpdateTrashIcon()

=== modified file 'launcher/TrashLauncherIcon.h'
--- launcher/TrashLauncherIcon.h	2013-03-21 19:58:52 +0000
+++ launcher/TrashLauncherIcon.h	2013-03-28 12:05:12 +0000
@@ -49,6 +49,7 @@
 
 private:
   void ActivateLauncherIcon(ActionArg arg);
+  bool IsOpened() const;
   MenuItemsVector GetMenus();
 
   static void UpdateTrashIconCb(GObject* source, GAsyncResult* res, gpointer data);

=== modified file 'launcher/Volume.h'
--- launcher/Volume.h	2013-03-13 20:54:45 +0000
+++ launcher/Volume.h	2013-03-28 12:05:12 +0000
@@ -46,6 +46,7 @@
   virtual std::string GetIdentifier() const = 0;
   virtual bool HasSiblings() const = 0;
   virtual bool IsMounted() const = 0;
+  virtual bool IsOpened() const = 0;
 
   virtual void EjectAndShowNotification() = 0;
   virtual void MountAndOpenInFileManager(unsigned long long timestamp = 0) = 0;
@@ -54,6 +55,7 @@
 
   sigc::signal<void> changed;
   sigc::signal<void> removed;
+  sigc::signal<void, bool> opened;
 
 private:
   Volume(Volume const&) = delete;

=== modified file 'launcher/VolumeImp.cpp'
--- launcher/VolumeImp.cpp	2013-03-21 19:58:52 +0000
+++ launcher/VolumeImp.cpp	2013-03-28 12:05:12 +0000
@@ -40,6 +40,7 @@
        DeviceNotificationDisplay::Ptr const& device_notification_display,
        VolumeImp* parent)
     : parent_(parent)
+    , opened_(false)
     , open_timestamp_(0)
     , volume_(volume)
     , file_manager_(file_manager)
@@ -50,7 +51,17 @@
     });
 
     signal_volume_removed_.Connect(volume_, "removed", [this] (GVolume*) {
-          parent_->removed.emit();
+      parent_->removed.emit();
+    });
+
+    file_manager_->locations_changed.connect([this] {
+      bool opened = file_manager_->IsPrefixOpened(GetUri());
+
+      if (opened_ != opened)
+      {
+        opened_ = opened;
+        parent_->opened.emit(opened_);
+      }
     });
   }
 
@@ -112,6 +123,11 @@
     return static_cast<bool>(mount);
   }
 
+  bool IsOpened() const
+  {
+    return opened_;
+  }
+
   void EjectAndShowNotification()
   {
     if (!CanBeEjected())
@@ -167,18 +183,22 @@
 
   void OpenInFileManager()
   {
-    file_manager_->Open(GetUri(), open_timestamp_);
+    file_manager_->OpenActiveChild(GetUri(), open_timestamp_);
   }
 
-  std::string GetUri()
+  std::string GetUri() const
   {
     glib::Object<GMount> mount(g_volume_get_mount(volume_));
+
+    if (!mount.IsType(G_TYPE_MOUNT))
+      return std::string();
+
     glib::Object<GFile> root(g_mount_get_root(mount));
 
-    if (root.IsType(G_TYPE_FILE))
-      return glib::String(g_file_get_uri(root)).Str();
-    else
-     return std::string();
+    if (!root.IsType(G_TYPE_FILE))
+      return std::string();
+
+    return glib::String(g_file_get_uri(root)).Str();
   }
 
   void StopDrive()
@@ -213,6 +233,7 @@
   }
 
   VolumeImp* parent_;
+  bool opened_;
   unsigned long long open_timestamp_;
   glib::Cancellable cancellable_;
   glib::Object<GVolume> volume_;
@@ -276,6 +297,11 @@
   return pimpl->IsMounted();
 }
 
+bool VolumeImp::IsOpened() const
+{
+  return pimpl->IsOpened();
+}
+
 void VolumeImp::MountAndOpenInFileManager(unsigned long long timestamp)
 {
   pimpl->MountAndOpenInFileManager(timestamp);

=== modified file 'launcher/VolumeImp.h'
--- launcher/VolumeImp.h	2013-03-21 16:22:34 +0000
+++ launcher/VolumeImp.h	2013-03-28 12:05:12 +0000
@@ -51,6 +51,7 @@
   virtual std::string GetIdentifier() const;
   virtual bool HasSiblings() const;
   virtual bool IsMounted() const;
+  virtual bool IsOpened() const;
 
   virtual void EjectAndShowNotification();
   virtual void MountAndOpenInFileManager(unsigned long long timestamp);

=== modified file 'launcher/VolumeLauncherIcon.cpp'
--- launcher/VolumeLauncherIcon.cpp	2013-03-13 20:54:45 +0000
+++ launcher/VolumeLauncherIcon.cpp	2013-03-28 12:05:12 +0000
@@ -71,8 +71,7 @@
   {
     parent_->tooltip_text = volume_->GetName();
     parent_->icon_name = volume_->GetIconName();
-
-    parent_->SetQuirk(Quirk::RUNNING, false);
+    parent_->SetQuirk(Quirk::RUNNING, volume_->IsOpened());
   }
 
   void UpdateVisibility()
@@ -92,6 +91,7 @@
     volume_changed_conn_ = volume_->changed.connect(sigc::mem_fun(this, &Impl::OnVolumeChanged));
     volume_removed_conn_ = volume_->removed.connect(sigc::mem_fun(this, &Impl::OnVolumeRemoved));
     settings_changed_conn_ = devices_settings_->changed.connect(sigc::mem_fun(this, &Impl::OnSettingsChanged));
+    volume_->opened.connect(sigc::hide(sigc::mem_fun(this, &Impl::UpdateIcon)));
   }
 
   void OnVolumeChanged()

=== modified file 'tests/test_mock_devices.h'
--- tests/test_mock_devices.h	2013-03-13 20:54:45 +0000
+++ tests/test_mock_devices.h	2013-03-28 12:05:12 +0000
@@ -83,6 +83,7 @@
   MOCK_CONST_METHOD0(HasSiblings, bool(void));
   MOCK_CONST_METHOD0(CanBeEjected, bool(void));
   MOCK_CONST_METHOD0(IsMounted, bool(void));
+  MOCK_CONST_METHOD0(IsOpened, bool(void));
 
   MOCK_METHOD0(EjectAndShowNotification, void(void));
   MOCK_METHOD1(MountAndOpenInFileManager, void(unsigned long long));

=== modified file 'tests/test_mock_filemanager.h'
--- tests/test_mock_filemanager.h	2013-03-21 20:36:16 +0000
+++ tests/test_mock_filemanager.h	2013-03-28 12:05:12 +0000
@@ -30,9 +30,12 @@
   typedef std::shared_ptr<MockFileManager> Ptr;
 
   MOCK_METHOD2(Open, void(std::string const& uri, unsigned long long time));
+  MOCK_METHOD2(OpenActiveChild, void(std::string const& uri, unsigned long long time));
   MOCK_METHOD1(EmptyTrash, void(unsigned long long time));
+  MOCK_CONST_METHOD0(OpenedLocations, std::vector<std::string>());
+  MOCK_CONST_METHOD1(IsPrefixOpened, bool(std::string const& uri));
 };
 
 }
 
-#endif
\ No newline at end of file
+#endif

=== modified file 'tests/test_trash_launcher_icon.cpp'
--- tests/test_trash_launcher_icon.cpp	2013-03-25 15:55:05 +0000
+++ tests/test_trash_launcher_icon.cpp	2013-03-28 12:05:12 +0000
@@ -18,20 +18,24 @@
  */
 
 #include <gmock/gmock.h>
+#include <UnityCore/DesktopUtilities.h>
 
 #include "TrashLauncherIcon.h"
 #include "test_mock_filemanager.h"
 
 using namespace unity;
 using namespace unity::launcher;
+using namespace testing;
 
 namespace
 {
 
-struct TestTrashLauncherIcon : testing::Test
+const std::string FALLBACK_TRASH_URI = "file://" + DesktopUtilities::GetUserDataDirectory() + "/Trash/files";
+
+struct TestTrashLauncherIcon : Test
 {
   TestTrashLauncherIcon()
-    : fm_(std::make_shared<MockFileManager>())
+    : fm_(std::make_shared<NiceMock<MockFileManager>>())
     , icon(fm_)
   {}
 
@@ -47,7 +51,15 @@
 TEST_F(TestTrashLauncherIcon, Activate)
 {
   unsigned long long time = g_random_int();
-  EXPECT_CALL(*fm_, Open("trash:", time));
+  EXPECT_CALL(*fm_, OpenActiveChild("trash:", time));
+  icon.Activate(ActionArg(ActionArg::Source::LAUNCHER, 0, time));
+}
+
+TEST_F(TestTrashLauncherIcon, ActivateFallback)
+{
+  ON_CALL(*fm_, IsPrefixOpened(FALLBACK_TRASH_URI)).WillByDefault(Return(true));
+  unsigned long long time = g_random_int();
+  EXPECT_CALL(*fm_, OpenActiveChild(FALLBACK_TRASH_URI, time));
   icon.Activate(ActionArg(ActionArg::Source::LAUNCHER, 0, time));
 }
 
@@ -69,4 +81,30 @@
   dbusmenu_menuitem_handle_event(empty_trash_menu, DBUSMENU_MENUITEM_EVENT_ACTIVATED, nullptr, time);
 }
 
+TEST_F(TestTrashLauncherIcon, RunningState)
+{
+  EXPECT_CALL(*fm_, IsPrefixOpened("trash:")).WillRepeatedly(Return(true));
+  EXPECT_CALL(*fm_, IsPrefixOpened(FALLBACK_TRASH_URI)).WillRepeatedly(Return(false));
+  fm_->locations_changed.emit();
+  EXPECT_TRUE(icon.GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+
+  EXPECT_CALL(*fm_, IsPrefixOpened("trash:")).WillRepeatedly(Return(false));
+  EXPECT_CALL(*fm_, IsPrefixOpened(FALLBACK_TRASH_URI)).WillRepeatedly(Return(false));
+  fm_->locations_changed.emit();
+  EXPECT_FALSE(icon.GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
+TEST_F(TestTrashLauncherIcon, RunningStateFallBack)
+{
+  EXPECT_CALL(*fm_, IsPrefixOpened("trash:")).WillRepeatedly(Return(false));
+  EXPECT_CALL(*fm_, IsPrefixOpened(FALLBACK_TRASH_URI)).WillRepeatedly(Return(true));
+  fm_->locations_changed.emit();
+  EXPECT_TRUE(icon.GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+
+  EXPECT_CALL(*fm_, IsPrefixOpened("trash:")).WillRepeatedly(Return(false));
+  EXPECT_CALL(*fm_, IsPrefixOpened(FALLBACK_TRASH_URI)).WillRepeatedly(Return(false));
+  fm_->locations_changed.emit();
+  EXPECT_FALSE(icon.GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+}
+
 }

=== modified file 'tests/test_volume_imp.cpp'
--- tests/test_volume_imp.cpp	2013-03-21 20:36:16 +0000
+++ tests/test_volume_imp.cpp	2013-03-28 12:05:12 +0000
@@ -46,7 +46,7 @@
   void SetUp()
   {
     gvolume_ = g_mock_volume_new();
-    file_manager_.reset(new MockFileManager);
+    file_manager_.reset(new NiceMock<MockFileManager>);
     device_notification_display_.reset(new MockDeviceNotificationDisplay);
     volume_.reset(new launcher::VolumeImp(glib::Object<GVolume>(G_VOLUME(gvolume_.RawPtr()), glib::AddRef()),
                                           file_manager_, device_notification_display_));
@@ -61,6 +61,7 @@
 TEST_F(TestVolumeImp, TestCtor)
 {
   EXPECT_FALSE(volume_->IsMounted());
+  EXPECT_FALSE(volume_->IsOpened());
 }
 
 TEST_F(TestVolumeImp, TestCanBeEjected)
@@ -109,6 +110,36 @@
   EXPECT_TRUE(volume_->IsMounted());
 }
 
+TEST_F(TestVolumeImp, TestIsOpened)
+{
+  volume_->MountAndOpenInFileManager(0);
+
+  EXPECT_CALL(*file_manager_, IsPrefixOpened(ROOT_FILE_URI));
+  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(true));
+  file_manager_->locations_changed.emit();
+  EXPECT_TRUE(volume_->IsOpened());
+
+  EXPECT_CALL(*file_manager_, IsPrefixOpened(ROOT_FILE_URI));
+  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(false));
+  file_manager_->locations_changed.emit();
+  EXPECT_FALSE(volume_->IsOpened());
+}
+
+TEST_F(TestVolumeImp, TestIsOpenedSignal)
+{
+  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(false));
+
+  bool opened = false;
+  volume_->opened.connect([&opened] (bool value) { opened = value; });
+  file_manager_->locations_changed.emit();
+
+  ASSERT_FALSE(opened);
+
+  ON_CALL(*file_manager_, IsPrefixOpened(_)).WillByDefault(Return(true));
+  file_manager_->locations_changed.emit();
+  EXPECT_TRUE(opened);
+}
+
 TEST_F(TestVolumeImp, TestEjectAndShowNotification)
 {
   g_mock_volume_set_can_eject(gvolume_, TRUE);
@@ -122,14 +153,7 @@
 TEST_F(TestVolumeImp, TestMountAndOpenInFileManager)
 {
   unsigned long long time = g_random_int();
-  EXPECT_CALL(*file_manager_, Open(ROOT_FILE_URI, time));
-
-  volume_->MountAndOpenInFileManager(time);
-  EXPECT_EQ(g_mock_volume_last_mount_had_mount_operation(gvolume_), TRUE);
-  EXPECT_TRUE(volume_->IsMounted());
-
-  time = g_random_int();
-  EXPECT_CALL(*file_manager_, Open(ROOT_FILE_URI, time));
+  EXPECT_CALL(*file_manager_, OpenActiveChild(ROOT_FILE_URI, time));
 
   volume_->MountAndOpenInFileManager(time);
   EXPECT_EQ(g_mock_volume_last_mount_had_mount_operation(gvolume_), TRUE);

=== modified file 'tests/test_volume_launcher_icon.cpp'
--- tests/test_volume_launcher_icon.cpp	2013-03-14 00:18:36 +0000
+++ tests/test_volume_launcher_icon.cpp	2013-03-28 12:05:12 +0000
@@ -35,8 +35,8 @@
 {
   virtual void SetUp()
   {
-    volume_.reset(new MockVolume);
-    settings_.reset(new MockDevicesSettings);
+    volume_.reset(new NiceMock<MockVolume>);
+    settings_.reset(new NiceMock<MockDevicesSettings>);
 
     SetupVolumeDefaultBehavior();
     SetupSettingsDefaultBehavior();
@@ -44,40 +44,25 @@
 
   void CreateIcon()
   {
-    icon_ = new VolumeLauncherIcon(volume_, settings_);
+    icon_ = new NiceMock<VolumeLauncherIcon>(volume_, settings_);
   }
 
   void SetupSettingsDefaultBehavior()
   {
-    EXPECT_CALL(*settings_, IsABlacklistedDevice(_))
-      .WillRepeatedly(Return(false));
+    ON_CALL(*settings_, IsABlacklistedDevice(_)).WillByDefault(Return(false));
   }
 
   void SetupVolumeDefaultBehavior()
   {
-    EXPECT_CALL(*volume_, CanBeRemoved())
-      .WillRepeatedly(Return(false));
-
-    EXPECT_CALL(*volume_, CanBeStopped())
-      .WillRepeatedly(Return(false));
-
-    EXPECT_CALL(*volume_, GetName())
-      .WillRepeatedly(Return("Test Name"));
-
-    EXPECT_CALL(*volume_, GetIconName())
-      .WillRepeatedly(Return("Test Icon Name"));
-
-    EXPECT_CALL(*volume_, GetIdentifier())
-      .WillRepeatedly(Return("Test Identifier"));
-
-    EXPECT_CALL(*volume_, HasSiblings())
-      .WillRepeatedly(Return(false));
-
-    EXPECT_CALL(*volume_, CanBeEjected())
-      .WillRepeatedly(Return(false));
-
-    EXPECT_CALL(*volume_, IsMounted())
-      .WillRepeatedly(Return(true));
+    ON_CALL(*volume_, CanBeRemoved()).WillByDefault(Return(false));
+    ON_CALL(*volume_, CanBeStopped()).WillByDefault(Return(false));
+    ON_CALL(*volume_, GetName()).WillByDefault(Return("Test Name"));
+    ON_CALL(*volume_, GetIconName()).WillByDefault(Return("Test Icon Name"));
+    ON_CALL(*volume_, GetIdentifier()).WillByDefault(Return("Test Identifier"));
+    ON_CALL(*volume_, HasSiblings()).WillByDefault(Return(false));
+    ON_CALL(*volume_, CanBeEjected()).WillByDefault(Return(false));
+    ON_CALL(*volume_, IsMounted()).WillByDefault(Return(true));
+    ON_CALL(*volume_, IsOpened()) .WillByDefault(Return(true));
   }
 
   glib::Object<DbusmenuMenuitem> GetMenuItemAtIndex(int index)
@@ -105,9 +90,23 @@
 {
   CreateIcon();
 
+  EXPECT_EQ(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING), volume_->IsOpened());
+}
+
+TEST_F(TestVolumeLauncherIcon, TestRunningStateUpdatesOnOpenedState)
+{
+  CreateIcon();
+
+  ON_CALL(*volume_, IsOpened()).WillByDefault(Return(false));
+  volume_->opened.emit(volume_->IsOpened());
   EXPECT_FALSE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
+
+  ON_CALL(*volume_, IsOpened()).WillByDefault(Return(true));
+  volume_->opened.emit(volume_->IsOpened());
+  EXPECT_TRUE(icon_->GetQuirk(AbstractLauncherIcon::Quirk::RUNNING));
 }
 
+
 TEST_F(TestVolumeLauncherIcon, TestPosition)
 {
   CreateIcon();

=== modified file 'unity-shared/FileManager.h'
--- unity-shared/FileManager.h	2013-03-21 20:09:02 +0000
+++ unity-shared/FileManager.h	2013-03-28 12:05:12 +0000
@@ -23,20 +23,27 @@
 
 #include <memory>
 #include <string>
+#include <sigc++/sigc++.h>
 
 namespace unity
 {
 
-class FileManager
+class FileManager : public sigc::trackable
 {
 public:
   typedef std::shared_ptr<FileManager> Ptr;
 
   FileManager() = default;
   virtual ~FileManager() {}
+
   virtual void Open(std::string const& uri, unsigned long long timestamp = 0) = 0;
+  virtual void OpenActiveChild(std::string const& uri, unsigned long long timestamp = 0) = 0;
+  virtual std::vector<std::string> OpenedLocations() const = 0;
+  virtual bool IsPrefixOpened(std::string const& uri) const = 0;
   virtual void EmptyTrash(unsigned long long timestamp = 0) = 0;
 
+  sigc::signal<void> locations_changed;
+
 private:
   FileManager(FileManager const&) = delete;
   FileManager& operator=(FileManager const&) = delete;

=== modified file 'unity-shared/GnomeFileManager.cpp'
--- unity-shared/GnomeFileManager.cpp	2013-03-21 20:37:04 +0000
+++ unity-shared/GnomeFileManager.cpp	2013-03-28 12:05:12 +0000
@@ -35,6 +35,75 @@
 const std::string TRASH_URI = "trash:";
 }
 
+struct GnomeFileManager::Impl
+{
+  Impl(GnomeFileManager* parent)
+    : parent_(parent)
+    , filemanager_proxy_("org.freedesktop.FileManager1", "/org/freedesktop/FileManager1", "org.freedesktop.FileManager1")
+  {
+    auto callback = sigc::mem_fun(this, &Impl::OnOpenLocationsUpdated);
+    filemanager_proxy_.GetProperty("OpenLocations", callback);
+    filemanager_proxy_.ConnectProperty("OpenLocations", callback);
+  }
+
+  void OnOpenLocationsUpdated(GVariant* value)
+  {
+    if (!g_variant_is_of_type(value, G_VARIANT_TYPE_STRING_ARRAY))
+    {
+      LOG_ERROR(logger) << "Locations value type is not matching the expected one!";
+      return;
+    }
+
+    opened_locations_.clear();
+
+    GVariantIter iter;
+    const char *str;
+
+    g_variant_iter_init(&iter, value);
+
+    while (g_variant_iter_loop(&iter, "s", &str))
+    {
+      LOG_DEBUG(logger) << "Opened location " << str;
+      opened_locations_.push_back(str);
+    }
+
+    parent_->locations_changed.emit();
+  }
+
+  std::string GetOpenedPrefix(std::string const& uri)
+  {
+    glib::Object<GFile> uri_file(g_file_new_for_uri(uri.c_str()));
+
+    for (auto const& loc : opened_locations_)
+    {
+      glib::Object<GFile> loc_file(g_file_new_for_uri(loc.c_str()));
+
+      if (g_file_equal(loc_file, uri_file) || g_file_has_prefix(loc_file, uri_file))
+        return loc;
+    }
+
+    return "";
+  }
+
+  GnomeFileManager* parent_;
+  glib::DBusProxy filemanager_proxy_;
+  std::vector<std::string> opened_locations_;
+};
+
+
+FileManager::Ptr GnomeFileManager::Get()
+{
+  static FileManager::Ptr instance(new GnomeFileManager());
+  return instance;
+}
+
+GnomeFileManager::GnomeFileManager()
+  : impl_(new Impl(this))
+{}
+
+GnomeFileManager::~GnomeFileManager()
+{}
+
 void GnomeFileManager::Open(std::string const& uri, unsigned long long timestamp)
 {
   if (uri.empty())
@@ -59,6 +128,13 @@
   }
 }
 
+void GnomeFileManager::OpenActiveChild(std::string const& uri, unsigned long long timestamp)
+{
+  auto const& opened = impl_->GetOpenedPrefix(uri);
+
+  Open(opened.empty() ? uri : opened, timestamp);
+}
+
 void GnomeFileManager::Activate(unsigned long long timestamp)
 {
   glib::Cancellable cancellable;
@@ -104,4 +180,14 @@
   proxy->CallBegin("EmptyTrash", nullptr, [proxy] (GVariant*, glib::Error const&) {});
 }
 
+std::vector<std::string> GnomeFileManager::OpenedLocations() const
+{
+  return impl_->opened_locations_;
+}
+
+bool GnomeFileManager::IsPrefixOpened(std::string const& uri) const
+{
+  return !impl_->GetOpenedPrefix(uri).empty();
+}
+
 }

=== modified file 'unity-shared/GnomeFileManager.h'
--- unity-shared/GnomeFileManager.h	2013-03-21 20:37:04 +0000
+++ unity-shared/GnomeFileManager.h	2013-03-28 12:05:12 +0000
@@ -29,11 +29,21 @@
 class GnomeFileManager : public FileManager
 {
 public:
+  static FileManager::Ptr Get();
+  ~GnomeFileManager();
+
   void Open(std::string const& uri, unsigned long long timestamp);
+  void OpenActiveChild(std::string const& uri, unsigned long long timestamp);
   void EmptyTrash(unsigned long long timestamp);
+  std::vector<std::string> OpenedLocations() const;
+  bool IsPrefixOpened(std::string const& uri) const;
 
 private:
+  GnomeFileManager();
   void Activate(unsigned long long timestamp);
+
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
 };
 
 }