← Back to branch summary

~jamespharaoh/ubuntu/oneiric/unity/fix-for-880672

« back to all changes in this revision

Viewing changes to .pc/debian-changes-4.8.2-0ubuntu3/plugins/unityshell/src/unityshell.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-08-19 18:53:28 UTC
  • Revision ID: james.westby@ubuntu.com-20110819185328-qaxk9eepjaghewu9
Tags: 4.8.2-0ubuntu4
Backport another trunk commit to fix an alt-tab segfault

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/debian-changes-4.8.2-0ubuntu3/plugins/unityshell/src/unityshell.cpp
1
 
// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
2
 
/* Compiz unity plugin
3
 
 * unity.cpp
4
 
 *
5
 
 * Copyright (c) 2010-11 Canonical Ltd.
6
 
 *
7
 
 * This program is free software; you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License
9
 
 * as published by the Free Software Foundation; either version 3
10
 
 * of the License, or (at your option) any later version.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 *
17
 
 * Your own copyright notice would go above. You are free to choose whatever
18
 
 * licence you want, just take note that some compiz code is GPL and you will
19
 
 * not be able to re-use it if you want to use a different licence.
20
 
 */
21
 
 
22
 
#include <NuxCore/Logger.h>
23
 
#include <Nux/Nux.h>
24
 
#include <Nux/HLayout.h>
25
 
#include <Nux/BaseWindow.h>
26
 
#include <Nux/WindowCompositor.h>
27
 
 
28
 
#include "IconRenderer.h"
29
 
#include "Launcher.h"
30
 
#include "LauncherIcon.h"
31
 
#include "LauncherController.h"
32
 
#include "PlacesSettings.h"
33
 
#include "GeisAdapter.h"
34
 
#include "DevicesSettings.h"
35
 
#include "PluginAdapter.h"
36
 
#include "StartupNotifyService.h"
37
 
#include "Timer.h"
38
 
#include "unityshell.h"
39
 
#include "BackgroundEffectHelper.h"
40
 
 
41
 
#include <dbus/dbus.h>
42
 
#include <dbus/dbus-glib.h>
43
 
#include <glib/gi18n-lib.h>
44
 
#include <gtk/gtk.h>
45
 
#include <gdk/gdk.h>
46
 
#include <libnotify/notify.h>
47
 
 
48
 
#include <sstream>
49
 
 
50
 
#include <core/atoms.h>
51
 
 
52
 
#include "unitya11y.h"
53
 
 
54
 
#include "ubus-server.h"
55
 
#include "UBusMessages.h"
56
 
 
57
 
#include "config.h"
58
 
 
59
 
/* FIXME: once we get a better method to add the toplevel windows to
60
 
   the accessible root object, this include would not be required */
61
 
#include "unity-util-accessible.h"
62
 
 
63
 
using namespace unity::switcher;
64
 
 
65
 
/* Set up vtable symbols */
66
 
COMPIZ_PLUGIN_20090315(unityshell, UnityPluginVTable);
67
 
 
68
 
using ::unity::logger::Timer;
69
 
 
70
 
namespace
71
 
{
72
 
 
73
 
nux::logging::Logger logger("unity.shell");
74
 
 
75
 
UnityScreen* uScreen = 0;
76
 
 
77
 
void configure_logging();
78
 
void capture_g_log_calls(const gchar* log_domain,
79
 
                         GLogLevelFlags log_level,
80
 
                         const gchar* message,
81
 
                         gpointer user_data);
82
 
gboolean is_extension_supported(const gchar* extensions, const gchar* extension);
83
 
gfloat get_opengl_version_f32(const gchar* version_string);
84
 
 
85
 
}
86
 
 
87
 
UnityScreen::UnityScreen(CompScreen* screen)
88
 
  : BaseSwitchScreen (screen)
89
 
  , PluginClassHandler <UnityScreen, CompScreen> (screen)
90
 
  , screen(screen)
91
 
  , cScreen(CompositeScreen::get(screen))
92
 
  , gScreen(GLScreen::get(screen))
93
 
  , launcher(nullptr)
94
 
  , controller(nullptr)
95
 
  , panelController(nullptr)
96
 
  , switcherController(nullptr)
97
 
  , gestureEngine(nullptr)
98
 
  , wt(nullptr)
99
 
  , launcherWindow(nullptr)
100
 
  , panelWindow(nullptr)
101
 
  , debugger(nullptr)
102
 
  , needsRelayout(false)
103
 
  , relayoutSourceId(0)
104
 
  , _edge_trigger_handle(0)
105
 
  , _edge_pointerY(0)
106
 
  , newFocusedWindow(nullptr)
107
 
  , lastFocusedWindow(nullptr)
108
 
  , doShellRepaint(false)
109
 
  , allowWindowPaint(false)
110
 
  , damaged(false)
111
 
  , _key_nav_mode_requested(false)
112
 
  , _last_output(nullptr)
113
 
  , switcher_desktop_icon(nullptr)
114
 
  , mActiveFbo (0)
115
 
{
116
 
  Timer timer;
117
 
  configure_logging();
118
 
  LOG_DEBUG(logger) << __PRETTY_FUNCTION__;
119
 
  int (*old_handler)(Display*, XErrorEvent*);
120
 
  old_handler = XSetErrorHandler(NULL);
121
 
 
122
 
  notify_init("unityshell");
123
 
 
124
 
  g_thread_init(NULL);
125
 
  dbus_g_thread_init();
126
 
 
127
 
  unity_a11y_preset_environment();
128
 
 
129
 
  XSetErrorHandler(old_handler);
130
 
 
131
 
  /* Wrap compiz interfaces */
132
 
  ScreenInterface::setHandler(screen);
133
 
  CompositeScreenInterface::setHandler(cScreen);
134
 
  GLScreenInterface::setHandler(gScreen);
135
 
 
136
 
  PluginAdapter::Initialize(screen);
137
 
  WindowManager::SetDefault(PluginAdapter::Default());
138
 
 
139
 
  StartupNotifyService::Default()->SetSnDisplay(screen->snDisplay(), screen->screenNum());
140
 
 
141
 
  nux::NuxInitialize(0);
142
 
  wt = nux::CreateFromForeignWindow(cScreen->output(),
143
 
                                    glXGetCurrentContext(),
144
 
                                    &UnityScreen::initUnity,
145
 
                                    this);
146
 
 
147
 
  wt->RedrawRequested.connect(sigc::mem_fun(this, &UnityScreen::onRedrawRequested));
148
 
 
149
 
  unity_a11y_init(wt);
150
 
 
151
 
  /* i18n init */
152
 
  bindtextdomain(GETTEXT_PACKAGE, LOCALE_DIR);
153
 
  bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
154
 
 
155
 
  wt->Run(NULL);
156
 
  uScreen = this;
157
 
 
158
 
  debugger = new DebugDBusInterface(this);
159
 
 
160
 
  _edge_timeout = optionGetLauncherRevealEdgeTimeout ();
161
 
 
162
 
  if (GL::fbo)
163
 
  {
164
 
    foreach (CompOutput &o, screen->outputDevs ())
165
 
      uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO (&o));
166
 
    
167
 
    uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO (&(screen->fullscreenOutput ())));
168
 
  }
169
 
 
170
 
  optionSetLauncherHideModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
171
 
  optionSetBacklightModeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
172
 
  optionSetLaunchAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
173
 
  optionSetUrgentAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
174
 
  optionSetPanelOpacityNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
175
 
  optionSetLauncherOpacityNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
176
 
  optionSetIconSizeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
177
 
  optionSetAutohideAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
178
 
  optionSetDashBlurExperimentalNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
179
 
  optionSetDevicesOptionNotify(boost::bind (&UnityScreen::optionChanged, this, _1, _2));
180
 
  optionSetShowLauncherInitiate(boost::bind(&UnityScreen::showLauncherKeyInitiate, this, _1, _2, _3));
181
 
  optionSetShowLauncherTerminate(boost::bind(&UnityScreen::showLauncherKeyTerminate, this, _1, _2, _3));
182
 
  optionSetKeyboardFocusInitiate(boost::bind(&UnityScreen::setKeyboardFocusKeyInitiate, this, _1, _2, _3));
183
 
  //optionSetKeyboardFocusTerminate (boost::bind (&UnityScreen::setKeyboardFocusKeyTerminate, this, _1, _2, _3));
184
 
  optionSetExecuteCommandInitiate(boost::bind(&UnityScreen::executeCommand, this, _1, _2, _3));
185
 
  optionSetPanelFirstMenuInitiate(boost::bind(&UnityScreen::showPanelFirstMenuKeyInitiate, this, _1, _2, _3));
186
 
  optionSetPanelFirstMenuTerminate(boost::bind(&UnityScreen::showPanelFirstMenuKeyTerminate, this, _1, _2, _3));
187
 
  optionSetLauncherRevealEdgeInitiate(boost::bind(&UnityScreen::launcherRevealEdgeInitiate, this, _1, _2, _3));
188
 
  optionSetLauncherRevealEdgeTimeoutNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
189
 
  optionSetAutomaximizeValueNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
190
 
  optionSetAltTabTimeoutNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
191
 
  
192
 
  optionSetAltTabForwardInitiate(boost::bind(&UnityScreen::altTabForwardInitiate, this, _1, _2, _3));
193
 
  optionSetAltTabForwardTerminate(boost::bind(&UnityScreen::altTabForwardTerminate, this, _1, _2, _3));
194
 
  
195
 
  optionSetAltTabPrevInitiate(boost::bind(&UnityScreen::altTabPrevInitiate, this, _1, _2, _3));
196
 
  optionSetAltTabPrevTerminate(boost::bind(&UnityScreen::altTabPrevTerminate, this, _1, _2, _3));
197
 
  
198
 
  optionSetAltTabDetailStartInitiate(boost::bind(&UnityScreen::altTabDetailStartInitiate, this, _1, _2, _3));
199
 
  optionSetAltTabDetailStartTerminate(boost::bind(&UnityScreen::altTabDetailStartTerminate, this, _1, _2, _3));
200
 
 
201
 
  optionSetAltTabDetailStopInitiate(boost::bind(&UnityScreen::altTabDetailStopInitiate, this, _1, _2, _3));
202
 
  optionSetAltTabDetailStopTerminate(boost::bind(&UnityScreen::altTabDetailStopTerminate, this, _1, _2, _3));
203
 
 
204
 
  optionSetAltTabNextWindowInitiate(boost::bind(&UnityScreen::altTabNextWindowInitiate, this, _1, _2, _3));
205
 
  optionSetAltTabNextWindowTerminate(boost::bind(&UnityScreen::altTabNextWindowTerminate, this, _1, _2, _3));
206
 
 
207
 
  optionSetAltTabExitInitiate(boost::bind(&UnityScreen::altTabExitInitiate, this, _1, _2, _3));
208
 
  optionSetAltTabExitTerminate(boost::bind(&UnityScreen::altTabExitTerminate, this, _1, _2, _3));
209
 
  
210
 
 
211
 
  for (unsigned int i = 0; i < G_N_ELEMENTS(_ubus_handles); i++)
212
 
    _ubus_handles[i] = 0;
213
 
 
214
 
  UBusServer* ubus = ubus_server_get_default();
215
 
  _ubus_handles[0] = ubus_server_register_interest(ubus,
216
 
                                                   UBUS_LAUNCHER_START_KEY_NAV,
217
 
                                                   (UBusCallback)&UnityScreen::OnLauncherStartKeyNav,
218
 
                                                   this);
219
 
 
220
 
  _ubus_handles[1] = ubus_server_register_interest(ubus,
221
 
                                                   UBUS_LAUNCHER_END_KEY_NAV,
222
 
                                                   (UBusCallback)&UnityScreen::OnLauncherEndKeyNav,
223
 
                                                   this);
224
 
 
225
 
  _ubus_handles[2] = ubus_server_register_interest(ubus,
226
 
                                                   UBUS_QUICKLIST_END_KEY_NAV,
227
 
                                                   (UBusCallback)&UnityScreen::OnQuicklistEndKeyNav,
228
 
                                                   this);
229
 
 
230
 
  g_timeout_add(0, &UnityScreen::initPluginActions, this);
231
 
 
232
 
  GeisAdapter::Default(screen)->Run();
233
 
  gestureEngine = new GestureEngine(screen);
234
 
 
235
 
  CompString name(PKGDATADIR"/panel-shadow.png");
236
 
  CompString pname("unityshell");
237
 
  CompSize size(1, 20);
238
 
  _shadow_texture = GLTexture::readImageToTexture(name, pname, size);
239
 
 
240
 
  ubus_manager_.RegisterInterest(UBUS_PLACE_VIEW_SHOWN, [&](GVariant* args) { dash_is_open_ = true; });
241
 
  ubus_manager_.RegisterInterest(UBUS_PLACE_VIEW_HIDDEN, [&](GVariant* args) { dash_is_open_ = false; });
242
 
 
243
 
  EnsureKeybindings();
244
 
 
245
 
  LOG_INFO(logger) << "UnityScreen constructed: " << timer.ElapsedSeconds() << "s";
246
 
}
247
 
 
248
 
UnityScreen::~UnityScreen()
249
 
{
250
 
  panelController->UnReference();
251
 
  delete controller;
252
 
  launcher->UnReference();
253
 
  launcherWindow->UnReference();
254
 
 
255
 
  notify_uninit();
256
 
 
257
 
  unity_a11y_finalize();
258
 
 
259
 
  UBusServer* ubus = ubus_server_get_default();
260
 
  for (unsigned int i = 0; i < G_N_ELEMENTS(_ubus_handles); i++)
261
 
  {
262
 
    if (_ubus_handles[i] != 0)
263
 
      ubus_server_unregister_interest(ubus, _ubus_handles[i]);
264
 
  }
265
 
 
266
 
  if (relayoutSourceId != 0)
267
 
    g_source_remove(relayoutSourceId);
268
 
 
269
 
  // Deleting the windows thread calls XCloseDisplay, which calls XSync, which
270
 
  // sits waiting for a reply.
271
 
  // delete wt;
272
 
 
273
 
  ::unity::ui::IconRenderer::DestroyTextures();
274
 
}
275
 
 
276
 
void UnityScreen::EnsureKeybindings()
277
 
{
278
 
  for (auto action : _shortcut_actions)
279
 
    screen->removeAction(action.get());
280
 
 
281
 
  _shortcut_actions.clear ();
282
 
 
283
 
  for (auto icon : *(launcher->GetModel()))
284
 
  {
285
 
    guint64 shortcut = icon->GetShortcut();
286
 
    if (shortcut == 0)
287
 
      continue;
288
 
 
289
 
    CompActionPtr action(new CompAction());
290
 
 
291
 
    CompAction::KeyBinding binding;
292
 
    std::ostringstream sout;
293
 
    sout << "<Super>" << static_cast<char>(shortcut);
294
 
    binding.fromString(sout.str());
295
 
 
296
 
    action->setKey(binding);
297
 
 
298
 
    screen->addAction(action.get());
299
 
    _shortcut_actions.push_back(action);
300
 
  }
301
 
}
302
 
 
303
 
void UnityScreen::nuxPrologue()
304
 
{
305
 
  /* Vertex lighting isn't used in Unity, we disable that state as it could have
306
 
   * been leaked by another plugin. That should theoretically be switched off
307
 
   * right after PushAttrib since ENABLE_BIT is meant to restore the LIGHTING
308
 
   * bit, but we do that here in order to workaround a bug (?) in the NVIDIA
309
 
   * drivers (lp:703140). */
310
 
  glDisable(GL_LIGHTING);
311
 
 
312
 
  /* reset matrices */
313
 
  glPushAttrib(GL_VIEWPORT_BIT | GL_ENABLE_BIT |
314
 
               GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT | GL_SCISSOR_BIT);
315
 
 
316
 
  glMatrixMode(GL_PROJECTION);
317
 
  glPushMatrix();
318
 
 
319
 
  glMatrixMode(GL_MODELVIEW);
320
 
  glPushMatrix();
321
 
 
322
 
  glGetError();
323
 
}
324
 
 
325
 
void UnityScreen::nuxEpilogue()
326
 
{
327
 
  (*GL::bindFramebuffer)(GL_FRAMEBUFFER_EXT, mActiveFbo);
328
 
 
329
 
  glMatrixMode(GL_PROJECTION);
330
 
  glLoadIdentity();
331
 
  glMatrixMode(GL_MODELVIEW);
332
 
  glLoadIdentity();
333
 
  glDepthRange(0, 1);
334
 
  glViewport(-1, -1, 2, 2);
335
 
  glRasterPos2f(0, 0);
336
 
 
337
 
  gScreen->resetRasterPos();
338
 
 
339
 
  glMatrixMode(GL_PROJECTION);
340
 
  glPopMatrix();
341
 
  glMatrixMode(GL_MODELVIEW);
342
 
  glPopMatrix();
343
 
 
344
 
  glDrawBuffer(GL_BACK);
345
 
  glReadBuffer(GL_BACK);
346
 
 
347
 
  glPopAttrib();
348
 
 
349
 
  glDisable(GL_SCISSOR_TEST);
350
 
}
351
 
 
352
 
void UnityScreen::OnLauncherHiddenChanged()
353
 
{
354
 
  if (launcher->Hidden())
355
 
    screen->addAction(&optionGetLauncherRevealEdge());
356
 
  else
357
 
    screen->removeAction(&optionGetLauncherRevealEdge());
358
 
}
359
 
 
360
 
void UnityScreen::paintPanelShadow(const GLMatrix& matrix)
361
 
{
362
 
  if (relayoutSourceId > 0)
363
 
    return;
364
 
 
365
 
  if (PluginAdapter::Default()->IsExpoActive())
366
 
    return;
367
 
 
368
 
  nuxPrologue();
369
 
 
370
 
  CompOutput* output = _last_output;
371
 
  float vc[4];
372
 
  float h = 20.0f;
373
 
  float w = 1.0f;
374
 
  float panel_h = 24.0f;
375
 
 
376
 
  float x1 = output->x();
377
 
  float y1 = panel_h;
378
 
  float x2 = x1 + output->width();
379
 
  float y2 = y1 + h;
380
 
 
381
 
  vc[0] = x1;
382
 
  vc[1] = x2;
383
 
  vc[2] = y1;
384
 
  vc[3] = y2;
385
 
 
386
 
  if (!dash_is_open_)
387
 
  {
388
 
    foreach(GLTexture * tex, _shadow_texture)
389
 
    {
390
 
      glEnable(GL_BLEND);
391
 
      glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
392
 
 
393
 
      GL::activeTexture(GL_TEXTURE0_ARB);
394
 
      tex->enable(GLTexture::Fast);
395
 
 
396
 
      glTexParameteri(tex->target(), GL_TEXTURE_WRAP_S, GL_REPEAT);
397
 
 
398
 
      glBegin(GL_QUADS);
399
 
      {
400
 
        glTexCoord2f(COMP_TEX_COORD_X(tex->matrix(), 0), COMP_TEX_COORD_Y(tex->matrix(), 0));
401
 
        glVertex2f(vc[0], vc[2]);
402
 
 
403
 
        glTexCoord2f(COMP_TEX_COORD_X(tex->matrix(), 0), COMP_TEX_COORD_Y(tex->matrix(), h));
404
 
        glVertex2f(vc[0], vc[3]);
405
 
 
406
 
        glTexCoord2f(COMP_TEX_COORD_X(tex->matrix(), w), COMP_TEX_COORD_Y(tex->matrix(), h));
407
 
        glVertex2f(vc[1], vc[3]);
408
 
 
409
 
        glTexCoord2f(COMP_TEX_COORD_X(tex->matrix(), w), COMP_TEX_COORD_Y(tex->matrix(), 0));
410
 
        glVertex2f(vc[1], vc[2]);
411
 
      }
412
 
      glEnd();
413
 
 
414
 
      tex->disable();
415
 
      glDisable(GL_BLEND);
416
 
    }
417
 
  }
418
 
  nuxEpilogue();
419
 
}
420
 
 
421
 
void
422
 
UnityWindow::updateIconPos (int   &wx,
423
 
                            int   &wy,
424
 
                            int   x,
425
 
                            int   y,
426
 
                            float width,
427
 
                            float height)
428
 
{
429
 
  wx = x + (last_bound.width - width) / 2;
430
 
  wy = y + (last_bound.height - height) / 2;
431
 
}
432
 
 
433
 
void UnityScreen::paintDisplay(const CompRegion& region, const GLMatrix& transform, unsigned int mask)
434
 
{
435
 
  CompOutput *output = _last_output;
436
 
 
437
 
  mFbos[output]->unbind ();
438
 
 
439
 
  /* Draw the bit of the relevant framebuffer for each output */
440
 
  mFbos[output]->paint ();
441
 
 
442
 
  nuxPrologue();
443
 
  nux::ObjectPtr<nux::IOpenGLTexture2D> device_texture = 
444
 
  nux::GetGraphicsDisplay()->GetGpuDevice()->CreateTexture2DFromID(mFbos[output]->texture(), 
445
 
  output->width(), output->height(), 1, nux::BITFMT_R8G8B8A8);
446
 
 
447
 
  nux::GetGraphicsDisplay()->GetGpuDevice()->backup_texture0_ = device_texture;
448
 
 
449
 
  nux::Geometry geo = nux::Geometry (output->x (), output->y (), output->width (), output->height ());
450
 
 
451
 
  wt->RenderInterfaceFromForeignCmd (&geo);
452
 
  nuxEpilogue();
453
 
 
454
 
if (switcherController->Visible ())
455
 
  {
456
 
    LayoutWindowList targets = switcherController->ExternalRenderTargets ();
457
 
 
458
 
    for (LayoutWindow::Ptr target : targets)
459
 
    {
460
 
      CompWindow* window = screen->findWindow(target->xid);
461
 
      UnityWindow *unity_window = UnityWindow::get (window);
462
 
 
463
 
      unity_window->paintThumbnail (target->result, target->alpha);
464
 
    }
465
 
  }
466
 
 
467
 
  doShellRepaint = false;
468
 
  damaged = false;
469
 
  BackgroundEffectHelper::updates_enabled = true;
470
 
}
471
 
 
472
 
void UnityWindow::paintThumbnail (nux::Geometry const& bounding, float alpha)
473
 
{
474
 
  GLMatrix matrix;
475
 
  matrix.toScreenSpace (UnityScreen::get (screen)->_last_output, -DEFAULT_Z_CAMERA);
476
 
 
477
 
  nux::Geometry geo = bounding;
478
 
  geo.x += 3;
479
 
  geo.width -= 6;
480
 
 
481
 
  geo.y += 3;
482
 
  geo.height -= 6;
483
 
 
484
 
  last_bound = geo;
485
 
 
486
 
  GLWindowPaintAttrib attrib = gWindow->lastPaintAttrib ();
487
 
  attrib.opacity = (GLushort) (alpha * G_MAXUSHORT);
488
 
 
489
 
  paintThumb (attrib,
490
 
              matrix,
491
 
              0,
492
 
              geo.x,
493
 
              geo.y,
494
 
              geo.width,
495
 
              geo.height,
496
 
              geo.width,
497
 
              geo.height);
498
 
}
499
 
 
500
 
/* called whenever we need to repaint parts of the screen */
501
 
bool UnityScreen::glPaintOutput(const GLScreenPaintAttrib& attrib,
502
 
                                const GLMatrix& transform,
503
 
                                const CompRegion& region,
504
 
                                CompOutput* output,
505
 
                                unsigned int mask)
506
 
{
507
 
  bool ret;
508
 
 
509
 
  /* bind the framebuffer here */
510
 
  mFbos[output]->bind ();
511
 
 
512
 
  doShellRepaint = true;
513
 
  allowWindowPaint = true;
514
 
  _last_output = output;
515
 
 
516
 
  /* glPaintOutput is part of the opengl plugin, so we need the GLScreen base class. */
517
 
  ret = gScreen->glPaintOutput(attrib, transform, region, output, mask);
518
 
 
519
 
  if (doShellRepaint)
520
 
    paintDisplay(region, transform, mask);
521
 
 
522
 
  return ret;
523
 
}
524
 
 
525
 
/* called whenever a plugin needs to paint the entire scene
526
 
 * transformed */
527
 
 
528
 
void UnityScreen::glPaintTransformedOutput(const GLScreenPaintAttrib& attrib,
529
 
                                           const GLMatrix& transform,
530
 
                                           const CompRegion& region,
531
 
                                           CompOutput* output,
532
 
                                           unsigned int mask)
533
 
{
534
 
  /* bind the framebuffer here */
535
 
  mFbos[output]->bind ();
536
 
  allowWindowPaint = false;
537
 
  /* urgh */
538
 
  gScreen->glPaintOutput(attrib, transform, region, output, mask);
539
 
}
540
 
 
541
 
void UnityScreen::preparePaint(int ms)
542
 
{
543
 
  if (BackgroundEffectHelper::blur_type == unity::BLUR_ACTIVE)
544
 
  {
545
 
    // this causes queue draws to be called, we obviously dont want to disable updates
546
 
    // because we are updating the blur, so ignore them.
547
 
    bool tmp = BackgroundEffectHelper::updates_enabled;
548
 
    BackgroundEffectHelper::QueueDrawOnOwners();
549
 
    BackgroundEffectHelper::updates_enabled = tmp;
550
 
  }
551
 
 
552
 
  cScreen->preparePaint(ms);
553
 
 
554
 
  if (damaged)
555
 
  {
556
 
    damaged = false;
557
 
    damageNuxRegions();
558
 
  }
559
 
 
560
 
}
561
 
 
562
 
/* Grab changed nux regions and add damage rects for them */
563
 
void UnityScreen::damageNuxRegions()
564
 
{
565
 
  if (damaged)
566
 
    return;
567
 
 
568
 
  std::vector<nux::Geometry> dirty = wt->GetDrawList();
569
 
  damaged = true;
570
 
 
571
 
  for (std::vector<nux::Geometry>::iterator it = dirty.begin(), end = dirty.end();
572
 
       it != end; ++it)
573
 
  {
574
 
    nux::Geometry const& geo = *it;
575
 
    cScreen->damageRegion(CompRegion(geo.x, geo.y, geo.width, geo.height));
576
 
  }
577
 
 
578
 
  nux::Geometry geo = wt->GetWindowCompositor().GetTooltipMainWindowGeometry();
579
 
  cScreen->damageRegion(CompRegion(geo.x, geo.y, geo.width, geo.height));
580
 
  cScreen->damageRegion(CompRegion(lastTooltipArea.x, lastTooltipArea.y,
581
 
                                   lastTooltipArea.width, lastTooltipArea.height));
582
 
 
583
 
  lastTooltipArea = geo;
584
 
 
585
 
  wt->ClearDrawList();
586
 
}
587
 
 
588
 
/* handle X Events */
589
 
void UnityScreen::handleEvent(XEvent* event)
590
 
{
591
 
  bool skip_other_plugins = false;
592
 
 
593
 
  switch (event->type)
594
 
  {
595
 
    case FocusIn:
596
 
    case FocusOut:
597
 
      if (event->xfocus.mode == NotifyGrab)
598
 
        PluginAdapter::Default()->OnScreenGrabbed();
599
 
      else if (event->xfocus.mode == NotifyUngrab)
600
 
        PluginAdapter::Default()->OnScreenUngrabbed();
601
 
      cScreen->damageScreen();  // evil hack
602
 
      if (_key_nav_mode_requested)
603
 
        launcher->startKeyNavMode();
604
 
      _key_nav_mode_requested = false;
605
 
      break;
606
 
    case KeyPress:
607
 
      KeySym key_sym;
608
 
      char key_string[2];
609
 
      int result;
610
 
      if ((result = XLookupString(&(event->xkey), key_string, 2, &key_sym, 0)) > 0)
611
 
      {
612
 
        key_string[result] = 0;
613
 
        skip_other_plugins = launcher->CheckSuperShortcutPressed(key_sym, event->xkey.keycode, event->xkey.state, key_string);
614
 
      }
615
 
      break;
616
 
  }
617
 
 
618
 
  // avoid further propagation (key conflict for instance)
619
 
  if (!skip_other_plugins)
620
 
    screen->handleEvent(event);
621
 
 
622
 
  if (!skip_other_plugins && screen->otherGrabExist("deco", "move", "switcher", "resize", NULL))
623
 
  {
624
 
    wt->ProcessForeignEvent(event, NULL);
625
 
  }
626
 
}
627
 
 
628
 
void UnityScreen::handleCompizEvent(const char* plugin,
629
 
                                    const char* event,
630
 
                                    CompOption::Vector& option)
631
 
{
632
 
  /*
633
 
   *  don't take into account window over launcher state during
634
 
   *  the ws switch as we can get false positives
635
 
   *  (like switching to an empty viewport while grabbing a fullscreen window)
636
 
   */
637
 
  if (strcmp(event, "start_viewport_switch") == 0)
638
 
    launcher->EnableCheckWindowOverLauncher(false);
639
 
  else if (strcmp(event, "end_viewport_switch") == 0)
640
 
  {
641
 
    // compute again the list of all window on the new viewport
642
 
    // to decide if we should or not hide the launcher
643
 
    launcher->EnableCheckWindowOverLauncher(true);
644
 
    launcher->CheckWindowOverLauncher();
645
 
  }
646
 
  screen->handleCompizEvent(plugin, event, option);
647
 
}
648
 
 
649
 
bool UnityScreen::showLauncherKeyInitiate(CompAction* action,
650
 
                                          CompAction::State state,
651
 
                                          CompOption::Vector& options)
652
 
{
653
 
  // to receive the Terminate event
654
 
  if (state & CompAction::StateInitKey)
655
 
    action->setState(action->state() | CompAction::StateTermKey);
656
 
 
657
 
  launcher->StartKeyShowLauncher();
658
 
  EnsureKeybindings ();
659
 
  return false;
660
 
}
661
 
 
662
 
bool UnityScreen::showLauncherKeyTerminate(CompAction* action,
663
 
                                           CompAction::State state,
664
 
                                           CompOption::Vector& options)
665
 
{
666
 
  launcher->EndKeyShowLauncher();
667
 
  return false;
668
 
}
669
 
 
670
 
bool UnityScreen::showPanelFirstMenuKeyInitiate(CompAction* action,
671
 
                                                CompAction::State state,
672
 
                                                CompOption::Vector& options)
673
 
{
674
 
  // to receive the Terminate event
675
 
  if (state & CompAction::StateInitKey)
676
 
    action->setState(action->state() | CompAction::StateTermKey);
677
 
 
678
 
  panelController->StartFirstMenuShow();
679
 
  return false;
680
 
}
681
 
 
682
 
bool UnityScreen::showPanelFirstMenuKeyTerminate(CompAction* action,
683
 
                                                 CompAction::State state,
684
 
                                                 CompOption::Vector& options)
685
 
{
686
 
  panelController->EndFirstMenuShow();
687
 
  return false;
688
 
}
689
 
 
690
 
gboolean UnityScreen::OnEdgeTriggerTimeout(gpointer data)
691
 
{
692
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(data);
693
 
 
694
 
  if (pointerX == 0)
695
 
  {
696
 
    if (abs(pointerY-self->_edge_pointerY) <= 5)
697
 
    {
698
 
      self->launcher->EdgeRevealTriggered();
699
 
    }
700
 
    else
701
 
    {
702
 
      /* We are still in the edge, but moving in Y, maybe we need another chance */
703
 
 
704
 
      if (abs(pointerY-self->_edge_pointerY) > 20)
705
 
      {
706
 
        /* We're quite far from the first hit spot, let's wait again */
707
 
        self->_edge_pointerY = pointerY;
708
 
        return true;
709
 
      }
710
 
      else
711
 
      {
712
 
        /* We're quite near to the first hit spot, so we can reduce our timeout */
713
 
        self->_edge_pointerY = pointerY;
714
 
        g_source_remove(self->_edge_trigger_handle);
715
 
        self->_edge_trigger_handle = g_timeout_add(self->_edge_timeout/2,
716
 
                                                   &UnityScreen::OnEdgeTriggerTimeout,
717
 
                                                   self);
718
 
        return false;
719
 
      }
720
 
    }
721
 
  }
722
 
 
723
 
  self->_edge_trigger_handle = 0;
724
 
  return false;
725
 
}
726
 
 
727
 
bool UnityScreen::launcherRevealEdgeInitiate(CompAction* action,
728
 
                                             CompAction::State state,
729
 
                                             CompOption::Vector& options)
730
 
{
731
 
  if (screen->grabbed())
732
 
    return false;
733
 
 
734
 
  if (_edge_trigger_handle)
735
 
    g_source_remove(_edge_trigger_handle);
736
 
 
737
 
  if (pointerX == 0)
738
 
  {
739
 
    _edge_pointerY = pointerY;
740
 
    _edge_trigger_handle = g_timeout_add(_edge_timeout,
741
 
                                         &UnityScreen::OnEdgeTriggerTimeout,
742
 
                                         this);
743
 
  }
744
 
 
745
 
  return false;
746
 
}
747
 
 
748
 
void UnityScreen::SendExecuteCommand()
749
 
{
750
 
  ubus_server_send_message(ubus_server_get_default(),
751
 
                           UBUS_PLACE_ENTRY_ACTIVATE_REQUEST,
752
 
                           g_variant_new("(sus)",
753
 
                                         "commands.lens",
754
 
                                         0,
755
 
                                         ""));
756
 
}
757
 
 
758
 
bool UnityScreen::executeCommand(CompAction* action,
759
 
                                 CompAction::State state,
760
 
                                 CompOption::Vector& options)
761
 
{
762
 
  SendExecuteCommand();
763
 
  return false;
764
 
}
765
 
 
766
 
void UnityScreen::restartLauncherKeyNav()
767
 
{
768
 
  // set input-focus on launcher-window and start key-nav mode
769
 
  if (newFocusedWindow != NULL)
770
 
  {
771
 
    newFocusedWindow->moveInputFocusTo();
772
 
    launcher->startKeyNavMode();
773
 
  }
774
 
}
775
 
 
776
 
void UnityScreen::startLauncherKeyNav()
777
 
{
778
 
  // get CompWindow* of launcher-window
779
 
  newFocusedWindow = screen->findWindow(launcherWindow->GetInputWindowId());
780
 
 
781
 
  // check if currently focused window isn't the launcher-window
782
 
  if (newFocusedWindow != screen->findWindow(screen->activeWindow()))
783
 
    lastFocusedWindow = screen->findWindow(screen->activeWindow());
784
 
 
785
 
  // set input-focus on launcher-window and start key-nav mode
786
 
  if (newFocusedWindow != NULL)
787
 
  {
788
 
    // Put the launcher BaseWindow at the top of the BaseWindow stack. The
789
 
    // input focus coming from the XinputWindow will be processed by the
790
 
    // launcher BaseWindow only. Then the Launcher BaseWindow will decide
791
 
    // which View will get the input focus.
792
 
    launcherWindow->PushToFront();
793
 
    newFocusedWindow->moveInputFocusTo();
794
 
  }
795
 
}
796
 
 
797
 
bool UnityScreen::setKeyboardFocusKeyInitiate(CompAction* action,
798
 
                                              CompAction::State state,
799
 
                                              CompOption::Vector& options)
800
 
{
801
 
  _key_nav_mode_requested = true;
802
 
  return false;
803
 
}
804
 
 
805
 
bool UnityScreen::altTabForwardInitiate(CompAction* action,
806
 
                                        CompAction::State state,
807
 
                                        CompOption::Vector& options)
808
 
{
809
 
  if (switcherController->Visible())
810
 
  {
811
 
    switcherController->Next();
812
 
  }
813
 
  else
814
 
  {
815
 
    std::vector<AbstractLauncherIcon*> results;
816
 
 
817
 
    if (!switcher_desktop_icon)
818
 
    {
819
 
      switcher_desktop_icon = new DesktopLauncherIcon(launcher);
820
 
      switcher_desktop_icon->SinkReference();
821
 
    }
822
 
 
823
 
    results.push_back(switcher_desktop_icon);
824
 
 
825
 
    LauncherModel::iterator it;
826
 
    for (it = launcher->GetModel()->begin(); it != launcher->GetModel()->end(); it++)
827
 
      if ((*it)->ShowInSwitcher())
828
 
        results.push_back(*it);
829
 
 
830
 
    // maybe check launcher position/hide state?
831
 
    switcherController->SetWorkspace(nux::Geometry(_primary_monitor.x + 100,
832
 
                                                   _primary_monitor.y + 100,
833
 
                                                   _primary_monitor.width - 200,
834
 
                                                   _primary_monitor.height - 200));
835
 
    switcherController->Show(SwitcherController::ALL, SwitcherController::FOCUS_ORDER, false, results);
836
 
  }
837
 
 
838
 
  action->setState(action->state() | CompAction::StateTermKey);
839
 
  return false;
840
 
}
841
 
 
842
 
bool UnityScreen::altTabForwardTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
843
 
{
844
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
845
 
  bool accept_state = (state & CompAction::StateCancel) == 0;
846
 
  switcherController->Hide(accept_state);
847
 
  return false;
848
 
}
849
 
 
850
 
bool UnityScreen::altTabPrevInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
851
 
{
852
 
  if (switcherController->Visible())
853
 
    switcherController->Prev();
854
 
 
855
 
  action->setState(action->state() | CompAction::StateTermKey);
856
 
  return false;
857
 
}
858
 
 
859
 
bool UnityScreen::altTabPrevTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
860
 
{
861
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
862
 
  return false;
863
 
}
864
 
 
865
 
bool UnityScreen::altTabDetailStartInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
866
 
{
867
 
  if (switcherController->Visible())
868
 
    switcherController->SetDetail(true);
869
 
 
870
 
  action->setState(action->state() | CompAction::StateTermKey);
871
 
  return false;
872
 
}
873
 
 
874
 
bool UnityScreen::altTabDetailStartTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
875
 
{
876
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
877
 
  return false;
878
 
}
879
 
 
880
 
bool UnityScreen::altTabDetailStopInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
881
 
{
882
 
  if (switcherController->Visible())
883
 
    switcherController->SetDetail(false);
884
 
 
885
 
  action->setState(action->state() | CompAction::StateTermKey);
886
 
  return false;
887
 
}
888
 
 
889
 
bool UnityScreen::altTabDetailStopTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
890
 
{
891
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
892
 
  return false;
893
 
}
894
 
 
895
 
bool UnityScreen::altTabNextWindowInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
896
 
{
897
 
  if (switcherController->Visible())
898
 
    switcherController->NextDetail();
899
 
 
900
 
  action->setState(action->state() | CompAction::StateTermKey);
901
 
  return false;
902
 
}
903
 
 
904
 
bool UnityScreen::altTabNextWindowTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
905
 
{
906
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
907
 
  return false;
908
 
}
909
 
 
910
 
bool UnityScreen::altTabExitInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
911
 
{
912
 
  switcherController->Hide(false);
913
 
  action->setState(action->state() | CompAction::StateTermKey);
914
 
  return false;
915
 
}
916
 
 
917
 
bool UnityScreen::altTabExitTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
918
 
{
919
 
  action->setState(action->state() & (unsigned)~(CompAction::StateTermKey));
920
 
  return false;
921
 
}
922
 
 
923
 
void UnityScreen::OnLauncherStartKeyNav(GVariant* data, void* value)
924
 
{
925
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(value);
926
 
  self->startLauncherKeyNav();
927
 
}
928
 
 
929
 
void UnityScreen::OnLauncherEndKeyNav(GVariant* data, void* value)
930
 
{
931
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(value);
932
 
  bool preserve_focus = false;
933
 
 
934
 
  if (data)
935
 
  {
936
 
    preserve_focus = g_variant_get_boolean(data);
937
 
  }
938
 
 
939
 
  // Return input-focus to previously focused window (before key-nav-mode was
940
 
  // entered)
941
 
  if (preserve_focus && (self->lastFocusedWindow != NULL))
942
 
  {
943
 
    self->lastFocusedWindow->moveInputFocusTo();
944
 
  }
945
 
}
946
 
 
947
 
void UnityScreen::OnQuicklistEndKeyNav(GVariant* data, void* value)
948
 
{
949
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(value);
950
 
  self->restartLauncherKeyNav();
951
 
}
952
 
 
953
 
gboolean UnityScreen::initPluginActions(gpointer data)
954
 
{
955
 
  CompPlugin* p = CompPlugin::find("expo");
956
 
 
957
 
  if (p)
958
 
  {
959
 
    MultiActionList expoActions(0);
960
 
 
961
 
    foreach(CompOption & option, p->vTable->getOptions())
962
 
    {
963
 
      if (option.name() == "expo_key" ||
964
 
          option.name() == "expo_button" ||
965
 
          option.name() == "expo_edge")
966
 
      {
967
 
        CompAction* action = &option.value().action();
968
 
        expoActions.AddNewAction(action, false);
969
 
        break;
970
 
      }
971
 
    }
972
 
 
973
 
    PluginAdapter::Default()->SetExpoAction(expoActions);
974
 
  }
975
 
 
976
 
  p = CompPlugin::find("scale");
977
 
 
978
 
  if (p)
979
 
  {
980
 
    MultiActionList scaleActions(0);
981
 
 
982
 
    foreach(CompOption & option, p->vTable->getOptions())
983
 
    {
984
 
      if (option.name() == "initiate_all_key" ||
985
 
          option.name() == "initiate_all_edge" ||
986
 
          option.name() == "initiate_key" ||
987
 
          option.name() == "initiate_button" ||
988
 
          option.name() == "initiate_edge" ||
989
 
          option.name() == "initiate_group_key" ||
990
 
          option.name() == "initiate_group_button" ||
991
 
          option.name() == "initiate_group_edge" ||
992
 
          option.name() == "initiate_output_key" ||
993
 
          option.name() == "initiate_output_button" ||
994
 
          option.name() == "initiate_output_edge")
995
 
      {
996
 
        CompAction* action = &option.value().action();
997
 
        scaleActions.AddNewAction(action, false);
998
 
      }
999
 
      else if (option.name() == "initiate_all_button")
1000
 
      {
1001
 
        CompAction* action = &option.value().action();
1002
 
        scaleActions.AddNewAction(action, true);
1003
 
      }
1004
 
    }
1005
 
 
1006
 
    PluginAdapter::Default()->SetScaleAction(scaleActions);
1007
 
  }
1008
 
 
1009
 
  p = CompPlugin::find("unitymtgrabhandles");
1010
 
 
1011
 
  if (p)
1012
 
  {
1013
 
    foreach(CompOption & option, p->vTable->getOptions())
1014
 
    {
1015
 
      if (option.name() == "show_handles_key")
1016
 
        PluginAdapter::Default()->SetShowHandlesAction(&option.value().action());
1017
 
      else if (option.name() == "hide_handles_key")
1018
 
        PluginAdapter::Default()->SetHideHandlesAction(&option.value().action());
1019
 
      else if (option.name() == "toggle_handles_key")
1020
 
        PluginAdapter::Default()->SetToggleHandlesAction(&option.value().action());
1021
 
    }
1022
 
  }
1023
 
 
1024
 
  return FALSE;
1025
 
}
1026
 
 
1027
 
/* Set up expo and scale actions on the launcher */
1028
 
bool UnityScreen::initPluginForScreen(CompPlugin* p)
1029
 
{
1030
 
  if (p->vTable->name() == "expo" ||
1031
 
      p->vTable->name() == "scale")
1032
 
  {
1033
 
    initPluginActions(this);
1034
 
  }
1035
 
 
1036
 
  return screen->initPluginForScreen(p);
1037
 
}
1038
 
 
1039
 
void UnityScreen::AddProperties(GVariantBuilder* builder)
1040
 
{
1041
 
}
1042
 
 
1043
 
const gchar* UnityScreen::GetName()
1044
 
{
1045
 
  return "Unity";
1046
 
}
1047
 
 
1048
 
const CompWindowList& UnityScreen::getWindowPaintList()
1049
 
{
1050
 
  CompWindowList& pl = _withRemovedNuxWindows = cScreen->getWindowPaintList();
1051
 
  CompWindowList::reverse_iterator it = pl.rbegin();
1052
 
  CompWindowList::reverse_iterator end = pl.rend();
1053
 
  std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
1054
 
 
1055
 
  unsigned int size = xwns.size();
1056
 
 
1057
 
  while (it != end)
1058
 
  {
1059
 
    bool erased = false;
1060
 
    auto id = (*it)->id();
1061
 
    for (unsigned int i = 0; i < size; ++i)
1062
 
    {
1063
 
      if (xwns[i] == id)
1064
 
      {
1065
 
        /* Increment the reverse_iterator to ensure
1066
 
               * it is valid, then it++ returns the old
1067
 
         * position */
1068
 
        CompWindowList::reverse_iterator oit = it++;
1069
 
        /* Get the base and offset by -1 since
1070
 
         * &*(reverse_iterator(i)) == &*(i - 1)) */
1071
 
        CompWindowList::iterator eit = --(oit.base ());
1072
 
 
1073
 
        erased = true;
1074
 
 
1075
 
        /* Remove that from the list */
1076
 
        pl.erase(eit);
1077
 
        break;
1078
 
      }
1079
 
    }
1080
 
 
1081
 
    if (!erased)
1082
 
      it++;
1083
 
  }
1084
 
 
1085
 
  return pl;
1086
 
}
1087
 
 
1088
 
/* handle window painting in an opengl context
1089
 
 *
1090
 
 * we want to paint underneath other windows here,
1091
 
 * so we need to find if this window is actually
1092
 
 * stacked on top of one of the nux input windows
1093
 
 * and if so paint nux and stop us from painting
1094
 
 * other windows or on top of the whole screen */
1095
 
bool UnityWindow::glDraw(const GLMatrix& matrix,
1096
 
                         GLFragment::Attrib& attrib,
1097
 
                         const CompRegion& region,
1098
 
                         unsigned int mask)
1099
 
{
1100
 
  if (uScreen->doShellRepaint && uScreen->allowWindowPaint)
1101
 
  {
1102
 
    std::vector<Window> const& xwns = nux::XInputWindow::NativeHandleList();
1103
 
    unsigned int size = xwns.size();
1104
 
 
1105
 
    for (CompWindow* w = window; w && uScreen->doShellRepaint; w = w->prev)
1106
 
    {
1107
 
      auto id = w->id();
1108
 
      for (unsigned int i = 0; i < size; ++i)
1109
 
      {
1110
 
        if (xwns[i] == id)
1111
 
        {
1112
 
          uScreen->paintDisplay(region, matrix, mask);
1113
 
          break;
1114
 
        }
1115
 
      }
1116
 
    }
1117
 
  }
1118
 
 
1119
 
  bool ret = gWindow->glDraw(matrix, attrib, region, mask);
1120
 
 
1121
 
  if (window->type() == CompWindowTypeDesktopMask)
1122
 
  {
1123
 
    uScreen->paintPanelShadow(matrix);
1124
 
  }
1125
 
 
1126
 
  return ret;
1127
 
}
1128
 
 
1129
 
/* Called whenever a window is mapped, unmapped, minimized etc */
1130
 
void UnityWindow::windowNotify(CompWindowNotify n)
1131
 
{
1132
 
  PluginAdapter::Default()->Notify(window, n);
1133
 
  window->windowNotify(n);
1134
 
}
1135
 
 
1136
 
void UnityWindow::stateChangeNotify(unsigned int lastState)
1137
 
{
1138
 
  PluginAdapter::Default()->NotifyStateChange(window, window->state(), lastState);
1139
 
  window->stateChangeNotify(lastState);
1140
 
}
1141
 
 
1142
 
void UnityWindow::moveNotify(int x, int y, bool immediate)
1143
 
{
1144
 
  PluginAdapter::Default()->NotifyMoved(window, x, y);
1145
 
  window->moveNotify(x, y, immediate);
1146
 
}
1147
 
 
1148
 
void UnityWindow::resizeNotify(int x, int y, int w, int h)
1149
 
{
1150
 
  PluginAdapter::Default()->NotifyResized(window, x, y, w, h);
1151
 
  window->resizeNotify(x, y, w, h);
1152
 
}
1153
 
 
1154
 
CompPoint UnityWindow::tryNotIntersectLauncher(CompPoint& pos)
1155
 
{
1156
 
  UnityScreen* us = UnityScreen::get(screen);
1157
 
  nux::Geometry geo = us->launcher->GetAbsoluteGeometry();
1158
 
  CompRect launcherGeo(geo.x, geo.y, geo.width, geo.height);
1159
 
 
1160
 
  if (launcherGeo.contains(pos))
1161
 
  {
1162
 
    if (screen->workArea().contains(CompRect(launcherGeo.right() + 1, pos.y(), window->width(), window->height())))
1163
 
      pos.setX(launcherGeo.right() + 1);
1164
 
  }
1165
 
 
1166
 
  return pos;
1167
 
}
1168
 
 
1169
 
bool UnityWindow::place(CompPoint& pos)
1170
 
{
1171
 
  UnityScreen* us = UnityScreen::get(screen);
1172
 
  Launcher::LauncherHideMode hideMode = us->launcher->GetHideMode();
1173
 
 
1174
 
  bool result = window->place(pos);
1175
 
 
1176
 
  switch (hideMode)
1177
 
  {
1178
 
    case Launcher::LAUNCHER_HIDE_DODGE_WINDOWS:
1179
 
    case Launcher::LAUNCHER_HIDE_DODGE_ACTIVE_WINDOW:
1180
 
      pos = tryNotIntersectLauncher(pos);
1181
 
      break;
1182
 
 
1183
 
    default:
1184
 
      break;
1185
 
  }
1186
 
 
1187
 
  return result;
1188
 
}
1189
 
 
1190
 
/* Configure callback for the launcher window */
1191
 
void UnityScreen::launcherWindowConfigureCallback(int WindowWidth, int WindowHeight,
1192
 
                                                  nux::Geometry& geo, void* user_data)
1193
 
{
1194
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(user_data);
1195
 
  geo = nux::Geometry(self->_primary_monitor.x, self->_primary_monitor.y + 24,
1196
 
                      geo.width, self->_primary_monitor.height - 24);
1197
 
}
1198
 
 
1199
 
/* Start up nux after OpenGL is initialized */
1200
 
void UnityScreen::initUnity(nux::NThread* thread, void* InitData)
1201
 
{
1202
 
  Timer timer;
1203
 
  initLauncher(thread, InitData);
1204
 
 
1205
 
  nux::ColorLayer background(nux::color::Transparent);
1206
 
  static_cast<nux::WindowThread*>(thread)->SetWindowBackgroundPaintLayer(&background);
1207
 
  LOG_INFO(logger) << "UnityScreen::initUnity: " << timer.ElapsedSeconds() << "s";
1208
 
}
1209
 
 
1210
 
void UnityScreen::onRedrawRequested()
1211
 
{
1212
 
  // disable blur updates so we dont waste perf. This can stall the blur during animations
1213
 
  // but ensures a smooth animation.
1214
 
  BackgroundEffectHelper::updates_enabled = false;
1215
 
  damageNuxRegions();
1216
 
}
1217
 
 
1218
 
/* Handle option changes and plug that into nux windows */
1219
 
void UnityScreen::optionChanged(CompOption* opt, UnityshellOptions::Options num)
1220
 
{
1221
 
  switch (num)
1222
 
  {
1223
 
    case UnityshellOptions::LauncherHideMode:
1224
 
      launcher->SetHideMode((Launcher::LauncherHideMode) optionGetLauncherHideMode());
1225
 
      break;
1226
 
    case UnityshellOptions::BacklightMode:
1227
 
      launcher->SetBacklightMode((Launcher::BacklightMode) optionGetBacklightMode());
1228
 
      break;
1229
 
    case UnityshellOptions::LaunchAnimation:
1230
 
      launcher->SetLaunchAnimation((Launcher::LaunchAnimation) optionGetLaunchAnimation());
1231
 
      break;
1232
 
    case UnityshellOptions::UrgentAnimation:
1233
 
      launcher->SetUrgentAnimation((Launcher::UrgentAnimation) optionGetUrgentAnimation());
1234
 
      break;
1235
 
    case UnityshellOptions::PanelOpacity:
1236
 
      panelController->SetOpacity(optionGetPanelOpacity());
1237
 
      break;
1238
 
    case UnityshellOptions::LauncherOpacity:
1239
 
      launcher->SetBackgroundAlpha(optionGetLauncherOpacity());
1240
 
      break;
1241
 
    case UnityshellOptions::IconSize:
1242
 
      panelController->SetBFBSize(optionGetIconSize() + 18);
1243
 
      launcher->SetIconSize(optionGetIconSize() + 6, optionGetIconSize());
1244
 
      dashController->launcher_width = optionGetIconSize() + 18;
1245
 
      break;
1246
 
    case UnityshellOptions::AutohideAnimation:
1247
 
      launcher->SetAutoHideAnimation((Launcher::AutoHideAnimation) optionGetAutohideAnimation());
1248
 
      break;
1249
 
    case UnityshellOptions::DashBlurExperimental:
1250
 
      BackgroundEffectHelper::blur_type = (unity::BlurType)optionGetDashBlurExperimental();
1251
 
      break;
1252
 
    case UnityshellOptions::AutomaximizeValue:
1253
 
      PluginAdapter::Default()->SetCoverageAreaBeforeAutomaximize(optionGetAutomaximizeValue() / 100.0f);
1254
 
      break;
1255
 
    case UnityshellOptions::DevicesOption:
1256
 
      unity::DevicesSettings::GetDefault().SetDevicesOption((unity::DevicesSettings::DevicesOption) optionGetDevicesOption());
1257
 
      break;
1258
 
    case UnityshellOptions::LauncherRevealEdgeTimeout:
1259
 
      _edge_timeout = optionGetLauncherRevealEdgeTimeout();
1260
 
      break;
1261
 
    case UnityshellOptions::AltTabTimeout:
1262
 
      switcherController->detail_on_timeout = optionGetAltTabTimeout();
1263
 
      break;
1264
 
    default:
1265
 
      break;
1266
 
  }
1267
 
}
1268
 
 
1269
 
void UnityScreen::NeedsRelayout()
1270
 
{
1271
 
  needsRelayout = true;
1272
 
}
1273
 
 
1274
 
void UnityScreen::ScheduleRelayout(guint timeout)
1275
 
{
1276
 
  if (relayoutSourceId == 0)
1277
 
    relayoutSourceId = g_timeout_add(timeout, &UnityScreen::RelayoutTimeout, this);
1278
 
}
1279
 
 
1280
 
void UnityScreen::Relayout()
1281
 
{
1282
 
  GdkScreen* scr;
1283
 
  GdkRectangle rect;
1284
 
  nux::Geometry lCurGeom;
1285
 
  gint primary_monitor;
1286
 
  int panel_height = 24;
1287
 
 
1288
 
  if (!needsRelayout)
1289
 
    return;
1290
 
 
1291
 
  if (GL::fbo)
1292
 
  {
1293
 
    foreach (CompOutput &o, screen->outputDevs ())
1294
 
      uScreen->mFbos[&o] = UnityFBO::Ptr (new UnityFBO (&o));
1295
 
    
1296
 
    uScreen->mFbos[&(screen->fullscreenOutput ())] = UnityFBO::Ptr (new UnityFBO (&(screen->fullscreenOutput ())));
1297
 
  }
1298
 
 
1299
 
  scr = gdk_screen_get_default ();
1300
 
  primary_monitor = gdk_screen_get_primary_monitor (scr);
1301
 
  gdk_screen_get_monitor_geometry (scr, primary_monitor, &rect);
1302
 
  _primary_monitor = rect;
1303
 
 
1304
 
  wt->SetWindowSize(rect.width, rect.height);
1305
 
 
1306
 
  lCurGeom = launcherWindow->GetGeometry();
1307
 
  launcher->SetMaximumHeight(rect.height - panel_height);
1308
 
 
1309
 
  g_debug("Setting to primary screen rect: x=%d y=%d w=%d h=%d",
1310
 
          rect.x,
1311
 
          rect.y,
1312
 
          rect.width,
1313
 
          rect.height);
1314
 
 
1315
 
  launcherWindow->SetGeometry(nux::Geometry(rect.x,
1316
 
                                            rect.y + panel_height,
1317
 
                                            lCurGeom.width,
1318
 
                                            rect.height - panel_height));
1319
 
  launcher->SetGeometry(nux::Geometry(rect.x,
1320
 
                                      rect.y + panel_height,
1321
 
                                      lCurGeom.width,
1322
 
                                      rect.height - panel_height));
1323
 
  needsRelayout = false;
1324
 
}
1325
 
 
1326
 
gboolean UnityScreen::RelayoutTimeout(gpointer data)
1327
 
{
1328
 
  UnityScreen* uScr = reinterpret_cast<UnityScreen*>(data);
1329
 
 
1330
 
  uScreen->mFbos.clear ();
1331
 
 
1332
 
  uScr->NeedsRelayout ();
1333
 
  uScr->Relayout();
1334
 
  uScr->relayoutSourceId = 0;
1335
 
 
1336
 
  uScr->cScreen->damageScreen();
1337
 
 
1338
 
  return FALSE;
1339
 
}
1340
 
 
1341
 
/* Handle changes in the number of workspaces by showing the switcher
1342
 
 * or not showing the switcher */
1343
 
bool UnityScreen::setOptionForPlugin(const char* plugin, const char* name,
1344
 
                                     CompOption::Value& v)
1345
 
{
1346
 
  bool status = screen->setOptionForPlugin(plugin, name, v);
1347
 
  if (status)
1348
 
  {
1349
 
    if (strcmp(plugin, "core") == 0 && strcmp(name, "hsize") == 0)
1350
 
    {
1351
 
      controller->UpdateNumWorkspaces(screen->vpSize().width() * screen->vpSize().height());
1352
 
    }
1353
 
  }
1354
 
  return status;
1355
 
}
1356
 
 
1357
 
void UnityScreen::outputChangeNotify()
1358
 
{
1359
 
  ScheduleRelayout(500);
1360
 
}
1361
 
 
1362
 
void UnityFBO::paint ()
1363
 
{
1364
 
  //CompositeScreen *cScreen = CompositeScreen::get (screen);
1365
 
  //unsigned int    mask = cScreen->damageMask ();
1366
 
  float texx, texy, texwidth, texheight;
1367
 
 
1368
 
  /* Draw the bit of the relevant framebuffer for each output */
1369
 
  GLMatrix transform;
1370
 
 
1371
 
  glViewport (output->x (), screen->height () - output->y2 (), output->width (), output->height ());
1372
 
 
1373
 
  transform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
1374
 
  glPushMatrix ();
1375
 
  glLoadMatrixf (transform.getMatrix ());
1376
 
 
1377
 
  /* Note that texcoords here are normalized, so it's just (0,0)-(1,1) */
1378
 
  texx = 0.0;
1379
 
  texy = 0.0;
1380
 
  texwidth = 1.0f;
1381
 
  texheight = 1.0f;
1382
 
 
1383
 
  if (mFBTexture)
1384
 
  {
1385
 
    glEnable (GL_TEXTURE_2D);
1386
 
    GL::activeTexture (GL_TEXTURE0_ARB);
1387
 
    glBindTexture (GL_TEXTURE_2D, mFBTexture);
1388
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1389
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1390
 
    
1391
 
    glPushAttrib (GL_SCISSOR_BIT);
1392
 
    glEnable (GL_SCISSOR_TEST);
1393
 
 
1394
 
    glScissor (output->x1 (), screen->height () - output->y2 (),
1395
 
                output->width (), output->height ());
1396
 
    
1397
 
    /* FIXME: This needs to be GL_TRIANGLE_STRIP */
1398
 
    glBegin (GL_QUADS);
1399
 
    glTexCoord2f (texx, texy + texheight);
1400
 
    glVertex2i   (output->x1 (), output->y1 ());
1401
 
    glTexCoord2f (texx, texy);
1402
 
    glVertex2i   (output->x1 (),        output->y2 ());
1403
 
    glTexCoord2f (texx + texwidth, texy);
1404
 
    glVertex2i   (output->x2 (), output->y2 ());
1405
 
    glTexCoord2f (texx + texwidth, texy + texheight);
1406
 
    glVertex2i   (output->x2 (),        output->y1 ());
1407
 
    glEnd ();
1408
 
    
1409
 
    GL::activeTexture (GL_TEXTURE0_ARB);
1410
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1411
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1412
 
    glBindTexture (GL_TEXTURE_2D, 0);
1413
 
    glEnable (GL_TEXTURE_2D);
1414
 
    
1415
 
    glDisable (GL_SCISSOR_TEST);
1416
 
    glPopAttrib ();
1417
 
  }
1418
 
 
1419
 
  glPopMatrix();
1420
 
}
1421
 
 
1422
 
void UnityFBO::unbind ()
1423
 
{
1424
 
  uScreen->setActiveFbo (0);
1425
 
  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, 0);
1426
 
 
1427
 
  glDrawBuffer (GL_BACK);
1428
 
  glReadBuffer (GL_BACK);
1429
 
 
1430
 
}
1431
 
 
1432
 
bool UnityFBO::status ()
1433
 
{
1434
 
  return mFboStatus;
1435
 
}
1436
 
 
1437
 
void UnityFBO::bind ()
1438
 
{
1439
 
  if (!mFBTexture)
1440
 
  {
1441
 
    glGenTextures (1, &mFBTexture);
1442
 
 
1443
 
    glBindTexture (GL_TEXTURE_2D, mFBTexture);
1444
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1445
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1446
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1447
 
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1448
 
    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, output->width (), output->height (), 0, GL_BGRA,
1449
 
#if IMAGE_BYTE_ORDER == MSBFirst
1450
 
                  GL_UNSIGNED_INT_8_8_8_8_REV,
1451
 
#else
1452
 
                  GL_UNSIGNED_BYTE,
1453
 
#endif
1454
 
                  NULL);
1455
 
 
1456
 
    glBindTexture (GL_TEXTURE_2D, 0);
1457
 
  }
1458
 
 
1459
 
  glGetError ();
1460
 
 
1461
 
  (*GL::bindFramebuffer) (GL_FRAMEBUFFER_EXT, mFboHandle);
1462
 
 
1463
 
  (*GL::framebufferTexture2D) (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT,
1464
 
                               GL_TEXTURE_2D, mFBTexture, 0);
1465
 
 
1466
 
  /* Ensure that a framebuffer is actually available */
1467
 
  if (!mFboStatus)
1468
 
  {
1469
 
    GLint status = (*GL::checkFramebufferStatus) (GL_DRAW_FRAMEBUFFER);
1470
 
 
1471
 
    if (status != GL_FRAMEBUFFER_COMPLETE)
1472
 
    {
1473
 
       switch (status)
1474
 
       {
1475
 
          case GL_FRAMEBUFFER_UNDEFINED:
1476
 
            compLogMessage ("unity", CompLogLevelWarn, "no window"); break;
1477
 
          case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
1478
 
            compLogMessage ("unity", CompLogLevelWarn, "attachment incomplete"); break;
1479
 
          case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
1480
 
            compLogMessage ("unity", CompLogLevelWarn, "no buffers attached to fbo"); break;
1481
 
          case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
1482
 
            compLogMessage ("unity", CompLogLevelWarn, "some attachment in glDrawBuffers doesn't exist in FBO"); break;
1483
 
          case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
1484
 
            compLogMessage ("unity", CompLogLevelWarn, "some attachment in glReadBuffers doesn't exist in FBO"); break;
1485
 
          case GL_FRAMEBUFFER_UNSUPPORTED:
1486
 
            compLogMessage ("unity", CompLogLevelWarn, "unsupported internal format"); break;
1487
 
          case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
1488
 
            compLogMessage ("unity", CompLogLevelWarn, "different levels of sampling for each attachment"); break;
1489
 
          case GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS:
1490
 
            compLogMessage ("unity", CompLogLevelWarn, "number of layers is different"); break;
1491
 
          default:
1492
 
            compLogMessage ("unity", CompLogLevelWarn, "unable to bind the framebuffer for an unknown reason"); break;
1493
 
       }
1494
 
 
1495
 
       GL::bindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
1496
 
       GL::deleteFramebuffers (1, &mFboHandle);
1497
 
 
1498
 
       glDrawBuffer (GL_BACK);
1499
 
       glReadBuffer (GL_BACK);
1500
 
 
1501
 
       mFboHandle = 0;
1502
 
 
1503
 
       mFboStatus = false;
1504
 
       uScreen->setActiveFbo (0);
1505
 
     }
1506
 
     else
1507
 
       mFboStatus = true;
1508
 
   }
1509
 
 
1510
 
  if (mFboStatus)
1511
 
  {
1512
 
    uScreen->setActiveFbo (mFboHandle);
1513
 
 
1514
 
    glDrawBuffer (GL_COLOR_ATTACHMENT0_EXT);
1515
 
    glReadBuffer (GL_COLOR_ATTACHMENT0_EXT);
1516
 
 
1517
 
    glViewport (0,
1518
 
                0,
1519
 
                output->width (),
1520
 
                output->height ());
1521
 
 
1522
 
  }
1523
 
}
1524
 
 
1525
 
UnityFBO::UnityFBO (CompOutput *o)
1526
 
 : mFboStatus (false)
1527
 
 , mFBTexture (0)
1528
 
 , output (o)
1529
 
{
1530
 
  (*GL::genFramebuffers) (1, &mFboHandle);
1531
 
}
1532
 
 
1533
 
UnityFBO::~UnityFBO ()
1534
 
{
1535
 
  (*GL::deleteFramebuffers) (1, &mFboHandle);
1536
 
 
1537
 
  if (mFBTexture)
1538
 
    glDeleteTextures (1, &mFBTexture);
1539
 
}
1540
 
 
1541
 
/* Start up the launcher */
1542
 
void UnityScreen::initLauncher(nux::NThread* thread, void* InitData)
1543
 
{
1544
 
  Timer timer;
1545
 
  UnityScreen* self = reinterpret_cast<UnityScreen*>(InitData);
1546
 
 
1547
 
  self->launcherWindow = new nux::BaseWindow(TEXT("LauncherWindow"));
1548
 
  self->launcherWindow->SinkReference();
1549
 
 
1550
 
  self->launcher = new Launcher(self->launcherWindow, self->screen);
1551
 
  self->launcher->SinkReference();
1552
 
  self->launcher->hidden_changed.connect(sigc::mem_fun(self, &UnityScreen::OnLauncherHiddenChanged));
1553
 
 
1554
 
  self->AddChild(self->launcher);
1555
 
 
1556
 
  nux::HLayout* layout = new nux::HLayout();
1557
 
  layout->AddView(self->launcher, 1);
1558
 
  layout->SetContentDistribution(nux::eStackLeft);
1559
 
  layout->SetVerticalExternalMargin(0);
1560
 
  layout->SetHorizontalExternalMargin(0);
1561
 
 
1562
 
  self->controller = new LauncherController(self->launcher, self->screen);
1563
 
 
1564
 
  self->launcherWindow->SetConfigureNotifyCallback(&UnityScreen::launcherWindowConfigureCallback, self);
1565
 
  self->launcherWindow->SetLayout(layout);
1566
 
  self->launcherWindow->SetBackgroundColor(nux::Color(0x00000000));
1567
 
  self->launcherWindow->ShowWindow(true);
1568
 
  self->launcherWindow->EnableInputWindow(true, "launcher", false, false);
1569
 
  self->launcherWindow->InputWindowEnableStruts(true);
1570
 
  self->launcherWindow->SetEnterFocusInputArea(self->launcher);
1571
 
 
1572
 
  self->switcherController = new SwitcherController();
1573
 
  /* FIXME: this should not be manual, should be managed with a
1574
 
     show/hide callback like in GAIL*/
1575
 
  if (unity_a11y_initialized () == TRUE)
1576
 
    {
1577
 
      AtkObject *atk_obj = NULL;
1578
 
 
1579
 
      atk_obj = unity_util_accessible_add_window (self->launcherWindow);
1580
 
 
1581
 
      atk_object_set_name (atk_obj, _("Launcher"));
1582
 
    }
1583
 
 
1584
 
  self->launcher->SetIconSize(54, 48);
1585
 
  self->launcher->SetBacklightMode(Launcher::BACKLIGHT_ALWAYS_ON);
1586
 
 
1587
 
  LOG_INFO(logger) << "initLauncher-Launcher " << timer.ElapsedSeconds() << "s";
1588
 
 
1589
 
  /* Setup panel */
1590
 
  timer.Reset();
1591
 
  self->panelController = new PanelController();
1592
 
  self->AddChild(self->panelController);
1593
 
  LOG_INFO(logger) << "initLauncher-Panel " << timer.ElapsedSeconds() << "s";
1594
 
 
1595
 
  /* Setup Places */
1596
 
  self->dashController = DashController::Ptr(new DashController());
1597
 
 
1598
 
  /* FIXME: this should not be manual, should be managed with a
1599
 
     show/hide callback like in GAIL
1600
 
  if (unity_a11y_initialized() == TRUE)
1601
 
  {
1602
 
    AtkObject* atk_obj = NULL;
1603
 
 
1604
 
    atk_obj = unity_util_accessible_add_window(self->placesController->GetWindow());
1605
 
 
1606
 
    atk_object_set_name(atk_obj, _("Places"));
1607
 
  }
1608
 
  */
1609
 
 
1610
 
  self->launcher->SetHideMode(Launcher::LAUNCHER_HIDE_DODGE_WINDOWS);
1611
 
  self->launcher->SetLaunchAnimation(Launcher::LAUNCH_ANIMATION_PULSE);
1612
 
  self->launcher->SetUrgentAnimation(Launcher::URGENT_ANIMATION_WIGGLE);
1613
 
  self->ScheduleRelayout(0);
1614
 
 
1615
 
  self->OnLauncherHiddenChanged();
1616
 
}
1617
 
 
1618
 
/* Window init */
1619
 
UnityWindow::UnityWindow(CompWindow* window)
1620
 
  : BaseSwitchWindow (dynamic_cast<BaseSwitchScreen *> (UnityScreen::get (screen)), window)
1621
 
  , PluginClassHandler<UnityWindow, CompWindow>(window)
1622
 
  , window(window)
1623
 
  , gWindow(GLWindow::get(window))
1624
 
{
1625
 
  WindowInterface::setHandler(window);
1626
 
  GLWindowInterface::setHandler(gWindow);
1627
 
}
1628
 
 
1629
 
UnityWindow::~UnityWindow()
1630
 
{
1631
 
  UnityScreen* us = UnityScreen::get(screen);
1632
 
  if (us->newFocusedWindow && (UnityWindow::get(us->newFocusedWindow) == this))
1633
 
    us->newFocusedWindow = NULL;
1634
 
  if (us->lastFocusedWindow && (UnityWindow::get(us->lastFocusedWindow) == this))
1635
 
    us->lastFocusedWindow = NULL;
1636
 
}
1637
 
 
1638
 
/* vtable init */
1639
 
bool UnityPluginVTable::init()
1640
 
{
1641
 
  gfloat version;
1642
 
  gchar* extensions;
1643
 
 
1644
 
  if (!CompPlugin::checkPluginABI("core", CORE_ABIVERSION))
1645
 
    return false;
1646
 
  if (!CompPlugin::checkPluginABI("composite", COMPIZ_COMPOSITE_ABI))
1647
 
    return false;
1648
 
  if (!CompPlugin::checkPluginABI("opengl", COMPIZ_OPENGL_ABI))
1649
 
    return false;
1650
 
 
1651
 
  /* Ensure OpenGL version is 1.4+. */
1652
 
  version = get_opengl_version_f32((const gchar*) glGetString(GL_VERSION));
1653
 
  if (version < 1.4f)
1654
 
  {
1655
 
    compLogMessage("unityshell", CompLogLevelError,
1656
 
                   "OpenGL 1.4+ not supported\n");
1657
 
    return false;
1658
 
  }
1659
 
 
1660
 
  /* Ensure OpenGL extensions required by the Unity plugin are available. */
1661
 
  extensions = (gchar*) glGetString(GL_EXTENSIONS);
1662
 
  if (!is_extension_supported(extensions, "GL_ARB_vertex_program"))
1663
 
  {
1664
 
    compLogMessage("unityshell", CompLogLevelError,
1665
 
                   "GL_ARB_vertex_program not supported\n");
1666
 
    return false;
1667
 
  }
1668
 
  if (!is_extension_supported(extensions, "GL_ARB_fragment_program"))
1669
 
  {
1670
 
    compLogMessage("unityshell", CompLogLevelError,
1671
 
                   "GL_ARB_fragment_program not supported\n");
1672
 
    return false;
1673
 
  }
1674
 
  if (!is_extension_supported(extensions, "GL_ARB_vertex_buffer_object"))
1675
 
  {
1676
 
    compLogMessage("unityshell", CompLogLevelError,
1677
 
                   "GL_ARB_vertex_buffer_object not supported\n");
1678
 
    return false;
1679
 
  }
1680
 
  if (!is_extension_supported(extensions, "GL_ARB_framebuffer_object"))
1681
 
  {
1682
 
    if (!is_extension_supported(extensions, "GL_EXT_framebuffer_object"))
1683
 
    {
1684
 
      compLogMessage("unityshell", CompLogLevelError,
1685
 
                     "GL_ARB_framebuffer_object or GL_EXT_framebuffer_object "
1686
 
                     "not supported\n");
1687
 
      return false;
1688
 
    }
1689
 
  }
1690
 
  if (!is_extension_supported(extensions, "GL_ARB_texture_non_power_of_two"))
1691
 
  {
1692
 
    if (!is_extension_supported(extensions, "GL_ARB_texture_rectangle"))
1693
 
    {
1694
 
      compLogMessage("unityshell", CompLogLevelError,
1695
 
                     "GL_ARB_texture_non_power_of_two or "
1696
 
                     "GL_ARB_texture_rectangle not supported\n");
1697
 
      return false;
1698
 
    }
1699
 
  }
1700
 
 
1701
 
  return true;
1702
 
}
1703
 
 
1704
 
 
1705
 
namespace
1706
 
{
1707
 
 
1708
 
void configure_logging()
1709
 
{
1710
 
  // The default behaviour of the logging infrastructure is to send all output
1711
 
  // to std::cout for warning or above.
1712
 
 
1713
 
  // TODO: write a file output handler that keeps track of backups.
1714
 
  nux::logging::configure_logging(::getenv("UNITY_LOG_SEVERITY"));
1715
 
  g_log_set_default_handler(capture_g_log_calls, NULL);
1716
 
}
1717
 
 
1718
 
/* Checks whether an extension is supported by the GLX or OpenGL implementation
1719
 
 * given the extension name and the list of supported extensions. */
1720
 
gboolean is_extension_supported(const gchar* extensions, const gchar* extension)
1721
 
{
1722
 
  if (extensions != NULL && extension != NULL)
1723
 
  {
1724
 
    const gsize len = strlen(extension);
1725
 
    gchar* p = (gchar*) extensions;
1726
 
    gchar* end = p + strlen(p);
1727
 
 
1728
 
    while (p < end)
1729
 
    {
1730
 
      const gsize size = strcspn(p, " ");
1731
 
      if (len == size && strncmp(extension, p, size) == 0)
1732
 
        return TRUE;
1733
 
      p += size + 1;
1734
 
    }
1735
 
  }
1736
 
 
1737
 
  return FALSE;
1738
 
}
1739
 
 
1740
 
/* Gets the OpenGL version as a floating-point number given the string. */
1741
 
gfloat get_opengl_version_f32(const gchar* version_string)
1742
 
{
1743
 
  gfloat version = 0.0f;
1744
 
  gint32 i;
1745
 
 
1746
 
  for (i = 0; isdigit(version_string[i]); i++)
1747
 
    version = version * 10.0f + (version_string[i] - 48);
1748
 
 
1749
 
  if ((version_string[i] == '.' || version_string[i] == ',') &&
1750
 
      isdigit(version_string[i + 1]))
1751
 
  {
1752
 
    version = version * 10.0f + (version_string[i + 1] - 48);
1753
 
    return (version + 0.1f) * 0.1f;
1754
 
  }
1755
 
  else
1756
 
    return 0.0f;
1757
 
}
1758
 
 
1759
 
nux::logging::Level glog_level_to_nux(GLogLevelFlags log_level)
1760
 
{
1761
 
  // For some weird reason, ERROR is more critical than CRITICAL in gnome.
1762
 
  if (log_level & G_LOG_LEVEL_ERROR)
1763
 
    return nux::logging::Critical;
1764
 
  if (log_level & G_LOG_LEVEL_CRITICAL)
1765
 
    return nux::logging::Error;
1766
 
  if (log_level & G_LOG_LEVEL_WARNING)
1767
 
    return nux::logging::Warning;
1768
 
  if (log_level & G_LOG_LEVEL_MESSAGE ||
1769
 
      log_level & G_LOG_LEVEL_INFO)
1770
 
    return nux::logging::Info;
1771
 
  // default to debug.
1772
 
  return nux::logging::Debug;
1773
 
}
1774
 
 
1775
 
void capture_g_log_calls(const gchar* log_domain,
1776
 
                         GLogLevelFlags log_level,
1777
 
                         const gchar* message,
1778
 
                         gpointer user_data)
1779
 
{
1780
 
  // Since we aren't entirely sure if log_domain contains anything, lets have
1781
 
  // a glib prefix.
1782
 
  std::string module("glib");
1783
 
  if (log_domain)
1784
 
  {
1785
 
    module += std::string(".") + log_domain;
1786
 
  }
1787
 
  nux::logging::Logger logger(module);
1788
 
  nux::logging::Level level = glog_level_to_nux(log_level);
1789
 
  if (logger.GetEffectiveLogLevel() >= level)
1790
 
  {
1791
 
    nux::logging::LogStream(level, logger.module(), "<unknown>", 0).stream()
1792
 
        << message;
1793
 
  }
1794
 
}
1795
 
 
1796
 
} // anonymous namespace