Back to index

unity  6.0.0
Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Member Functions | Private Member Functions | Private Attributes | Static Private Attributes
PluginAdapter Class Reference

#include <PluginAdapter.h>

Inheritance diagram for PluginAdapter:
Inheritance graph
[legend]
Collaboration diagram for PluginAdapter:
Collaboration graph
[legend]

List of all members.

Public Types

enum  FocusVisibility { OnlyVisible, ForceUnminimizeInvisible, ForceUnminimizeOnCurrentDesktop }
typedef std::list
< Introspectable * > 
IntrospectableList

Public Member Functions

 ~PluginAdapter ()
void SetScaleAction (MultiActionList &scale)
void SetExpoAction (MultiActionList &expo)
void SetShowHandlesAction (CompAction *action)
void SetHideHandlesAction (CompAction *action)
void SetToggleHandlesAction (CompAction *action)
void OnWindowClosed (CompWindow *)
void OnScreenGrabbed ()
void OnScreenUngrabbed ()
void OnShowDesktop ()
void OnLeaveDesktop ()
void TerminateScale ()
bool IsScaleActive ()
bool IsScaleActiveForGroup ()
void InitiateExpo ()
bool IsExpoActive ()
void ShowGrabHandles (CompWindow *window, bool use_timer)
void HideGrabHandles (CompWindow *window)
void ToggleGrabHandles (CompWindow *window)
void Notify (CompWindow *window, CompWindowNotify notify)
void NotifyMoved (CompWindow *window, int x, int y)
void NotifyResized (CompWindow *window, int x, int y, int w, int h)
void NotifyStateChange (CompWindow *window, unsigned int state, unsigned int last_state)
void NotifyCompizEvent (const char *plugin, const char *event, CompOption::Vector &option)
void NotifyNewDecorationState (guint32 xid)
guint32 GetActiveWindow ()
void Decorate (guint32 xid)
void Undecorate (guint32 xid)
bool IsWindowMaximized (guint xid)
bool IsWindowDecorated (guint xid)
bool IsWindowOnCurrentDesktop (guint xid)
bool IsWindowObscured (guint xid)
bool IsWindowMapped (guint xid)
bool IsWindowVisible (guint32 xid)
bool IsWindowOnTop (guint32 xid)
bool IsWindowClosable (guint32 xid)
bool IsWindowMinimizable (guint32 xid)
bool IsWindowMaximizable (guint32 xid)
void Restore (guint32 xid)
void RestoreAt (guint32 xid, int x, int y)
void Minimize (guint32 xid)
void Close (guint32 xid)
void Activate (guint32 xid)
void Raise (guint32 xid)
void Lower (guint32 xid)
void ShowDesktop ()
void SetWindowIconGeometry (Window window, nux::Geometry const &geo)
void FocusWindowGroup (std::vector< Window > windows, FocusVisibility, int monitor=-1, bool only_top_win=true)
bool ScaleWindowGroup (std::vector< Window > windows, int state, bool force)
bool IsScreenGrabbed ()
bool IsViewPortSwitchStarted ()
unsigned long long GetWindowActiveNumber (guint32 xid)
bool MaximizeIfBigEnough (CompWindow *window)
int GetWindowMonitor (guint32 xid) const
nux::Geometry GetWindowGeometry (guint32 xid) const
nux::Geometry GetWindowSavedGeometry (guint32 xid) const
nux::Geometry GetScreenGeometry () const
nux::Geometry GetWorkAreaGeometry (guint32 xid=0) const
void CheckWindowIntersections (nux::Geometry const &region, bool &active, bool &any)
int WorkspaceCount ()
void SetCoverageAreaBeforeAutomaximize (float area)
bool saveInputFocus ()
bool restoreInputFocus ()
void MoveResizeWindow (guint32 xid, nux::Geometry geometry)
virtual bool IsWindowMaximized (guint32 xid)=0
virtual bool IsWindowDecorated (guint32 xid)=0
virtual bool IsWindowOnCurrentDesktop (guint32 xid)=0
virtual bool IsWindowObscured (guint32 xid)=0
virtual bool IsWindowMapped (guint32 xid)=0
void StartMove (guint32 xid, int, int)
GVariant * Introspect ()
void AddChild (Introspectable *child)
void RemoveChild (Introspectable *child)
virtual IntrospectableList GetIntrospectableChildren ()
guint64 GetIntrospectionId () const

Static Public Member Functions

static PluginAdapterDefault ()
static void Initialize (CompScreen *screen)
static void SetDefault (WindowManager *manager)

Public Attributes

nux::Property< bool > bias_active_to_viewport
sigc::signal< void, guint32 > window_mapped
sigc::signal< void, guint32 > window_unmapped
sigc::signal< void, guint32 > window_maximized
sigc::signal< void, guint32 > window_restored
sigc::signal< void, guint32 > window_minimized
sigc::signal< void, guint32 > window_unminimized
sigc::signal< void, guint32 > window_shaded
sigc::signal< void, guint32 > window_unshaded
sigc::signal< void, guint32 > window_shown
sigc::signal< void, guint32 > window_hidden
sigc::signal< void, guint32 > window_resized
sigc::signal< void, guint32 > window_moved
sigc::signal< void, guint32 > window_focus_changed
sigc::signal< void, guint32 > window_decorated
sigc::signal< void, guint32 > window_undecorated
sigc::signal< void > initiate_spread
sigc::signal< void > terminate_spread
sigc::signal< void > initiate_expo
sigc::signal< void > terminate_expo
sigc::signal< void > compiz_screen_grabbed
sigc::signal< void > compiz_screen_ungrabbed
sigc::signal< void > compiz_screen_viewport_switch_started
sigc::signal< void > compiz_screen_viewport_switch_ended
sigc::signal< void, const char
*, const char
*, CompOption::Vector & > 
compiz_event

Protected Member Functions

 PluginAdapter (CompScreen *screen)
void AddProperties (GVariantBuilder *builder)
std::string GetName () const
virtual std::string GetChildsName () const
 Please don't override this unless you really need to. The only valid reason is if you have a property that simply must be called 'Children'.

Private Member Functions

std::string MatchStringForXids (std::vector< Window > *windows)
void InitiateScale (std::string const &match, int state=0)
bool CheckWindowIntersection (nux::Geometry const &region, CompWindow *window)
void SetMwmWindowHints (Window xid, MotifWmHints *new_hints)

Private Attributes

CompScreen * m_Screen
MultiActionList m_ExpoActionList
MultiActionList m_ScaleActionList
bool _spread_state
bool _spread_windows_state
bool _expo_state
bool _vp_switch_started
CompAction * _grab_show_action
CompAction * _grab_hide_action
CompAction * _grab_toggle_action
float _coverage_area_before_automaximize
bool _in_show_desktop
CompWindow * _last_focused_window
std::map< guint32, unsigned int > _window_decoration_state

Static Private Attributes

static PluginAdapter_default = 0

Detailed Description

Definition at line 60 of file PluginAdapter.h.


Member Typedef Documentation

Definition at line 34 of file Introspectable.h.


Member Enumeration Documentation

Enumerator:
OnlyVisible 
ForceUnminimizeInvisible 
ForceUnminimizeOnCurrentDesktop 

Definition at line 42 of file WindowManager.h.


Constructor & Destructor Documentation

Definition at line 82 of file PluginAdapterCompiz.cpp.

{
}
PluginAdapter::PluginAdapter ( CompScreen *  screen) [protected]

Definition at line 63 of file PluginAdapterCompiz.cpp.

Here is the caller graph for this function:


Member Function Documentation

void PluginAdapter::Activate ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 661 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    window->activate();
}

Definition at line 78 of file Introspectable.cpp.

{
  _children.push_back(child);
  child->_parents.push_back(this);
}

Here is the caller graph for this function:

void PluginAdapter::AddProperties ( GVariantBuilder *  builder) [protected, virtual]

Implements WindowManager.

Definition at line 1318 of file PluginAdapterCompiz.cpp.

{
  unity::variant::BuilderWrapper wrapper(builder);
  wrapper.add(GetScreenGeometry())
         .add("workspace_count", WorkspaceCount())
         .add("active_window", GetActiveWindow())
         .add("screen_grabbed", IsScreenGrabbed())
         .add("scale_active", IsScaleActive())
         .add("scale_active_for_group", IsScaleActiveForGroup())
         .add("expo_active", IsExpoActive())
         .add("viewport_switch_running", IsViewPortSwitchStarted())
         .add("showdesktop_active", _in_show_desktop);
}

Here is the call graph for this function:

bool PluginAdapter::CheckWindowIntersection ( nux::Geometry const &  region,
CompWindow *  window 
) [private]

Definition at line 968 of file PluginAdapterCompiz.cpp.

{
  int intersect_types = CompWindowTypeNormalMask | CompWindowTypeDialogMask |
                        CompWindowTypeModalDialogMask | CompWindowTypeUtilMask;

  if (!window ||
      !(window->type() & intersect_types) ||
      !window->isMapped() ||
      !window->isViewable() ||
      window->state() & CompWindowStateHiddenMask)
    return false;

  if (CompRegion(window->borderRect()).intersects(CompRect(region.x, region.y, region.width, region.height)))
    return true;

  return false;
}

Here is the caller graph for this function:

void PluginAdapter::CheckWindowIntersections ( nux::Geometry const &  region,
bool &  active,
bool &  any 
) [virtual]

Implements WindowManager.

Definition at line 987 of file PluginAdapterCompiz.cpp.

{
  // prime to false so we can assume values later one
  active = false;
  any = false;

  CompWindowList window_list = m_Screen->windows();
  CompWindowList::iterator it;
  CompWindow* window = NULL;
  CompWindow* parent = NULL;
  int type_dialogs = CompWindowTypeDialogMask | CompWindowTypeModalDialogMask
                     | CompWindowTypeUtilMask;


  window = m_Screen->findWindow(m_Screen->activeWindow());

  if (window && (window->type() & type_dialogs))
    parent = m_Screen->findWindow(window->transientFor());

  if (CheckWindowIntersection(region, window) || CheckWindowIntersection(region, parent))
  {
    any = true;
    active = true;
  }
  else
  {
    for (it = window_list.begin(); it != window_list.end(); it++)
    {
      if (CheckWindowIntersection(region, *it))
      {
        any = true;
        break;
      }
    }
  }
}

Here is the call graph for this function:

void PluginAdapter::Close ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 650 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    window->close(CurrentTime);
}
void PluginAdapter::Decorate ( guint32  xid) [virtual]

Reimplemented from WindowManager.

Definition at line 1083 of file PluginAdapterCompiz.cpp.

{
  MotifWmHints hints = { 0 };

  hints.flags = MWM_HINTS_DECORATIONS;
  hints.decorations = GDK_DECOR_ALL & ~(MWM_HINTS_UNDECORATED_UNITY);

  SetMwmWindowHints(xid, &hints);
}

Here is the call graph for this function:

Reimplemented from WindowManager.

Definition at line 49 of file PluginAdapterCompiz.cpp.

{
  if (!_default)
    return 0;
  return _default;
}

Here is the caller graph for this function:

void PluginAdapter::FocusWindowGroup ( std::vector< Window >  windows,
FocusVisibility  focus_visibility,
int  monitor = -1,
bool  only_top_win = true 
) [virtual]

Implements WindowManager.

Definition at line 694 of file PluginAdapterCompiz.cpp.

{
  CompPoint target_vp = m_Screen->vp();
  CompWindow* top_window = nullptr;
  CompWindow* top_monitor_win = nullptr;

  bool any_on_current = false;
  bool any_mapped = false;
  bool any_mapped_on_current = false;
  bool forced_unminimize = false;

  /* sort the list */
  CompWindowList windows;
  for (auto win : m_Screen->clientList())
  {
    Window id = win->id();
    if (std::find(window_ids.begin(), window_ids.end(), id) != window_ids.end())
      windows.push_back(win);
  }

  /* filter based on workspace */
  for (CompWindow* &win : windows)
  {
    if (win->defaultViewport() == m_Screen->vp())
    {
      any_on_current = true;

      if (!win->minimized())
      {
        any_mapped_on_current = true;
      }
    }

    if (!win->minimized())
    {
      any_mapped = true;
    }

    if (any_on_current && any_mapped)
      break;
  }

  if (!any_on_current)
  {
    for (auto it = windows.rbegin(); it != windows.rend(); ++it)
    {
      CompWindow* win = *it;
      if ((any_mapped && !win->minimized()) || !any_mapped)
      {
        target_vp = win->defaultViewport();
        break;
      }
    }
  }

  for (CompWindow* &win : windows)
  {
    if (win->defaultViewport() == target_vp)
    {
      int win_monitor = GetWindowMonitor(win->id());

      /* Any window which is actually unmapped is
      * not going to be accessible by either switcher
      * or scale, so unconditionally unminimize those
      * windows when the launcher icon is activated */
      if ((focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeOnCurrentDesktop &&
          target_vp == m_Screen->vp()) ||
          (focus_visibility == WindowManager::FocusVisibility::ForceUnminimizeInvisible &&
           win->mapNum() == 0))
      {
        top_window = win;
        forced_unminimize = true;

        if (monitor >= 0 && win_monitor == monitor)
          top_monitor_win = win;

        if (!only_top_win)
        {
          bool is_mapped = (win->mapNum() != 0);
          win->unminimize();

           /* Initially minimized windows dont get raised */
          if (!is_mapped)
            win->raise();
        }
      }
      else if ((any_mapped_on_current && !win->minimized()) || !any_mapped_on_current)
      {
        if (!forced_unminimize || target_vp == m_Screen->vp())
        {
          top_window = win;

          if (monitor >= 0 && win_monitor == monitor)
            top_monitor_win = win;

          if (!only_top_win)
            win->raise();
        }
      }
    }
  }

  if (monitor >= 0 && top_monitor_win)
    top_window = top_monitor_win;

  if (top_window)
  {
    if (only_top_win)
    {
      if (forced_unminimize)
        {
          top_window->unminimize();
        }

      top_window->raise();
    }

    top_window->activate();
  }
}

Here is the call graph for this function:

guint32 PluginAdapter::GetActiveWindow ( ) [virtual]

Implements WindowManager.

Definition at line 398 of file PluginAdapterCompiz.cpp.

{
  return m_Screen->activeWindow();
}

Here is the caller graph for this function:

std::string unity::debug::Introspectable::GetChildsName ( ) const [protected, virtual, inherited]

Please don't override this unless you really need to. The only valid reason is if you have a property that simply must be called 'Children'.

Definition at line 92 of file Introspectable.cpp.

{
  return "Children";
}

Here is the caller graph for this function:

Introspectable::IntrospectableList unity::debug::Introspectable::GetIntrospectableChildren ( ) [virtual, inherited]

Reimplemented in unity::hud::View, unity::launcher::LauncherModel, unity::QuicklistView, and unity::dash::ResultView.

Definition at line 41 of file Introspectable.cpp.

{
  return _children;
}

Here is the caller graph for this function:

guint64 unity::debug::Introspectable::GetIntrospectionId ( ) const [inherited]

Definition at line 97 of file Introspectable.cpp.

{
  return _id;
}

Here is the caller graph for this function:

std::string WindowManager::GetName ( ) const [protected, virtual, inherited]

Implements unity::debug::Introspectable.

Definition at line 254 of file WindowManager.cpp.

{
  return "WindowManager";
}
nux::Geometry PluginAdapter::GetScreenGeometry ( ) const [virtual]

Implements WindowManager.

Definition at line 928 of file PluginAdapterCompiz.cpp.

{
  nux::Geometry geo;

  geo.x = 0;
  geo.y = 0;
  geo.width = m_Screen->width();
  geo.height = m_Screen->height();

  return geo;
}

Here is the caller graph for this function:

unsigned long long PluginAdapter::GetWindowActiveNumber ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 301 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);

  if (window)
  {
    // result is actually an unsigned int (32 bits)
    unsigned long long result = window->activeNum ();
    if (bias_active_to_viewport() && window->defaultViewport() == m_Screen->vp())
      result = result << 32;

    return result;
  }

  return 0;
}
nux::Geometry PluginAdapter::GetWindowGeometry ( guint32  xid) const [virtual]

Implements WindowManager.

Definition at line 890 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;
  nux::Geometry geo;

  window = m_Screen->findWindow(win);
  if (window)
  {
    geo.x = window->borderRect().x();
    geo.y = window->borderRect().y();
    geo.width = window->borderRect().width();
    geo.height = window->borderRect().height();
  }
  return geo;
}

Here is the caller graph for this function:

int PluginAdapter::GetWindowMonitor ( guint32  xid) const [virtual]

Implements WindowManager.

Definition at line 873 of file PluginAdapterCompiz.cpp.

{
  // FIXME, we should use window->outputDevice() but this is not UScreen friendly
  nux::Geometry const& geo = GetWindowGeometry(xid);

  if (!geo.IsNull())
  {
    int x = geo.x + geo.width/2;
    int y = geo.y + geo.height/2;

    return unity::UScreen::GetDefault()->GetMonitorAtPosition(x, y);
  }

  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nux::Geometry PluginAdapter::GetWindowSavedGeometry ( guint32  xid) const [virtual]

Implements WindowManager.

Definition at line 908 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  nux::Geometry geo(0, 0, 1, 1);
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
  {
    XWindowChanges &wc = window->saveWc();
    geo.x = wc.x;
    geo.y = wc.y;
    geo.width = wc.width;
    geo.height = wc.height;
  }

  return geo;
}

Here is the caller graph for this function:

nux::Geometry PluginAdapter::GetWorkAreaGeometry ( guint32  xid = 0) const [virtual]

Implements WindowManager.

Definition at line 941 of file PluginAdapterCompiz.cpp.

{
  CompWindow* window = nullptr;
  unsigned int output = 0;

  if (xid != 0)
  {
    Window win = xid;

    window = m_Screen->findWindow(win);
    if (window)
    {
      output = window->outputDevice();
    }
  }

  if (xid == 0 || !window)
  {
    output = m_Screen->currentOutputDev().id();
  }

  CompRect workarea = m_Screen->getWorkareaForOutput(output);

  return nux::Geometry(workarea.x(), workarea.y(), workarea.width(), workarea.height());
}

Here is the caller graph for this function:

void PluginAdapter::HideGrabHandles ( CompWindow *  window)

Definition at line 1200 of file PluginAdapterCompiz.cpp.

{
  if (!_grab_hide_action || !window)
    return;

  CompOption::Vector argument;

  argument.resize(2);
  argument[0].setName("root", CompOption::TypeInt);
  argument[0].value().set((int) screen->root());
  argument[1].setName("window", CompOption::TypeInt);
  argument[1].value().set((int) window->id());

  /* Initiate the first available action with the arguments */
  _grab_hide_action->initiate()(_grab_hide_action, 0, argument);
}
void PluginAdapter::Initialize ( CompScreen *  screen) [static]

Definition at line 58 of file PluginAdapterCompiz.cpp.

{
  _default = new PluginAdapter(screen);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PluginAdapter::InitiateExpo ( ) [virtual]

Implements WindowManager.

Definition at line 389 of file PluginAdapterCompiz.cpp.

{
  CompOption::Vector argument(0);

  m_ExpoActionList.InitiateAll(argument, 0);
}

Here is the call graph for this function:

void PluginAdapter::InitiateScale ( std::string const &  match,
int  state = 0 
) [private]

Definition at line 351 of file PluginAdapterCompiz.cpp.

{
  CompOption::Vector argument;
  CompMatch      m(match);

  argument.resize(1);
  argument[0].setName("match", CompOption::TypeMatch);
  argument[0].value().set(m);

  m_ScaleActionList.InitiateAll(argument, state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GVariant * unity::debug::Introspectable::Introspect ( ) [inherited]

Definition at line 47 of file Introspectable.cpp.

{
  GVariantBuilder  builder;
  GVariantBuilder  child_builder;
  gint             n_children = 0;

  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
  g_variant_builder_add(&builder, "{sv}", "id", g_variant_new_uint64(_id));

  AddProperties(&builder);

  g_variant_builder_init(&child_builder, G_VARIANT_TYPE("as"));

  auto children = GetIntrospectableChildren();
  for (auto it = children.begin(); it != children.end(); it++)
  {
    if ((*it)->GetName() != "")
    {
      g_variant_builder_add(&child_builder, "s", (*it)->GetName().c_str());
      n_children++;
    }
  }

  GVariant* child_results = g_variant_builder_end(&child_builder);

  if (n_children > 0)
    g_variant_builder_add(&builder, "{sv}", GetChildsName().c_str(), child_results);
  return g_variant_builder_end(&builder);
}

Here is the call graph for this function:

bool PluginAdapter::IsExpoActive ( ) [virtual]

Implements WindowManager.

Definition at line 383 of file PluginAdapterCompiz.cpp.

{
  return m_Screen->grabExist("expo");
}

Here is the caller graph for this function:

bool PluginAdapter::IsScaleActive ( ) [virtual]

Implements WindowManager.

Definition at line 371 of file PluginAdapterCompiz.cpp.

{
  return m_Screen->grabExist("scale");
}

Here is the caller graph for this function:

Implements WindowManager.

Definition at line 377 of file PluginAdapterCompiz.cpp.

{
  return _spread_windows_state && m_Screen->grabExist("scale");
}

Here is the caller graph for this function:

bool PluginAdapter::IsScreenGrabbed ( ) [virtual]

Implements WindowManager.

Definition at line 1108 of file PluginAdapterCompiz.cpp.

{
  return m_Screen->grabbed();
}

Here is the caller graph for this function:

Implements WindowManager.

Definition at line 1114 of file PluginAdapterCompiz.cpp.

{
  return _vp_switch_started;
}

Here is the caller graph for this function:

bool PluginAdapter::IsWindowClosable ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 572 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    return (window->actions() & CompWindowActionCloseMask);

  return false;
}
virtual bool WindowManager::IsWindowDecorated ( guint32  xid) [pure virtual, inherited]

Implemented in WindowManagerDummy.

Here is the caller graph for this function:

bool PluginAdapter::IsWindowDecorated ( guint  xid)

Definition at line 419 of file PluginAdapterCompiz.cpp.

{
  Display* display = m_Screen->dpy();
  Window win = xid;
  Atom hints_atom = None;
  MotifWmHints* hints = NULL;
  Atom type = None;
  gint format;
  gulong nitems;
  gulong bytes_after;
  bool ret = true;

  hints_atom = XInternAtom(display, _XA_MOTIF_WM_HINTS, false);

  if (XGetWindowProperty(display, win, hints_atom, 0,
                         sizeof(MotifWmHints) / sizeof(long), False,
                         hints_atom, &type, &format, &nitems, &bytes_after,
                         (guchar**)&hints) != Success)
    return false;

  if (!hints)
    return ret;

  /* Check for the presence of the high bit
   * if present, it means that we undecorated
   * this window, so don't mark it as undecorated */
  if (type == hints_atom && format != 0 &&
      hints->flags & MWM_HINTS_DECORATIONS)
  {
    /* Must have both bits set */
    _window_decoration_state[xid] = ret =
          (hints->decorations & (MwmDecorAll | MwmDecorTitle))  ||
          (hints->decorations & MWM_HINTS_UNDECORATED_UNITY);
  }

  XFree(hints);
  return ret;
}

Here is the caller graph for this function:

virtual bool WindowManager::IsWindowMapped ( guint32  xid) [pure virtual, inherited]

Implemented in WindowManagerDummy.

Here is the caller graph for this function:

bool PluginAdapter::IsWindowMapped ( guint  xid)

Definition at line 508 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    return window->mapNum () > 0;
  return true;
}
bool PluginAdapter::IsWindowMaximizable ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 598 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    return (window->actions() & MAXIMIZABLE);

  return false;
}
virtual bool WindowManager::IsWindowMaximized ( guint32  xid) [pure virtual, inherited]

Implemented in WindowManagerDummy.

Here is the caller graph for this function:

bool PluginAdapter::IsWindowMaximized ( guint  xid)

Definition at line 404 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
  {
    return ((window->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE);
  }

  return false;
}
bool PluginAdapter::IsWindowMinimizable ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 585 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    return (window->actions() & CompWindowActionMinimizeMask);

  return false;
}
virtual bool WindowManager::IsWindowObscured ( guint32  xid) [pure virtual, inherited]

Implemented in WindowManagerDummy.

Here is the caller graph for this function:

bool PluginAdapter::IsWindowObscured ( guint  xid)

Definition at line 475 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);

  if (window)
  {
    if (window->inShowDesktopMode())
      return true;

    CompPoint window_vp = window->defaultViewport();
    nux::Geometry const& win_geo = GetWindowGeometry(window->id());
    // Check if any windows above this one are blocking it
    for (CompWindow* sibling = window->next; sibling != NULL; sibling = sibling->next)
    {
      if (sibling->defaultViewport() == window_vp
          && !sibling->minimized()
          && sibling->isMapped()
          && sibling->isViewable()
          && (sibling->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE
          && !GetWindowGeometry(sibling->id()).Intersect(win_geo).IsNull())
      {
        return true;
      }
    }
  }

  return false;
}

Here is the call graph for this function:

virtual bool WindowManager::IsWindowOnCurrentDesktop ( guint32  xid) [pure virtual, inherited]

Implemented in WindowManagerDummy.

Here is the caller graph for this function:

Definition at line 459 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
  {
    // we aren't checking window->onCurrentDesktop (), as the name implies, because that is broken
    return (window->defaultViewport() == m_Screen->vp());
  }

  return false;
}
bool PluginAdapter::IsWindowOnTop ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 533 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window = m_Screen->findWindow(win);

  if (window)
  {
    if (window->inShowDesktopMode() || !window->isMapped() || !window->isViewable() || window->minimized())
      return false;

    CompPoint window_vp = window->defaultViewport();
    nux::Geometry const& window_vp_geo = GetWorkAreaGeometry(window->id());
    std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();

    for (CompWindow* sibling = window->next; sibling; sibling = sibling->next)
    {
      if (sibling->defaultViewport() == window_vp && !sibling->minimized() &&
          sibling->isMapped() && sibling->isViewable() && !sibling->inShowDesktopMode() &&
          !(sibling->state() & CompWindowStateAboveMask) &&
          !(sibling->type() & CompWindowTypeSplashMask) &&
          !(sibling->type() & CompWindowTypeDockMask) &&
          /* FIXME: This should be included by the above defaultViewport() check,
           * but it doesn't seem to work correctly when there's only one workspace
           * enabled, so please drop the line above when bug #996604 is fixed in
           * Compiz. */
          !window_vp_geo.Intersect(GetWindowGeometry(sibling->id())).IsNull() &&
          std::find(our_xids.begin(), our_xids.end(), sibling->id()) == our_xids.end())
      {
        return false;
      }
    }

    return true;
  }

  return false;
}

Here is the call graph for this function:

bool PluginAdapter::IsWindowVisible ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 520 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    return !(window->state() & CompWindowStateHiddenMask) && !window->inShowDesktopMode();

  return false;
}
void PluginAdapter::Lower ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 683 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    window->lower();
}
std::string PluginAdapter::MatchStringForXids ( std::vector< Window > *  windows) [private]

Definition at line 334 of file PluginAdapterCompiz.cpp.

{
  std::ostringstream sout;

  sout << "any & (";

  std::vector<Window>::iterator it;
  for (it = windows->begin(); it != windows->end(); ++it)
  {
    sout << "| xid=" << static_cast<int>(*it) << " ";
  }
  sout << ")";

  return sout.str();
}

Here is the caller graph for this function:

bool PluginAdapter::MaximizeIfBigEnough ( CompWindow *  window)

Definition at line 1120 of file PluginAdapterCompiz.cpp.

{
  XClassHint   classHint;
  Status       status;
  std::string  win_wmclass;
  int          num_monitor;

  int          screen_width;
  int          screen_height;
  float        covering_part;

  if (!window)
    return false;

  if ((window->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE)
    return false;

  if (window->type() != CompWindowTypeNormalMask
      || (window->actions() & MAXIMIZABLE) != MAXIMIZABLE)
    return false;

  status = XGetClassHint(m_Screen->dpy(), window->id(), &classHint);
  if (status && classHint.res_class)
  {
    win_wmclass = classHint.res_class;
    XFree(classHint.res_class);

    if (classHint.res_name)
      XFree(classHint.res_name);
  }
  else
    return false;

  num_monitor = window->outputDevice();
  CompOutput &o = m_Screen->outputDevs().at(num_monitor);

  screen_height = o.workArea().height();
  screen_width = o.workArea().width();

  // See bug https://bugs.launchpad.net/unity/+bug/797808
  if (screen_height * screen_width > THRESHOLD_HEIGHT * THRESHOLD_WIDTH)
    return false;

  // use server<parameter> because the window won't show the real parameter as
  // not mapped yet
  const XSizeHints& hints = window->sizeHints();
  covering_part = (float)(window->serverWidth() * window->serverHeight()) / (float)(screen_width * screen_height);
  if ((covering_part < _coverage_area_before_automaximize) || (covering_part > 1.0) ||
      (hints.flags & PMaxSize && (screen_width > hints.max_width || screen_height > hints.max_height)))
  {
    LOG_DEBUG(logger) << win_wmclass << " window size doesn't fit";
    return false;
  }

  window->maximize(MAXIMIZE_STATE);

  return true;
}

Here is the caller graph for this function:

void PluginAdapter::Minimize ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 639 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window && (window->actions() & CompWindowActionMinimizeMask))
    window->minimize();
}
void PluginAdapter::MoveResizeWindow ( guint32  xid,
nux::Geometry  geometry 
) [virtual]

Implements WindowManager.

Definition at line 1275 of file PluginAdapterCompiz.cpp.

{
  int w, h;
  CompWindow* window = m_Screen->findWindow(xid);

  if (!window)
    return;

  if (window->constrainNewWindowSize(geometry.width, geometry.height, &w, &h))
  {
    CompRect workarea = m_Screen->getWorkareaForOutput(window->outputDevice());
    int dx = geometry.x + w - workarea.right() + window->border().right;
    int dy = geometry.y + h - workarea.bottom() + window->border().bottom;

    if (dx > 0)
      geometry.x -= dx;
    if (dy > 0)
      geometry.y -= dy;

    geometry.SetWidth(w);
    geometry.SetHeight(h);
  }

  XWindowChanges xwc;
  xwc.x = geometry.x;
  xwc.y = geometry.y;
  xwc.width = geometry.width;
  xwc.height = geometry.height;

  if (window->mapNum())
    window->sendSyncRequest();

  window->configureXWindow(CWX | CWY | CWWidth | CWHeight, &xwc);
}

Here is the caller graph for this function:

void PluginAdapter::Notify ( CompWindow *  window,
CompWindowNotify  notify 
)

Definition at line 172 of file PluginAdapterCompiz.cpp.

{
  switch (notify)
  {
    case CompWindowNotifyMinimize:
      window_minimized.emit(window->id());
      break;
    case CompWindowNotifyUnminimize:
      window_unminimized.emit(window->id());
      break;
    case CompWindowNotifyShade:
      window_shaded.emit(window->id());
      break;
    case CompWindowNotifyUnshade:
      window_unshaded.emit(window->id());
      break;
    case CompWindowNotifyHide:
      window_hidden.emit(window->id());
      break;
    case CompWindowNotifyShow:
      window_shown.emit(window->id());
      break;
    case CompWindowNotifyMap:
      WindowManager::window_mapped.emit(window->id());
      break;
    case CompWindowNotifyUnmap:
      WindowManager::window_unmapped.emit(window->id());
      break;
    case CompWindowNotifyFocusChange:
      WindowManager::window_focus_changed.emit(window->id());
      break;
    default:
      break;
  }
}

Here is the caller graph for this function:

void PluginAdapter::NotifyCompizEvent ( const char *  plugin,
const char *  event,
CompOption::Vector &  option 
)

Definition at line 209 of file PluginAdapterCompiz.cpp.

{
  if (g_strcmp0(event, "start_viewport_switch") == 0)
  {
    _vp_switch_started = true;
    compiz_screen_viewport_switch_started.emit();
  }
  else if (g_strcmp0(event, "end_viewport_switch") == 0)
  {
    _vp_switch_started = false;
    compiz_screen_viewport_switch_ended.emit();
  }

  compiz_event.emit(plugin, event, option);
}

Here is the caller graph for this function:

void PluginAdapter::NotifyMoved ( CompWindow *  window,
int  x,
int  y 
)

Definition at line 131 of file PluginAdapterCompiz.cpp.

{
  window_moved.emit(window->id());
}

Here is the caller graph for this function:

Definition at line 152 of file PluginAdapterCompiz.cpp.

{
  bool wasTracked = (_window_decoration_state.find (xid) != _window_decoration_state.end ());
  bool wasDecorated = false;

  if (wasTracked)
    wasDecorated = _window_decoration_state[xid];

  bool decorated = IsWindowDecorated (xid);

  if (decorated == wasDecorated)
    return;

  if (decorated && (!wasDecorated || !wasTracked))
    WindowManager::window_decorated.emit(xid);
  else if (wasDecorated || !wasTracked)
    WindowManager::window_undecorated.emit(xid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PluginAdapter::NotifyResized ( CompWindow *  window,
int  x,
int  y,
int  w,
int  h 
)

Definition at line 125 of file PluginAdapterCompiz.cpp.

{
  window_resized.emit(window->id());
}

Here is the caller graph for this function:

void PluginAdapter::NotifyStateChange ( CompWindow *  window,
unsigned int  state,
unsigned int  last_state 
)

Definition at line 137 of file PluginAdapterCompiz.cpp.

{
  if (!((last_state & MAXIMIZE_STATE) == MAXIMIZE_STATE)
      && ((state & MAXIMIZE_STATE) == MAXIMIZE_STATE))
  {
    WindowManager::window_maximized.emit(window->id());
  }
  else if (((last_state & MAXIMIZE_STATE) == MAXIMIZE_STATE)
           && !((state & MAXIMIZE_STATE) == MAXIMIZE_STATE))
  {
    WindowManager::window_restored.emit(window->id());
  }
}

Here is the caller graph for this function:

Definition at line 866 of file PluginAdapterCompiz.cpp.

{
  LOG_DEBUG(logger) << "No longer in show desktop mode.";
  _in_show_desktop = false;
}

Here is the caller graph for this function:

Definition at line 88 of file PluginAdapterCompiz.cpp.

{
  compiz_screen_grabbed.emit();

  if (!_spread_state && screen->grabExist("scale"))
  {
    _spread_state = true;
    initiate_spread.emit();
  }

  if (!_expo_state && screen->grabExist("expo"))
  {
    _expo_state = true;
    initiate_expo.emit();
  }
}

Here is the caller graph for this function:

Definition at line 106 of file PluginAdapterCompiz.cpp.

{
  if (_spread_state && !screen->grabExist("scale"))
  {
    _spread_state = false;
    _spread_windows_state = false;
    terminate_spread.emit();
  }

  if (_expo_state && !screen->grabExist("expo"))
  {
    _expo_state = false;
    terminate_expo.emit();
  }

  compiz_screen_ungrabbed.emit();
}

Here is the caller graph for this function:

Definition at line 859 of file PluginAdapterCompiz.cpp.

{
  LOG_DEBUG(logger) << "Now in show desktop mode.";
  _in_show_desktop = true;
}

Here is the caller graph for this function:

void PluginAdapter::OnWindowClosed ( CompWindow *  w)

Definition at line 1311 of file PluginAdapterCompiz.cpp.

Here is the caller graph for this function:

void PluginAdapter::Raise ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 672 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    window->raise();
}

Definition at line 85 of file Introspectable.cpp.

{
  _children.remove(child);
  child->_parents.remove(this);
}

Here is the caller graph for this function:

void PluginAdapter::Restore ( guint32  xid) [virtual]

Implements WindowManager.

Definition at line 611 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window)
    window->maximize(0);
}
void PluginAdapter::RestoreAt ( guint32  xid,
int  x,
int  y 
) [virtual]

Implements WindowManager.

Definition at line 622 of file PluginAdapterCompiz.cpp.

{
  Window win = xid;
  CompWindow* window;

  window = m_Screen->findWindow(win);
  if (window && (window->state() & MAXIMIZE_STATE))
  {
    nux::Geometry new_geo(GetWindowSavedGeometry(xid));
    new_geo.x = x;
    new_geo.y = y;
    window->maximize(0);
    MoveResizeWindow(xid, new_geo);
  }
}

Here is the call graph for this function:

Implements WindowManager.

Definition at line 1257 of file PluginAdapterCompiz.cpp.

{
  if (_last_focused_window)
  {
    _last_focused_window->moveInputFocusTo ();
    _last_focused_window = NULL;
    return true;
  }
  else
  {
    m_Screen->focusDefaultWindow ();
    return false;
  }

  return false;
}

Here is the caller graph for this function:

bool PluginAdapter::saveInputFocus ( ) [virtual]

Implements WindowManager.

Definition at line 1242 of file PluginAdapterCompiz.cpp.

{
  Window      active = m_Screen->activeWindow ();
  CompWindow* cw = m_Screen->findWindow (active);

  if (cw)
  {
    _last_focused_window = cw;
    return true;
  }

  return false;
}

Here is the caller graph for this function:

bool PluginAdapter::ScaleWindowGroup ( std::vector< Window >  windows,
int  state,
bool  force 
) [virtual]

Implements WindowManager.

Definition at line 816 of file PluginAdapterCompiz.cpp.

{
  if (windows.size() > 1 || (force && windows.size() > 0))
  {
    std::string match = MatchStringForXids(&windows);
    InitiateScale(match, state);
    _spread_windows_state = true;
    return true;
  }
  return false;
}

Here is the call graph for this function:

Definition at line 1236 of file PluginAdapterCompiz.cpp.

Here is the caller graph for this function:

void WindowManager::SetDefault ( WindowManager manager) [static, inherited]

Definition at line 249 of file WindowManager.cpp.

{
  window_manager = manager;
}

Here is the caller graph for this function:

Definition at line 322 of file PluginAdapterCompiz.cpp.

{
  m_ExpoActionList = expo;
}

Here is the caller graph for this function:

void PluginAdapter::SetHideHandlesAction ( CompAction *  action) [inline]

Definition at line 78 of file PluginAdapter.h.

  {
    _grab_hide_action = action;
  }

Here is the caller graph for this function:

void PluginAdapter::SetMwmWindowHints ( Window  xid,
MotifWmHints new_hints 
) [private]

Definition at line 1031 of file PluginAdapterCompiz.cpp.

{
  Display* display = m_Screen->dpy();
  Atom hints_atom = None;
  MotifWmHints* data = NULL;
  MotifWmHints* hints = NULL;
  Atom type = None;
  gint format;
  gulong nitems;
  gulong bytes_after;

  hints_atom = XInternAtom(display, _XA_MOTIF_WM_HINTS, false);

  if (XGetWindowProperty(display,
                         xid,
                         hints_atom, 0, sizeof(MotifWmHints) / sizeof(long),
                         False, AnyPropertyType, &type, &format, &nitems,
                         &bytes_after, (guchar**)&data) != Success)
  {
    return;
  }

  if (type != hints_atom || !data)
  {
    hints = new_hints;
  }
  else
  {
    hints = data;

    if (new_hints->flags & MWM_HINTS_FUNCTIONS)
    {
      hints->flags |= MWM_HINTS_FUNCTIONS;
      hints->functions = new_hints->functions;
    }
    if (new_hints->flags & MWM_HINTS_DECORATIONS)
    {
      hints->flags |= MWM_HINTS_DECORATIONS;
      hints->decorations = new_hints->decorations;
    }
  }

  XChangeProperty(display,
                  xid,
                  hints_atom, hints_atom, 32, PropModeReplace,
                  (guchar*)hints, sizeof(MotifWmHints) / sizeof(long));

  if (data)
    XFree(data);
}

Here is the caller graph for this function:

Definition at line 328 of file PluginAdapterCompiz.cpp.

{
  m_ScaleActionList = scale;
}

Here is the caller graph for this function:

void PluginAdapter::SetShowHandlesAction ( CompAction *  action) [inline]

Definition at line 74 of file PluginAdapter.h.

  {
    _grab_show_action = action;
  }

Here is the caller graph for this function:

void PluginAdapter::SetToggleHandlesAction ( CompAction *  action) [inline]

Definition at line 82 of file PluginAdapter.h.

  {
    _grab_toggle_action = action;
  }

Here is the caller graph for this function:

void PluginAdapter::SetWindowIconGeometry ( Window  window,
nux::Geometry const &  geo 
) [virtual]

Implements WindowManager.

Definition at line 829 of file PluginAdapterCompiz.cpp.

{
  long data[4];

  data[0] = geo.x;
  data[1] = geo.y;
  data[2] = geo.width;
  data[3] = geo.height;

  XChangeProperty(m_Screen->dpy(), window, Atoms::wmIconGeometry,
                  XA_CARDINAL, 32, PropModeReplace,
                  (unsigned char*) data, 4);
}
void PluginAdapter::ShowDesktop ( ) [virtual]

Implements WindowManager.

Definition at line 844 of file PluginAdapterCompiz.cpp.

{
  if (_in_show_desktop)
  {
    LOG_INFO(logger) << "Leaving show-desktop mode.";
    m_Screen->leaveShowDesktopMode(NULL);
  }
  else
  {
    LOG_INFO(logger) << "Entering show-desktop mode.";
    m_Screen->enterShowDesktopMode();
  }
}
void PluginAdapter::ShowGrabHandles ( CompWindow *  window,
bool  use_timer 
)

Definition at line 1180 of file PluginAdapterCompiz.cpp.

{
  if (!_grab_show_action || !window)
    return;

  CompOption::Vector argument;

  argument.resize(3);
  argument[0].setName("root", CompOption::TypeInt);
  argument[0].value().set((int) screen->root());
  argument[1].setName("window", CompOption::TypeInt);
  argument[1].value().set((int) window->id());
  argument[2].setName("use-timer", CompOption::TypeBool);
  argument[2].value().set(use_timer);

  /* Initiate the first available action with the arguments */
  _grab_show_action->initiate()(_grab_show_action, 0, argument);
}

Here is the caller graph for this function:

void WindowManager::StartMove ( guint32  xid,
int  x,
int  y 
) [inherited]

Definition at line 261 of file WindowManager.cpp.

{
  if (x < 0 || y < 0)
    return;

  XEvent ev;
  Display* d = nux::GetGraphicsDisplay()->GetX11Display();

  /* We first need to ungrab the pointer. FIXME: Evil */

  XUngrabPointer(d, CurrentTime);

  // --------------------------------------------------------------------------
  // FIXME: This is a workaround until the non-paired events issue is fixed in
  // nux
  XButtonEvent bev =
  {
    ButtonRelease,
    0,
    False,
    d,
    0,
    0,
    0,
    CurrentTime,
    x, y,
    x, y,
    0,
    Button1,
    True
  };
  XEvent* e = (XEvent*)&bev;
  nux::GetWindowThread()->ProcessForeignEvent(e, NULL);

  ev.xclient.type    = ClientMessage;
  ev.xclient.display = d;

  ev.xclient.serial     = 0;
  ev.xclient.send_event = true;

  ev.xclient.window     = xid;
  ev.xclient.message_type = m_MoveResizeAtom;
  ev.xclient.format     = 32;

  ev.xclient.data.l[0] = x; // x_root
  ev.xclient.data.l[1] = y; // y_root
  ev.xclient.data.l[2] = NET_WM_MOVERESIZE_MOVE; //direction
  ev.xclient.data.l[3] = 1; // button
  ev.xclient.data.l[4] = 2; // source

  XSendEvent(d, DefaultRootWindow(d), FALSE,
             SubstructureRedirectMask | SubstructureNotifyMask,
             &ev);

  XSync(d, FALSE);
}
void PluginAdapter::TerminateScale ( ) [virtual]

Implements WindowManager.

Definition at line 364 of file PluginAdapterCompiz.cpp.

{
  CompOption::Vector argument(0);
  m_ScaleActionList.TerminateAll(argument);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PluginAdapter::ToggleGrabHandles ( CompWindow *  window)

Definition at line 1218 of file PluginAdapterCompiz.cpp.

{
  if (!_grab_toggle_action || !window)
    return;

  CompOption::Vector argument;

  argument.resize(2);
  argument[0].setName("root", CompOption::TypeInt);
  argument[0].value().set((int) screen->root());
  argument[1].setName("window", CompOption::TypeInt);
  argument[1].value().set((int) window->id());

  /* Initiate the first available action with the arguments */
  _grab_toggle_action->initiate()(_grab_toggle_action, 0, argument);
}
void PluginAdapter::Undecorate ( guint32  xid) [virtual]

Reimplemented from WindowManager.

Definition at line 1094 of file PluginAdapterCompiz.cpp.

{
  MotifWmHints hints = { 0 };

  /* Set the high bit to indicate that we undecorated this
   * window, when an application attempts to "undecorate"
   * the window again, this bit will be cleared */
  hints.flags = MWM_HINTS_DECORATIONS;
  hints.decorations = MWM_HINTS_UNDECORATED_UNITY;

  SetMwmWindowHints(xid, &hints);
}

Here is the call graph for this function:

int PluginAdapter::WorkspaceCount ( ) [virtual]

Implements WindowManager.

Definition at line 1025 of file PluginAdapterCompiz.cpp.

{
  return m_Screen->vpSize().width() * m_Screen->vpSize().height();
}

Here is the caller graph for this function:


Member Data Documentation

Definition at line 191 of file PluginAdapter.h.

PluginAdapter * PluginAdapter::_default = 0 [static, private]

Definition at line 198 of file PluginAdapter.h.

Definition at line 184 of file PluginAdapter.h.

CompAction* PluginAdapter::_grab_hide_action [private]

Definition at line 188 of file PluginAdapter.h.

CompAction* PluginAdapter::_grab_show_action [private]

Definition at line 187 of file PluginAdapter.h.

CompAction* PluginAdapter::_grab_toggle_action [private]

Definition at line 189 of file PluginAdapter.h.

Definition at line 193 of file PluginAdapter.h.

CompWindow* PluginAdapter::_last_focused_window [private]

Definition at line 194 of file PluginAdapter.h.

Definition at line 182 of file PluginAdapter.h.

Definition at line 183 of file PluginAdapter.h.

Definition at line 185 of file PluginAdapter.h.

std::map<guint32, unsigned int> PluginAdapter::_window_decoration_state [private]

Definition at line 196 of file PluginAdapter.h.

Definition at line 67 of file PluginAdapter.h.

sigc::signal<void, const char*, const char*, CompOption::Vector&> WindowManager::compiz_event [inherited]

Definition at line 140 of file WindowManager.h.

sigc::signal<void> WindowManager::compiz_screen_grabbed [inherited]

Definition at line 135 of file WindowManager.h.

sigc::signal<void> WindowManager::compiz_screen_ungrabbed [inherited]

Definition at line 136 of file WindowManager.h.

Definition at line 138 of file WindowManager.h.

Definition at line 137 of file WindowManager.h.

sigc::signal<void> WindowManager::initiate_expo [inherited]

Definition at line 132 of file WindowManager.h.

sigc::signal<void> WindowManager::initiate_spread [inherited]

Definition at line 129 of file WindowManager.h.

Definition at line 179 of file PluginAdapter.h.

Definition at line 180 of file PluginAdapter.h.

CompScreen* PluginAdapter::m_Screen [private]

Definition at line 178 of file PluginAdapter.h.

sigc::signal<void> WindowManager::terminate_expo [inherited]

Definition at line 133 of file WindowManager.h.

sigc::signal<void> WindowManager::terminate_spread [inherited]

Definition at line 130 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_decorated [inherited]

Definition at line 126 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_focus_changed [inherited]

Definition at line 125 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_hidden [inherited]

Definition at line 122 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_mapped [inherited]

Definition at line 113 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_maximized [inherited]

Definition at line 115 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_minimized [inherited]

Definition at line 117 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_moved [inherited]

Definition at line 124 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_resized [inherited]

Definition at line 123 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_restored [inherited]

Definition at line 116 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_shaded [inherited]

Definition at line 119 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_shown [inherited]

Definition at line 121 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_undecorated [inherited]

Definition at line 127 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_unmapped [inherited]

Definition at line 114 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_unminimized [inherited]

Definition at line 118 of file WindowManager.h.

sigc::signal<void, guint32> WindowManager::window_unshaded [inherited]

Definition at line 120 of file WindowManager.h.


The documentation for this class was generated from the following files: