← Back to branch summary

~3v1n0/unity/scale-window-cast-protection

« back to all changes in this revision

Viewing changes to launcher/VolumeLauncherIcon.cpp

  • Committer: Marco Trevisan (Treviño)
  • Date: 2016-03-07 18:51:47 UTC
  • mfrom: (4080 unity)
  • mto: This revision was merged to the branch mainline in revision 4085.
  • Revision ID: mail@3v1n0.net-20160307185147-0p1m89up4tqfb6w1
Merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
launcher/VolumeLauncherIcon.cpp
49
49
    , volume_(volume)
50
50
    , devices_settings_(devices_settings)
51
51
    , notification_(notification)
52
 
    , file_manager_(fm)
 
52
    , file_manager_(parent_->file_manager_)
53
53
  {
54
54
    UpdateIcon();
55
55
    UpdateVisibility();
60
60
  {
61
61
    parent_->tooltip_text = volume_->GetName();
62
62
    parent_->icon_name = volume_->GetIconName();
63
 
    parent_->SetQuirk(Quirk::RUNNING, file_manager_->IsPrefixOpened(volume_->GetUri()));
64
63
  }
65
64
 
66
65
  void UpdateVisibility()
67
66
  {
68
 
    UpdateKeepInLauncher();
69
 
    parent_->SetQuirk(Quirk::VISIBLE, keep_in_launcher_);
70
 
  }
71
 
 
72
 
  void UpdateKeepInLauncher()
73
 
  {
74
 
    auto const& identifier = volume_->GetIdentifier();
75
 
    keep_in_launcher_ = !devices_settings_->IsABlacklistedDevice(identifier);
 
67
    parent_->SetQuirk(Quirk::VISIBLE, IsVisible());
 
68
  }
 
69
 
 
70
  bool IsBlackListed()
 
71
  {
 
72
    return devices_settings_->IsABlacklistedDevice(volume_->GetIdentifier());
 
73
  }
 
74
 
 
75
  bool IsVisible()
 
76
  {
 
77
    if (IsBlackListed() && parent_->GetManagedWindows().empty())
 
78
      return false;
 
79
 
 
80
    return true;
76
81
  }
77
82
 
78
83
  void ConnectSignals()
79
84
  {
80
 
    connections_.Add(volume_->changed.connect(sigc::mem_fun(this, &Impl::OnVolumeChanged)));
 
85
    connections_.Add(volume_->changed.connect([this] { UpdateIcon(); }));
81
86
    connections_.Add(volume_->removed.connect(sigc::mem_fun(this, &Impl::OnVolumeRemoved)));
82
 
    connections_.Add(devices_settings_->changed.connect(sigc::mem_fun(this, &Impl::OnSettingsChanged)));
83
 
    connections_.Add(file_manager_->locations_changed.connect(sigc::mem_fun(this, &Impl::UpdateIcon)));
84
 
  }
85
 
 
86
 
  void OnVolumeChanged()
87
 
  {
88
 
    UpdateIcon();
 
87
    connections_.Add(devices_settings_->changed.connect([this] { UpdateVisibility(); }));
 
88
    connections_.Add(parent_->windows_changed.connect([this] (int) { UpdateVisibility(); }));
89
89
  }
90
90
 
91
91
  void OnVolumeRemoved()
92
92
  {
93
 
    if (devices_settings_->IsABlacklistedDevice(volume_->GetIdentifier()))
94
 
      devices_settings_->TryToUnblacklist(volume_->GetIdentifier());
95
 
 
 
93
    devices_settings_->TryToUnblacklist(volume_->GetIdentifier());
96
94
    parent_->UnStick();
97
95
    parent_->Remove();
98
96
  }
99
97
 
100
 
  void OnSettingsChanged()
101
 
  {
102
 
    UpdateVisibility();
103
 
  }
104
 
 
105
98
  bool CanEject() const
106
99
  {
107
100
    return volume_->CanBeEjected();
152
145
  void OpenInFileManager(uint64_t timestamp)
153
146
  {
154
147
    DoActionWhenMounted([this, timestamp] {
155
 
      file_manager_->OpenActiveChild(volume_->GetUri(), timestamp);
 
148
      file_manager_->Open(volume_->GetUri(), timestamp);
156
149
    });
157
150
  }
158
151
 
171
164
    AppendSeparatorItem(result);
172
165
    AppendNameItem(result);
173
166
    AppendSeparatorItem(result);
174
 
    AppendUnlockFromLauncherItem(result);
 
167
    AppendWindowsItems(result);
 
168
    AppendToggleLockFromLauncherItem(result);
175
169
    AppendEjectItem(result);
176
170
    AppendSafelyRemoveItem(result);
177
171
    AppendUnmountItem(result);
 
172
    AppendQuitItem(result);
178
173
 
179
174
    return result;
180
175
  }
181
176
 
182
 
  void AppendUnlockFromLauncherItem(MenuItemsVector& menu)
 
177
  void AppendToggleLockFromLauncherItem(MenuItemsVector& menu)
183
178
  {
184
179
    if (volume_->GetIdentifier().empty())
185
180
      return;
186
181
 
187
182
    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
188
183
 
189
 
    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Unlock from Launcher"));
 
184
    const char* label = IsBlackListed() ? _("Lock to Launcher") : _("Unlock from Launcher");
 
185
    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, label);
190
186
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
191
187
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
192
188
 
193
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
194
 
      auto const& identifier = volume_->GetIdentifier();
195
 
      parent_->UnStick();
196
 
      devices_settings_->TryToBlacklist(identifier);
 
189
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
190
      if (!IsBlackListed())
 
191
      {
 
192
        parent_->UnStick();
 
193
        devices_settings_->TryToBlacklist(volume_->GetIdentifier());
 
194
      }
 
195
      else
 
196
      {
 
197
        devices_settings_->TryToUnblacklist(volume_->GetIdentifier());
 
198
      }
197
199
    }));
198
200
 
199
201
    menu.push_back(menu_item);
220
222
    dbusmenu_menuitem_property_set_bool(menu_item, QuicklistMenuItem::MARKUP_ENABLED_PROPERTY, true);
221
223
    dbusmenu_menuitem_property_set_bool(menu_item, QuicklistMenuItem::MARKUP_ACCEL_DISABLED_PROPERTY, true);
222
224
 
223
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
 
225
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
224
226
      OpenInFileManager(timestamp);
225
227
    }));
226
228
 
227
229
    menu.push_back(menu_item);
228
230
  }
229
231
 
 
232
  void AppendWindowsItems(MenuItemsVector& menu)
 
233
  {
 
234
    if (!parent_->IsRunning())
 
235
      return;
 
236
 
 
237
    auto const& windows_items = parent_->GetWindowsMenuItems();
 
238
    if (!windows_items.empty())
 
239
    {
 
240
      menu.insert(end(menu), begin(windows_items), end(windows_items));
 
241
      AppendSeparatorItem(menu);
 
242
    }
 
243
  }
 
244
 
230
245
  void AppendOpenItem(MenuItemsVector& menu)
231
246
  {
232
247
    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
235
250
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
236
251
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
237
252
 
238
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
 
253
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, unsigned timestamp) {
239
254
      OpenInFileManager(timestamp);
240
255
    }));
241
256
 
253
268
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
254
269
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
255
270
 
256
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
271
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
272
      parent_->Quit();
257
273
      EjectAndShowNotification();
258
274
    }));
259
275
 
271
287
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
272
288
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
273
289
 
274
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
275
 
        volume_->StopDrive();
 
290
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
291
      parent_->Quit();
 
292
      volume_->StopDrive();
276
293
    }));
277
294
 
278
295
    menu.push_back(menu_item);
289
306
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
290
307
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
291
308
 
292
 
    gsignals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
293
 
        volume_->Unmount();
 
309
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
310
      volume_->Unmount();
 
311
    }));
 
312
 
 
313
    menu.push_back(menu_item);
 
314
  }
 
315
 
 
316
  void AppendQuitItem(MenuItemsVector& menu)
 
317
  {
 
318
    if (!parent_->IsRunning())
 
319
      return;
 
320
 
 
321
    if (!menu.empty())
 
322
      AppendSeparatorItem(menu);
 
323
 
 
324
    glib::Object<DbusmenuMenuitem> menu_item(dbusmenu_menuitem_new());
 
325
 
 
326
    dbusmenu_menuitem_property_set(menu_item, DBUSMENU_MENUITEM_PROP_LABEL, _("Quit"));
 
327
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_ENABLED, true);
 
328
    dbusmenu_menuitem_property_set_bool(menu_item, DBUSMENU_MENUITEM_PROP_VISIBLE, true);
 
329
 
 
330
    parent_->glib_signals_.Add(new ItemSignal(menu_item, DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, [this] (DbusmenuMenuitem*, int) {
 
331
      parent_->Quit();
294
332
    }));
295
333
 
296
334
    menu.push_back(menu_item);
307
345
  }
308
346
 
309
347
  VolumeLauncherIcon* parent_;
310
 
  bool keep_in_launcher_;
311
348
  Volume::Ptr volume_;
312
349
  DevicesSettings::Ptr devices_settings_;
313
350
  DeviceNotificationDisplay::Ptr notification_;
314
351
  FileManager::Ptr file_manager_;
315
 
 
316
 
  glib::SignalManager gsignals_;
317
352
  connection::Manager connections_;
318
353
};
319
354
 
325
360
                                       DevicesSettings::Ptr const& devices_settings,
326
361
                                       DeviceNotificationDisplay::Ptr const& notification,
327
362
                                       FileManager::Ptr const& fm)
328
 
  : SimpleLauncherIcon(IconType::DEVICE)
 
363
  : WindowedLauncherIcon(IconType::DEVICE)
 
364
  , StorageLauncherIcon(GetIconType(), fm)
329
365
  , pimpl_(new Impl(volume, devices_settings, notification, fm, this))
330
 
{}
 
366
{
 
367
  UpdateStorageWindows();
 
368
}
331
369
 
332
370
VolumeLauncherIcon::~VolumeLauncherIcon()
333
371
{}
334
372
 
335
373
void VolumeLauncherIcon::AboutToRemove()
336
374
{
 
375
  StorageLauncherIcon::AboutToRemove();
 
376
 
337
377
  if (CanEject())
338
378
    EjectAndShowNotification();
339
379
  else if (CanStop())
360
400
  return pimpl_->StopDrive();
361
401
}
362
402
 
363
 
void VolumeLauncherIcon::ActivateLauncherIcon(ActionArg arg)
364
 
{
365
 
  SimpleLauncherIcon::ActivateLauncherIcon(arg);
366
 
  pimpl_->OpenInFileManager(arg.timestamp);
367
 
}
368
 
 
369
403
AbstractLauncherIcon::MenuItemsVector VolumeLauncherIcon::GetMenus()
370
404
{
371
405
  return pimpl_->GetMenus();
388
422
  SetQuirk(Quirk::VISIBLE, true);
389
423
}
390
424
 
391
 
bool VolumeLauncherIcon::OnShouldHighlightOnDrag(DndData const& dnd_data)
392
 
{
393
 
  for (auto const& uri : dnd_data.Uris())
394
 
  {
395
 
    if (uri.find("file://") == 0)
396
 
      return true;
397
 
  }
398
 
 
399
 
  return false;
400
 
}
401
 
 
402
425
nux::DndAction VolumeLauncherIcon::OnQueryAcceptDrop(DndData const& dnd_data)
403
426
{
404
427
  return dnd_data.Uris().empty() ? nux::DNDACTION_NONE : nux::DNDACTION_COPY;
412
435
  FullyAnimateQuirkDelayed(100, LauncherIcon::Quirk::SHIMMER);
413
436
}
414
437
 
 
438
std::string VolumeLauncherIcon::GetVolumeUri() const
 
439
{
 
440
  return pimpl_->volume_->GetUri();
 
441
}
 
442
 
 
443
WindowList VolumeLauncherIcon::GetStorageWindows() const
 
444
{
 
445
  return file_manager_->WindowsForLocation(GetVolumeUri());
 
446
}
 
447
 
 
448
void VolumeLauncherIcon::OpenInstanceLauncherIcon(Time timestamp)
 
449
{
 
450
  pimpl_->OpenInFileManager(timestamp);
 
451
}
 
452
 
415
453
//
416
454
// Introspection
417
455
//