← Back to branch summary

~bilalakhtar/unity/software-center-integration-for-o

« back to all changes in this revision

Viewing changes to plugins/unityshell/src/PanelController.cpp

  • Committer: Bilal Akhtar
  • Date: 2012-01-15 14:03:49 UTC
  • mfrom: (1346.2.488 unity)
  • Revision ID: bilalakhtar@ubuntu.com-20120115140349-mht4dke0occbsyra
Merge from trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/unityshell/src/PanelController.cpp
 
1
// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
1
2
/*
2
3
 * Copyright (C) 2011 Canonical Ltd
3
4
 *
18
19
 
19
20
#include "PanelController.h"
20
21
 
21
 
#include "NuxCore/Logger.h"
 
22
#include <vector>
 
23
#include <NuxCore/Logger.h>
 
24
#include <Nux/BaseWindow.h>
22
25
 
23
26
#include "UScreen.h"
24
 
 
25
 
#include "unitya11y.h"
26
 
#include "unity-util-accessible.h"
27
 
 
28
 
using namespace unity;
 
27
#include "PanelView.h"
 
28
 
 
29
namespace unity
 
30
{
 
31
namespace panel
 
32
{
29
33
 
30
34
namespace
31
35
{
32
36
nux::logging::Logger logger("unity.panel");
33
37
}
34
38
 
35
 
PanelController::PanelController()
36
 
  : _bfb_size(66),
37
 
    _opacity(1.0f),
38
 
    _open_menu_start_received(false)
 
39
class Controller::Impl : public sigc::trackable
 
40
{
 
41
public:
 
42
  Impl();
 
43
  ~Impl();
 
44
 
 
45
  void StartFirstMenuShow();
 
46
  void EndFirstMenuShow();
 
47
  void QueueRedraw();
 
48
 
 
49
  unsigned int GetTrayXid();
 
50
  std::list <nux::Geometry> GetGeometries();
 
51
 
 
52
  // NOTE: nux::Property maybe?
 
53
  void SetOpacity(float opacity);
 
54
  void SetOpacityMaximizedToggle(bool enabled);
 
55
 
 
56
  float opacity() const;
 
57
 
 
58
  void SetMenuShowTimings(int fadein, int fadeout, int discovery,
 
59
                          int discovery_fadein, int discovery_fadeout);
 
60
 
 
61
private:
 
62
  unity::PanelView* ViewForWindow(nux::BaseWindow* window);
 
63
  void OnScreenChanged(int primary_monitor, std::vector<nux::Geometry>& monitors);
 
64
 
 
65
  static void WindowConfigureCallback(int            window_width,
 
66
                                      int            window_height,
 
67
                                      nux::Geometry& geo,
 
68
                                      void*          user_data);
 
69
private:
 
70
  std::vector<nux::BaseWindow*> windows_;
 
71
  float opacity_;
 
72
  bool opacity_maximized_toggle_;
 
73
  bool open_menu_start_received_;
 
74
  int menus_fadein_;
 
75
  int menus_fadeout_;
 
76
  int menus_discovery_;
 
77
  int menus_discovery_fadein_;
 
78
  int menus_discovery_fadeout_;
 
79
};
 
80
 
 
81
 
 
82
Controller::Impl::Impl()
 
83
  : opacity_(1.0f)
 
84
  , opacity_maximized_toggle_(false)
 
85
  , open_menu_start_received_(false)
39
86
{
40
87
  UScreen* screen = UScreen::GetDefault();
41
 
  screen->changed.connect(sigc::mem_fun(this, &PanelController::OnScreenChanged));
 
88
  screen->changed.connect(sigc::mem_fun(this, &Impl::OnScreenChanged));
42
89
  OnScreenChanged(screen->GetPrimaryMonitor(), screen->GetMonitors());
43
90
}
44
91
 
45
 
PanelController::~PanelController()
 
92
Controller::Impl::~Impl()
46
93
{
47
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
48
 
 
49
 
  for (it = _windows.begin(); it != eit; ++it)
 
94
  for (auto window : windows_)
50
95
  {
51
 
    (*it)->UnReference();
 
96
    window->UnReference();
52
97
  }
53
98
}
54
99
 
55
 
unsigned int PanelController::GetTrayXid ()
 
100
unsigned int Controller::Impl::GetTrayXid()
56
101
{
57
 
  if (!_windows.empty ())
58
 
    return ViewForWindow (_windows.front ())->GetTrayXid ();
 
102
  if (!windows_.empty())
 
103
    return ViewForWindow(windows_.front())->GetTrayXid();
59
104
  else
60
105
    return 0;
61
106
}
62
107
 
63
 
void
64
 
PanelController::StartFirstMenuShow()
65
 
{
66
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
67
 
 
68
 
  for (it = _windows.begin(); it != eit; ++it)
69
 
  {
70
 
    PanelView* view = ViewForWindow(*it);
71
 
 
 
108
std::list<nux::Geometry> Controller::Impl::GetGeometries()
 
109
{
 
110
  std::list<nux::Geometry> geometries;
 
111
 
 
112
  for (auto window : windows_)
 
113
  {
 
114
    geometries.push_back(window->GetAbsoluteGeometry());
 
115
  }
 
116
 
 
117
  return geometries;
 
118
}
 
119
 
 
120
void Controller::Impl::StartFirstMenuShow()
 
121
{
 
122
  for (auto window: windows_)
 
123
  {
 
124
    PanelView* view = ViewForWindow(window);
72
125
    view->StartFirstMenuShow();
73
126
  }
74
127
 
75
 
  _open_menu_start_received = true;
 
128
  open_menu_start_received_ = true;
76
129
}
77
130
 
78
 
void
79
 
PanelController::EndFirstMenuShow()
 
131
void Controller::Impl::EndFirstMenuShow()
80
132
{
81
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
82
 
 
83
 
  if (!_open_menu_start_received)
 
133
  if (!open_menu_start_received_)
84
134
    return;
85
 
  _open_menu_start_received = false;
 
135
  open_menu_start_received_ = false;
86
136
 
87
 
  for (it = _windows.begin(); it != eit; ++it)
 
137
  for (auto window: windows_)
88
138
  {
89
 
    PanelView* view = ViewForWindow(*it);
 
139
    PanelView* view = ViewForWindow(window);
90
140
    view->EndFirstMenuShow();
91
141
  }
92
142
}
93
143
 
94
 
void
95
 
PanelController::SetOpacity(float opacity)
96
 
{
97
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
98
 
 
99
 
  _opacity = opacity;
100
 
 
101
 
  for (it = _windows.begin(); it != eit; ++it)
102
 
  {
103
 
    ViewForWindow(*it)->SetOpacity(_opacity);
104
 
  }
105
 
}
106
 
 
107
 
void PanelController::QueueRedraw()
108
 
{
109
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
110
 
  for (it = _windows.begin(); it != eit; ++it)
111
 
  {
112
 
    (*it)->QueueDraw();
113
 
  }
114
 
}
115
 
 
116
 
PanelView*
117
 
PanelController::ViewForWindow(nux::BaseWindow* window)
 
144
void Controller::Impl::SetOpacity(float opacity)
 
145
{
 
146
  opacity_ = opacity;
 
147
 
 
148
  for (auto window: windows_)
 
149
  {
 
150
    ViewForWindow(window)->SetOpacity(opacity_);
 
151
  }
 
152
}
 
153
 
 
154
void Controller::Impl::SetOpacityMaximizedToggle(bool enabled)
 
155
{
 
156
  opacity_maximized_toggle_ = enabled;
 
157
 
 
158
  for (auto window: windows_)
 
159
  {
 
160
    ViewForWindow(window)->SetOpacityMaximizedToggle(opacity_maximized_toggle_);
 
161
  }
 
162
}
 
163
 
 
164
void Controller::Impl::SetMenuShowTimings(int fadein, int fadeout, int discovery,
 
165
                                          int discovery_fadein, int discovery_fadeout)
 
166
{
 
167
  menus_fadein_ = fadein;
 
168
  menus_fadeout_ = fadeout;
 
169
  menus_discovery_ = discovery;
 
170
  menus_discovery_fadein_ = discovery_fadein;
 
171
  menus_discovery_fadeout_ = discovery_fadeout;
 
172
 
 
173
  for (auto window: windows_)
 
174
  {
 
175
    ViewForWindow(window)->SetMenuShowTimings(fadein, fadeout, discovery,
 
176
                                              discovery_fadein, discovery_fadeout);
 
177
  }
 
178
}
 
179
 
 
180
void Controller::Impl::QueueRedraw()
 
181
{
 
182
  for (auto window: windows_)
 
183
  {
 
184
    window->QueueDraw();
 
185
  }
 
186
}
 
187
 
 
188
PanelView* Controller::Impl::ViewForWindow(nux::BaseWindow* window)
118
189
{
119
190
  nux::Layout* layout = window->GetLayout();
120
191
  std::list<nux::Area*>::iterator it = layout->GetChildren().begin();
123
194
}
124
195
 
125
196
// We need to put a panel on every monitor, and try and re-use the panels we already have
126
 
void
127
 
PanelController::OnScreenChanged(int primary_monitor, std::vector<nux::Geometry>& monitors)
 
197
void Controller::Impl::OnScreenChanged(int primary_monitor,
 
198
                                       std::vector<nux::Geometry>& monitors)
128
199
{
129
 
  std::vector<nux::BaseWindow*>::iterator it, eit = _windows.end();
 
200
  std::vector<nux::BaseWindow*>::iterator it, eit = windows_.end();
130
201
  int n_monitors = monitors.size();
131
202
  int i = 0;
132
203
 
133
 
  for (it = _windows.begin(); it != eit; ++it)
 
204
  for (it = windows_.begin(); it != eit; ++it)
134
205
  {
135
206
    if (i < n_monitors)
136
207
    {
163
234
  {
164
235
    for (i = i; i < n_monitors; i++)
165
236
    {
166
 
      nux::BaseWindow* window;
167
 
      PanelView*       view;
168
 
      nux::HLayout*    layout;
169
 
 
170
 
      // FIXME(loicm): Several objects created here are leaked.
171
 
 
172
 
      layout = new nux::HLayout(NUX_TRACKER_LOCATION);
173
 
 
174
 
      view = new PanelView();
 
237
      nux::HLayout* layout = new nux::HLayout(NUX_TRACKER_LOCATION);
 
238
 
 
239
      PanelView* view = new PanelView();
175
240
      view->SetMaximumHeight(24);
176
 
      view->SetOpacity(_opacity);
 
241
      view->SetOpacity(opacity_);
 
242
      view->SetOpacityMaximizedToggle(opacity_maximized_toggle_);
 
243
      view->SetMenuShowTimings(menus_fadein_, menus_fadeout_, menus_discovery_,
 
244
                               menus_discovery_fadein_, menus_discovery_fadeout_);
177
245
      view->SetPrimary(i == primary_monitor);
178
246
      view->SetMonitor(i);
179
 
      AddChild(view);
180
247
 
181
248
      layout->AddView(view, 1);
182
249
      layout->SetContentDistribution(nux::eStackLeft);
183
250
      layout->SetVerticalExternalMargin(0);
184
251
      layout->SetHorizontalExternalMargin(0);
185
252
 
186
 
      window = new nux::BaseWindow("");
 
253
      nux::BaseWindow* window = new nux::BaseWindow("");
187
254
      window->SinkReference();
188
 
      window->SetConfigureNotifyCallback(&PanelController::WindowConfigureCallback, window);
 
255
      window->SetConfigureNotifyCallback(&Impl::WindowConfigureCallback, window);
189
256
      window->SetLayout(layout);
190
 
      window->SetBackgroundColor(nux::Color(0x00000000));
 
257
      window->SetBackgroundColor(nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
191
258
      window->ShowWindow(true);
192
259
      window->EnableInputWindow(true, "panel", false, false);
193
260
      window->InputWindowEnableStruts(true);
196
263
      geo.height = 24;
197
264
      window->SetGeometry(geo);
198
265
 
199
 
      /* FIXME: this should not be manual, should be managed with a
200
 
         show/hide callback like in GAIL*/
201
 
      if (unity_a11y_initialized() == TRUE)
202
 
        unity_util_accessible_add_window(window);
203
 
 
204
 
      _windows.push_back(window);
 
266
      windows_.push_back(window);
205
267
 
206
268
      LOG_DEBUG(logger) << "Added Panel for Monitor " << i;
207
269
    }
208
270
  }
209
271
 
210
 
  if ((int)_windows.size() > n_monitors)
 
272
  if ((int)windows_.size() > n_monitors)
211
273
  {
212
274
    std::vector<nux::BaseWindow*>::iterator sit;
213
275
    for (sit = it; sit != eit; ++sit)
216
278
      LOG_DEBUG(logger) << "Removed extra Panel";
217
279
    }
218
280
 
219
 
    _windows.erase(it, _windows.end());
 
281
    windows_.erase(it, windows_.end());
220
282
  }
221
283
}
222
284
 
223
 
void
224
 
PanelController::WindowConfigureCallback(int            window_width,
225
 
                                         int            window_height,
226
 
                                         nux::Geometry& geo,
227
 
                                         void*          user_data)
 
285
void Controller::Impl::WindowConfigureCallback(int window_width,
 
286
                                               int window_height,
 
287
                                               nux::Geometry& geo,
 
288
                                               void* user_data)
228
289
{
229
290
  nux::BaseWindow* window = static_cast<nux::BaseWindow*>(user_data);
230
291
  geo = window->GetGeometry();
231
292
}
232
293
 
233
 
const gchar*
234
 
PanelController::GetName()
235
 
{
236
 
  return "PanelController";
237
 
}
238
 
 
239
 
void
240
 
PanelController::AddProperties(GVariantBuilder* builder)
241
 
{
242
 
 
243
 
}
 
294
float Controller::Impl::opacity() const
 
295
{
 
296
  return opacity_;
 
297
}
 
298
 
 
299
 
 
300
Controller::Controller()
 
301
  : pimpl(new Impl())
 
302
{
 
303
}
 
304
 
 
305
Controller::~Controller()
 
306
{
 
307
  delete pimpl;
 
308
}
 
309
 
 
310
void Controller::StartFirstMenuShow()
 
311
{
 
312
  pimpl->StartFirstMenuShow();
 
313
}
 
314
 
 
315
void Controller::EndFirstMenuShow()
 
316
{
 
317
  pimpl->EndFirstMenuShow();
 
318
}
 
319
 
 
320
void Controller::SetOpacity(float opacity)
 
321
{
 
322
  pimpl->SetOpacity(opacity);
 
323
}
 
324
 
 
325
void Controller::SetOpacityMaximizedToggle(bool enabled)
 
326
{
 
327
  pimpl->SetOpacityMaximizedToggle(enabled);
 
328
}
 
329
 
 
330
void Controller::SetMenuShowTimings(int fadein, int fadeout, int discovery,
 
331
                                    int discovery_fadein, int discovery_fadeout)
 
332
{
 
333
  pimpl->SetMenuShowTimings(fadein, fadeout, discovery, discovery_fadein, discovery_fadeout);
 
334
}
 
335
 
 
336
void Controller::QueueRedraw()
 
337
{
 
338
  pimpl->QueueRedraw();
 
339
}
 
340
 
 
341
unsigned int Controller::GetTrayXid()
 
342
{
 
343
  return pimpl->GetTrayXid();
 
344
}
 
345
 
 
346
std::list<nux::Geometry> Controller::GetGeometries()
 
347
{
 
348
  return pimpl->GetGeometries();
 
349
}
 
350
 
 
351
float Controller::opacity() const
 
352
{
 
353
  return pimpl->opacity();
 
354
}
 
355
 
 
356
 
 
357
} // namespace panel
 
358
} // namespace unity