Unity

Merge lp:~3v1n0/unity/panel-p-window-buttons into lp:~3v1n0/unity/panel-p-indicators-view

panel-p-window-buttons
Merge into panel-p-indicators-view

Proposed by Marco Trevisan (Treviño) on 2012-03-30

Status:	Merged
Approved by:	Marco Trevisan (Treviño) on 2012-04-02
Approved revision:	no longer in the source branch.
Merge reported by:	Marco Trevisan (Treviño)
Merged at revision:	not available
Proposed branch:	lp:~3v1n0/unity/panel-p-window-buttons
Merge into:	lp:~3v1n0/unity/panel-p-indicators-view
Diff against target:	1037 lines (+620/-232) 2 files modified plugins/unityshell/src/WindowButtons.cpp (+587/-220) plugins/unityshell/src/WindowButtons.h (+33/-12)
To merge this branch:	bzr merge lp:~3v1n0/unity/panel-p-window-buttons
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
Tim Penhey (community)			Approve on 2012-04-02
Marco Trevisan (Treviño)			Pending
Review via email: mp+100123@code.launchpad.net

Description of the change

Window Buttons changes, see https://code.launchpad.net/~3v1n0/unity/panel-p-cleanup/+merge/99950

Revision history for this message

Tim Penhey (thumper) wrote on 2012-04-02:

Looks OK, but I still recommend some real interactive testing :)

review: Approve

Revision history for this message

Marco Trevisan (Treviño) (3v1n0) wrote on 2012-04-02:

That is coming... ;)

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Marco Trevisan (Treviño)

 === modified file 'plugins/unityshell/src/WindowButtons.cpp'
 --- plugins/unityshell/src/WindowButtons.cpp	2012-03-21 12:31:11 +0000
 +++ plugins/unityshell/src/WindowButtons.cpp	2012-04-04 20:17:24 +0000
@@ -1,6 +1,6 @@
  // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
  /*
-- * Copyright (C) 2010 Canonical Ltd
++ * Copyright (C) 2010-2012 Canonical Ltd
+  *
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 3 as
@@ -15,125 +15,139 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  *
   * Authored by: Neil Jagdish Patel <neil.patel@canonical.com>
++ *              Marco Trevisan (Treviño) <3v1n0@ubuntu.com>
   */
  #include "config.h"
  #include <Nux/Nux.h>
--#include <Nux/HLayout.h>
--#include <Nux/VLayout.h>
--#include <Nux/Button.h>
--
--#include <NuxGraphics/GLThread.h>
--#include <Nux/BaseWindow.h>
--#include <Nux/WindowCompositor.h>
--
++
++#include <UnityCore/GLibWrapper.h>
  #include <UnityCore/Variant.h>
++
  #include "WindowButtons.h"
--#include "ubus-server.h"
--#include "UBusMessages.h"
--
  #include "DashSettings.h"
  #include "PanelStyle.h"
--
--#include <UnityCore/GLibWrapper.h>
++#include "UBusMessages.h"
++#include "WindowManager.h"
  namespace unity
+ {
--class WindowButton : public nux::Button
++class WindowButton : public nux::Button, public debug::Introspectable
+ {
    // A single window button
  public:
    WindowButton(panel::WindowButtonType type)
--    : nux::Button("", NUX_TRACKER_LOCATION),
--      _type(type),
--      _overlay_is_open(false),
--      _mouse_is_down(false),
--      _place_shown_interest(0),
--      _place_hidden_interest(0),
--      _opacity(1.0f)
++    : nux::Button("", NUX_TRACKER_LOCATION)
++    , _type(type)
++    , _focused(true)
++    , _overlay_is_open(false)
++    , _opacity(1.0f)
+   {
++    panel::Style::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::LoadImages));
      LoadImages();
--    UpdateDashUnmaximize();
--    panel::Style::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::LoadImages));
--    dash::Settings::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::UpdateDashUnmaximize));
--
--    UBusServer* ubus = ubus_server_get_default();
--    _place_shown_interest = ubus_server_register_interest(ubus, UBUS_OVERLAY_SHOWN,
--                                                          (UBusCallback)&WindowButton::OnOverlayShown,
--                                                          this);
--    _place_hidden_interest = ubus_server_register_interest(ubus, UBUS_OVERLAY_HIDDEN,
--                                                           (UBusCallback)&WindowButton::OnOverlayHidden,
--                                                           this);
--
--    /* FIXME HasMouseFocus() doesn't seem to work correctly, so we use this workaround */
--    mouse_down.connect([&_mouse_is_down](int, int, unsigned long, unsigned long) {
--      _mouse_is_down = true;
--    });
--    mouse_up.connect([&_mouse_is_down](int, int, unsigned long, unsigned long) {
--      _mouse_is_down = false;
--    });
+   }
--  ~WindowButton()
++  void SetVisualState(nux::ButtonVisualState new_state)
+   {
--    UBusServer* ubus = ubus_server_get_default();
--    if (_place_shown_interest != 0)
--      ubus_server_unregister_interest(ubus, _place_shown_interest);
--    if (_place_hidden_interest != 0)
--      ubus_server_unregister_interest(ubus, _place_hidden_interest);
++    if (new_state != visual_state_)
++    {
++      visual_state_ = new_state;
++      QueueDraw();
++    }
+   }
    void Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+   {
--    nux::Geometry      geo = GetGeometry();
--    nux::BaseTexture*  tex = nullptr;
++    nux::Geometry const& geo = GetGeometry();
++    nux::BaseTexture* tex;
      nux::TexCoordXForm texxform;
      GfxContext.PushClippingRectangle(geo);
      if (_overlay_is_open)
+     {
--      if (_type == panel::WindowButtonType::UNMAXIMIZE && !_overlay_can_maximize)
++      if (!IsEnabled())
+       {
          tex = _disabled_dash_tex.GetPointer();
+       }
        else
+       {
--        //FIXME should use HasMouseFocus()
--        if (_mouse_is_down && IsMouseInside())
--          tex = _pressed_dash_tex.GetPointer();
--        else if (IsMouseInside())
--          tex = _prelight_dash_tex.GetPointer();
--        else
--          tex = _normal_dash_tex.GetPointer();
++        switch (visual_state_)
++        {
++          case nux::VISUAL_STATE_PRESSED:
++            tex = _pressed_dash_tex.GetPointer();
++            break;
++          case nux::VISUAL_STATE_PRELIGHT:
++            tex = _prelight_dash_tex.GetPointer();
++            break;
++          default:
++            tex = _normal_dash_tex.GetPointer();
++        }
++      }
++    }
++    else if (!IsEnabled())
++    {
++      tex = _disabled_tex.GetPointer();
++    }
++    else if (!_focused)
++    {
++      switch (visual_state_)
++      {
++        case nux::VISUAL_STATE_PRESSED:
++          tex = _unfocused_pressed_tex.GetPointer();
++          break;
++        case nux::VISUAL_STATE_PRELIGHT:
++          tex = _unfocused_prelight_tex.GetPointer();
++          break;
++        default:
++          tex = _unfocused_tex.GetPointer();
+       }
+     }
      else
+     {
--      //FIXME should use HasMouseFocus()
--      if (_mouse_is_down && IsMouseInside())
--        tex = _pressed_tex.GetPointer();
--      else if (IsMouseInside())
--        tex = _prelight_tex.GetPointer();
--      else
--        tex = _normal_tex.GetPointer();
++      switch (visual_state_)
++      {
++        case nux::VISUAL_STATE_PRESSED:
++          tex = _pressed_tex.GetPointer();
++          break;
++        case nux::VISUAL_STATE_PRELIGHT:
++          tex = _prelight_tex.GetPointer();
++          break;
++        default:
++          tex = _normal_tex.GetPointer();
++      }
+     }
      if (tex)
--      GfxContext.QRP_1Tex(geo.x,
--                          geo.y,
--                          (float)geo.width,
--                          (float)geo.height,
--                          tex->GetDeviceTexture(),
--                          texxform,
++    {
++      GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
++                          tex->GetDeviceTexture(), texxform,
                            nux::color::White * _opacity);
++    }
      GfxContext.PopClippingRectangle();
+   }
++  void UpdateSize()
++  {
++    int panel_height = panel::Style::Instance().panel_height;
++    nux::BaseTexture* tex;
++    tex = (_overlay_is_open) ? _normal_dash_tex.GetPointer() : _normal_tex.GetPointer();
++    int width = 0;
++    int height = 0;
++
++    if (tex)
++    {
++      width = std::min(panel_height, tex->GetWidth());
++      height = std::min(panel_height, tex->GetHeight());
++    }
++
++    SetMinMaxSize(width, height);
++  }
++
    void LoadImages()
+   {
      panel::Style& style = panel::Style::Instance();
@@ -141,53 +155,16 @@
      _normal_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::NORMAL));
      _prelight_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::PRELIGHT));
      _pressed_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::PRESSED));
++    _unfocused_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::UNFOCUSED));
++    _disabled_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::DISABLED));
++    _unfocused_prelight_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::UNFOCUSED_PRELIGHT));
++    _unfocused_pressed_tex.Adopt(style.GetWindowButton(_type, panel::WindowState::UNFOCUSED_PRESSED));
      _normal_dash_tex.Adopt(GetDashWindowButton(_type, panel::WindowState::NORMAL));
      _prelight_dash_tex.Adopt(GetDashWindowButton(_type, panel::WindowState::PRELIGHT));
      _pressed_dash_tex.Adopt(GetDashWindowButton(_type, panel::WindowState::PRESSED));
--
--    if (_overlay_is_open)
--    {
--      if (_normal_dash_tex)
--        SetMinMaxSize(_normal_dash_tex->GetWidth(), _normal_dash_tex->GetHeight());
--    }
--    else
--    {
--      if (_normal_tex)
--        SetMinMaxSize(_normal_tex->GetWidth(), _normal_tex->GetHeight());
--    }
--
--    QueueDraw();
--  }
--
--  void UpdateDashUnmaximize()
--  {
--    // only update the unmaximize button
--    if (_type != panel::WindowButtonType::UNMAXIMIZE)
--      return;
--
--    panel::WindowButtonType real_type = panel::WindowButtonType::UNMAXIMIZE;
--
--    if (dash::Settings::Instance().GetFormFactor() == dash::FormFactor::DESKTOP)
--    {
--      real_type = panel::WindowButtonType::MAXIMIZE;
--    }
--
--    //!!FIXME!! - don't have disabled instances of the (un)maximize buttons
--    // get (un)maximize buttons
--    _normal_dash_tex.Adopt(GetDashWindowButton(real_type, panel::WindowState::NORMAL));
--    _prelight_dash_tex.Adopt(GetDashWindowButton(real_type, panel::WindowState::PRELIGHT));
--    _pressed_dash_tex.Adopt(GetDashWindowButton(real_type, panel::WindowState::PRESSED));
--    _disabled_dash_tex.Adopt(GetDashWindowButton(real_type, panel::WindowState::DISABLED));
--
--    // still check if the dash is really opened,
--    // someone could change the form factor through dconf
--    // when the dash is closed
--    if (_overlay_is_open)
--    {
--      if (_normal_dash_tex)
--        SetMinMaxSize(_normal_dash_tex->GetWidth(), _normal_dash_tex->GetHeight());
--    }
--
++    _disabled_dash_tex.Adopt(GetDashWindowButton(_type, panel::WindowState::DISABLED));
++
++    UpdateSize();
      QueueDraw();
+   }
@@ -196,62 +173,135 @@
      if (_opacity != opacity)
+     {
        _opacity = opacity;
--      NeedRedraw();
++      QueueDraw();
+     }
+   }
--  double GetOpacity()
++  double GetOpacity() const
+   {
      return _opacity;
+   }
++  void SetFocusedState(bool focused)
++  {
++    if (_focused != focused)
++    {
++      _focused = focused;
++      QueueDraw();
++    }
++  }
++
++  void SetOverlayOpen(bool open)
++  {
++    if (_overlay_is_open == open)
++      return;
++
++    _overlay_is_open = open;
++
++    UpdateSize();
++    QueueDraw();
++  }
++
++  bool IsOverlayOpen()
++  {
++    return _overlay_is_open;
++  }
++
++  panel::WindowButtonType GetType() const
++  {
++    return _type;
++  }
++
++  void ChangeType(panel::WindowButtonType new_type)
++  {
++    if (_type != new_type)
++    {
++      _type = new_type;
++      LoadImages();
++    }
++  }
++
++  void SetEnabled(bool enabled)
++  {
++    if (enabled == IsEnabled())
++      return;
++
++    SetEnableView(enabled);
++    QueueDraw();
++  }
++
++  bool IsEnabled()
++  {
++    return IsViewEnabled();
++  }
++
++protected:
++  std::string GetName() const
++  {
++    return "Button";
++  }
++
++  void AddProperties(GVariantBuilder* builder)
++  {
++    std::string type_name;
++    std::string state_name;
++
++    switch (_type)
++    {
++      case panel::WindowButtonType::CLOSE:
++        type_name = "Close";
++        break;
++      case panel::WindowButtonType::MINIMIZE:
++        type_name = "Minimize";
++        break;
++      case panel::WindowButtonType::MAXIMIZE:
++        type_name = "Maximize";
++        break;
++      case panel::WindowButtonType::UNMAXIMIZE:
++        type_name = "Unmaximize";
++        break;
++    }
++
++    switch (visual_state_)
++    {
++      case nux::VISUAL_STATE_PRESSED:
++        state_name = "pressed";
++        break;
++      case nux::VISUAL_STATE_PRELIGHT:
++        state_name = "prelight";
++        break;
++      default:
++        state_name = "normal";
++    }
++
++    variant::BuilderWrapper(builder).add(GetGeometry())
++                                    .add("type", type_name)
++                                    .add("visible", IsVisible())
++                                    .add("enabled", IsEnabled())
++                                    .add("visual_state", state_name)
++                                    .add("opacity", _opacity)
++                                    .add("focused", _focused)
++                                    .add("overlay_mode", _overlay_is_open);
++  }
++
++
  private:
    panel::WindowButtonType _type;
--  typedef nux::ObjectPtr<nux::BaseTexture> BaseTexturePtr;
--  BaseTexturePtr _normal_tex;
--  BaseTexturePtr _prelight_tex;
--  BaseTexturePtr _pressed_tex;
--  BaseTexturePtr _normal_dash_tex;
--  BaseTexturePtr _prelight_dash_tex;
--  BaseTexturePtr _pressed_dash_tex;
--  BaseTexturePtr _disabled_dash_tex;
--
++  bool _focused;
    bool _overlay_is_open;
--  bool _overlay_can_maximize;
--  bool _mouse_is_down;
--  guint32 _place_shown_interest;
--  guint32 _place_hidden_interest;
    double _opacity;
--  static void OnOverlayShown(GVariant* data, void* val)
--  {
--    unity::glib::String overlay_identity;
--    gboolean can_maximise = FALSE;
--    gint32 overlay_monitor = 0;
--    g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
--                  &overlay_identity, &can_maximise, &overlay_monitor);
--
--    WindowButton* self = (WindowButton*)val;
--
--    self->_overlay_is_open = true;
--    if (self->_normal_dash_tex)
--      self->SetMinMaxSize(self->_normal_dash_tex->GetWidth(), self->_normal_dash_tex->GetHeight());
--
--    self->_overlay_can_maximize = (can_maximise) ? true : false;
--
--    self->QueueDraw();
--  }
--
--  static void OnOverlayHidden(GVariant* data, void* val)
--  {
--    WindowButton* self = (WindowButton*)val;
--
--    self->_overlay_is_open = false;
--    if (self->_normal_tex)
--      self->SetMinMaxSize(self->_normal_tex->GetWidth(), self->_normal_tex->GetHeight());
--
--    self->QueueDraw();
--  }
++  nux::ObjectPtr<nux::BaseTexture> _normal_tex;
++  nux::ObjectPtr<nux::BaseTexture> _prelight_tex;
++  nux::ObjectPtr<nux::BaseTexture> _pressed_tex;
++  nux::ObjectPtr<nux::BaseTexture> _unfocused_tex;
++  nux::ObjectPtr<nux::BaseTexture> _unfocused_prelight_tex;
++  nux::ObjectPtr<nux::BaseTexture> _unfocused_pressed_tex;
++  nux::ObjectPtr<nux::BaseTexture> _disabled_tex;
++  nux::ObjectPtr<nux::BaseTexture> _normal_dash_tex;
++  nux::ObjectPtr<nux::BaseTexture> _prelight_dash_tex;
++  nux::ObjectPtr<nux::BaseTexture> _pressed_dash_tex;
++  nux::ObjectPtr<nux::BaseTexture> _disabled_dash_tex;
    nux::BaseTexture* GetDashWindowButton(panel::WindowButtonType type,
                                          panel::WindowState state)
@@ -282,7 +332,10 @@
  WindowButtons::WindowButtons()
    : HLayout("", NUX_TRACKER_LOCATION)
--  , _opacity(1.0f)
++  , monitor_(0)
++  , opacity_(1.0f)
++  , focused_(true)
++  , window_xid_(0)
+ {
    WindowButton* but;
@@ -303,94 +356,408 @@
    but = new WindowButton(panel::WindowButtonType::CLOSE);
    AddView(but, 0, nux::eCenter, nux::eFix);
--  but->state_change.connect(sigc::mem_fun(this, &WindowButtons::OnCloseClicked));
++  AddChild(but);
++  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnCloseClicked));
    but->mouse_enter.connect(lambda_enter);
    but->mouse_leave.connect(lambda_leave);
    but->mouse_move.connect(lambda_moved);
    but = new WindowButton(panel::WindowButtonType::MINIMIZE);
    AddView(but, 0, nux::eCenter, nux::eFix);
--  but->state_change.connect(sigc::mem_fun(this, &WindowButtons::OnMinimizeClicked));
++  AddChild(but);
++  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMinimizeClicked));
    but->mouse_enter.connect(lambda_enter);
    but->mouse_leave.connect(lambda_leave);
    but->mouse_move.connect(lambda_moved);
    but = new WindowButton(panel::WindowButtonType::UNMAXIMIZE);
    AddView(but, 0, nux::eCenter, nux::eFix);
--  but->state_change.connect(sigc::mem_fun(this, &WindowButtons::OnRestoreClicked));
--  but->mouse_enter.connect(lambda_enter);
--  but->mouse_leave.connect(lambda_leave);
--  but->mouse_move.connect(lambda_moved);
++  AddChild(but);
++  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnRestoreClicked));
++  but->mouse_enter.connect(lambda_enter);
++  but->mouse_leave.connect(lambda_leave);
++  but->mouse_move.connect(lambda_moved);
++
++  but = new WindowButton(panel::WindowButtonType::MAXIMIZE);
++  AddView(but, 0, nux::eCenter, nux::eFix);
++  AddChild(but);
++  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMaximizeClicked));
++  but->mouse_enter.connect(lambda_enter);
++  but->mouse_leave.connect(lambda_leave);
++  but->mouse_move.connect(lambda_moved);
++  but->SetVisible(false);
    SetContentDistribution(nux::eStackLeft);
--}
--
--
--WindowButtons::~WindowButtons()
--{
--}
--
--void
--WindowButtons::OnCloseClicked(nux::View* view)
--{
++
++  ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &WindowButtons::OnOverlayShown));
++  ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &WindowButtons::OnOverlayHidden));
++  dash::Settings::Instance().changed.connect(sigc::mem_fun(this, &WindowButtons::OnDashSettingsUpdated));
++}
++
++nux::Area* WindowButtons::FindAreaUnderMouse(const nux::Point& mouse, nux::NuxEventType event_type)
++{
++  /* The first button should be clickable on the left space too, to
++   * make Fitts happy. All also on their top side. See bug #839690 */
++  bool first_found = false;
++
++  for (auto area : GetChildren())
++  {
++    if (area->IsVisible() && area->GetInputEventSensitivity())
++    {
++      nux::Geometry const& geo = area->GetAbsoluteGeometry();
++
++      if (!first_found)
++      {
++        first_found = true;
++
++        if (mouse.x < geo.x && mouse.y < (geo.y + geo.height))
++          return area;
++      }
++
++      if (geo.IsPointInside(mouse.x, mouse.y))
++        return area;
++
++      if (mouse.x >= geo.x && mouse.x <= (geo.x + geo.width) && mouse.y <= geo.y)
++        return area;
++    }
++  }
++
++  return nullptr;
++}
++
++void WindowButtons::OnCloseClicked(nux::Button *button)
++{
++  auto win_button = dynamic_cast<WindowButton*>(button);
++
++  if (!win_button || !win_button->IsEnabled())
++    return;
++
++  if (win_button->IsOverlayOpen())
++  {
++    ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
++  }
++  else
++  {
++    WindowManager::Default()->Close(window_xid_);
++  }
++
    close_clicked.emit();
+ }
--void
--WindowButtons::OnMinimizeClicked(nux::View* view)
++void WindowButtons::OnMinimizeClicked(nux::Button *button)
+ {
++  auto win_button = dynamic_cast<WindowButton*>(button);
++
++  if (!win_button || !win_button->IsEnabled())
++    return;
++
++  if (!win_button->IsOverlayOpen())
++    WindowManager::Default()->Minimize(window_xid_);
++
    minimize_clicked.emit();
+ }
--void
--WindowButtons::OnRestoreClicked(nux::View* view)
++void WindowButtons::OnRestoreClicked(nux::Button *button)
+ {
++  auto win_button = dynamic_cast<WindowButton*>(button);
++
++  if (!win_button || !win_button->IsEnabled())
++    return;
++
++  if (win_button->IsOverlayOpen())
++  {
++    dash::Settings::Instance().SetFormFactor(dash::FormFactor::DESKTOP);
++  }
++  else
++  {
++    WindowManager* wm = WindowManager::Default();
++    Window to_restore = window_xid_;
++
++    wm->Raise(to_restore);
++    wm->Activate(to_restore);
++    wm->Restore(to_restore);
++  }
++
    restore_clicked.emit();
+ }
--nux::Area*
--WindowButtons::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
--{
--  return nux::HLayout::FindAreaUnderMouse(mouse_position, event_type);
--}
--
--void
--WindowButtons::SetOpacity(double opacity)
++void WindowButtons::OnMaximizeClicked(nux::Button *button)
++{
++  auto win_button = dynamic_cast<WindowButton*>(button);
++
++  if (!win_button || !win_button->IsEnabled())
++    return;
++
++  if (win_button->IsOverlayOpen())
++  {
++    dash::Settings::Instance().SetFormFactor(dash::FormFactor::NETBOOK);
++  }
++
++  maximize_clicked.emit();
++}
++
++void WindowButtons::OnOverlayShown(GVariant* data)
++{
++  WindowButton* maximize_button = nullptr;
++  WindowButton* restore_button = nullptr;
++  glib::String overlay_identity;
++  gboolean can_maximise = FALSE;
++  gint32 overlay_monitor = 0;
++  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
++                &overlay_identity, &can_maximise, &overlay_monitor);
++
++  if (overlay_monitor != monitor_)
++  {
++    for (auto area : GetChildren())
++    {
++      auto button = dynamic_cast<WindowButton*>(area);
++
++      if (button)
++        button->SetEnabled(false);
++    }
++
++    return;
++  }
++
++  active_overlay_ = overlay_identity.Str();
++
++  for (auto area : GetChildren())
++  {
++    auto button = dynamic_cast<WindowButton*>(area);
++
++    if (button)
++    {
++      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
++        restore_button = button;
++
++      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
++        maximize_button = button;
++
++      button->SetOverlayOpen(true);
++    }
++  }
++
++  if (restore_button && maximize_button)
++  {
++    dash::Settings &dash_settings = dash::Settings::Instance();
++    bool maximizable = (dash_settings.GetFormFactor() == dash::FormFactor::DESKTOP);
++
++    restore_button->SetEnabled(can_maximise);
++    maximize_button->SetEnabled(can_maximise);
++
++    if (maximizable != maximize_button->IsVisible())
++    {
++      if (maximize_button->IsVisible())
++        restore_button->SetVisualState(maximize_button->GetVisualState());
++      else if (restore_button->IsVisible())
++        maximize_button->SetVisualState(restore_button->GetVisualState());
++
++      restore_button->SetVisible(!maximizable);
++      maximize_button->SetVisible(maximizable);
++
++      QueueDraw();
++    }
++  }
++}
++
++void WindowButtons::OnOverlayHidden(GVariant* data)
++{
++  WindowButton* maximize_button = nullptr;
++  WindowButton* restore_button = nullptr;
++
++  glib::String overlay_identity;
++  gboolean can_maximise = FALSE;
++  gint32 overlay_monitor = 0;
++  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
++                &overlay_identity, &can_maximise, &overlay_monitor);
++
++  if (overlay_monitor != monitor_)
++  {
++    for (auto area : GetChildren())
++    {
++      auto button = dynamic_cast<WindowButton*>(area);
++
++      if (button)
++        button->SetEnabled(true);
++    }
++  }
++
++  if (active_overlay_ != overlay_identity.Str())
++    return;
++
++  active_overlay_ = "";
++
++  for (auto area : GetChildren())
++  {
++    auto button = dynamic_cast<WindowButton*>(area);
++
++    if (button)
++    {
++      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
++        restore_button = button;
++
++      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
++        maximize_button = button;
++
++      button->SetOverlayOpen(false);
++    }
++  }
++
++  if (restore_button && maximize_button)
++  {
++    restore_button->SetEnabled(true);
++    maximize_button->SetEnabled(true);
++
++    if (!restore_button->IsVisible())
++    {
++      restore_button->SetVisualState(maximize_button->GetVisualState());
++
++      restore_button->SetVisible(true);
++      maximize_button->SetVisible(false);
++
++      QueueDraw();
++    }
++  }
++}
++
++void WindowButtons::OnDashSettingsUpdated()
++{
++  WindowButton* maximize_button = nullptr;
++  WindowButton* restore_button = nullptr;
++
++  for (auto area : GetChildren())
++  {
++    auto button = dynamic_cast<WindowButton*>(area);
++
++    if (button)
++    {
++      if (!button->IsOverlayOpen())
++        break;
++
++      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
++        restore_button = button;
++
++      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
++        maximize_button = button;
++
++      if (restore_button && maximize_button)
++        break;
++    }
++  }
++
++  if (restore_button && restore_button->IsOverlayOpen() && maximize_button)
++  {
++    dash::Settings &dash_settings = dash::Settings::Instance();
++    bool maximizable = (dash_settings.GetFormFactor() == dash::FormFactor::DESKTOP);
++
++    if (maximizable != maximize_button->IsVisible())
++    {
++      if (maximize_button->IsVisible())
++        restore_button->SetVisualState(maximize_button->GetVisualState());
++      else if (restore_button->IsVisible())
++        maximize_button->SetVisualState(restore_button->GetVisualState());
++
++      restore_button->SetVisible(!maximizable);
++      maximize_button->SetVisible(maximizable);
++
++      QueueDraw();
++    }
++  }
++}
++
++void WindowButtons::SetOpacity(double opacity)
+ {
    opacity = CLAMP(opacity, 0.0f, 1.0f);
    for (auto area : GetChildren())
+   {
--    auto but = dynamic_cast<WindowButton*>(area);
--
--    if (but)
--      but->SetOpacity(opacity);
--  }
--
--  if (_opacity != opacity)
--  {
--    _opacity = opacity;
--    NeedRedraw();
--  }
--}
--
--double
--WindowButtons::GetOpacity()
--{
--  return _opacity;
--}
--
--std::string
--WindowButtons::GetName() const
--{
--  return "window-buttons";
--}
--
--void
--WindowButtons::AddProperties(GVariantBuilder* builder)
--{
--  unity::variant::BuilderWrapper(builder).add(GetGeometry());
--}
--
--
--} // namespace unity
++    auto button = dynamic_cast<WindowButton*>(area);
++
++    if (button)
++      button->SetOpacity(opacity);
++  }
++
++  if (opacity_ != opacity)
++  {
++    opacity_ = opacity;
++    QueueDraw();
++  }
++}
++
++double WindowButtons::GetOpacity()
++{
++  return opacity_;
++}
++
++void WindowButtons::SetFocusedState(bool focused)
++{
++  for (auto area : GetChildren())
++  {
++    auto button = dynamic_cast<WindowButton*>(area);
++
++    if (button)
++      button->SetFocusedState(focused);
++  }
++
++  if (focused_ != focused)
++  {
++    focused_ = focused;
++    QueueDraw();
++  }
++}
++
++bool WindowButtons::GetFocusedState()
++{
++  return focused_;
++}
++
++void WindowButtons::SetControlledWindow(Window xid)
++{
++  if (xid != window_xid_)
++  {
++    window_xid_ = xid;
++
++    for (auto area : GetChildren())
++    {
++      auto button = dynamic_cast<WindowButton*>(area);
++
++      if (button->GetType() == panel::WindowButtonType::MINIMIZE)
++      {
++        bool minimizable = WindowManager::Default()->IsWindowMinimizable(xid);
++        button->SetEnabled(minimizable);
++        break;
++      }
++    }
++  }
++}
++
++Window WindowButtons::GetControlledWindow()
++{
++  return window_xid_;
++}
++
++void WindowButtons::SetMonitor(int monitor)
++{
++  monitor_ = monitor;
++}
++
++int WindowButtons::GetMonitor()
++{
++  return monitor_;
++}
++
++std::string WindowButtons::GetName() const
++{
++  return "WindowButtons";
++}
++
++void WindowButtons::AddProperties(GVariantBuilder* builder)
++{
++  variant::BuilderWrapper(builder).add(GetGeometry())
++                                  .add("monitor", monitor_)
++                                  .add("opacity", opacity_)
++                                  .add("focused", focused_)
++                                  .add("controlled_window", window_xid_);
++}
++
++} // unity namespace
 === modified file 'plugins/unityshell/src/WindowButtons.h'
 --- plugins/unityshell/src/WindowButtons.h	2012-02-25 16:19:39 +0000
 +++ plugins/unityshell/src/WindowButtons.h	2012-04-04 20:17:24 +0000
@@ -1,6 +1,6 @@
  // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
  /*
-- * Copyright (C) 2010 Canonical Ltd
++ * Copyright (C) 2010-2012 Canonical Ltd
+  *
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 3 as
@@ -15,49 +15,70 @@
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+  *
   * Authored by: Neil Jagdish Patel <neil.patel@canonical.com>
++ *              Marco Trevisan (Treviño) <3v1n0@ubuntu.com>
   */
  #ifndef WINDOW_BUTTONS_H
  #define WINDOW_BUTTONS_H
  #include <Nux/HLayout.h>
--#include <Nux/View.h>
++#include <Nux/Button.h>
++#include "UBusWrapper.h"
  #include "Introspectable.h"
  namespace unity
+ {
--class WindowButtons : public nux::HLayout, public unity::debug::Introspectable
++class WindowButtons : public nux::HLayout, public debug::Introspectable
+ {
    // These are the [close][minimize][restore] buttons on the panel when there
    // is a maximized window
  public:
    WindowButtons();
--  ~WindowButtons();
    void SetOpacity(double opacity);
    double GetOpacity();
++  void SetFocusedState(bool focused);
++  bool GetFocusedState();
++
++  void SetControlledWindow(Window xid);
++  Window GetControlledWindow();
++
++  void SetMonitor(int monitor);
++  int GetMonitor();
++
++  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_pos, nux::NuxEventType event_type);
++
    sigc::signal<void> close_clicked;
    sigc::signal<void> minimize_clicked;
    sigc::signal<void> restore_clicked;
++  sigc::signal<void> maximize_clicked;
    sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_move;
    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_enter;
    sigc::signal<void, int, int, unsigned long, unsigned long> mouse_leave;
--  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type);
--
  protected:
    std::string GetName() const;
--  void          AddProperties(GVariantBuilder* builder);
++  void AddProperties(GVariantBuilder* builder);
  private:
--  void OnCloseClicked(nux::View *view);
--  void OnMinimizeClicked(nux::View *view);
--  void OnRestoreClicked(nux::View *view);
--
--  double _opacity;
++  void OnCloseClicked(nux::Button *button);
++  void OnMinimizeClicked(nux::Button *button);
++  void OnRestoreClicked(nux::Button *button);
++  void OnMaximizeClicked(nux::Button *button);
++  void OnOverlayShown(GVariant* data);
++  void OnOverlayHidden(GVariant* data);
++  void OnDashSettingsUpdated();
++
++  int monitor_;
++  double opacity_;
++  bool focused_;
++  Window window_xid_;
++  std::string active_overlay_;
++
++  UBusManager ubus_manager_;
  };
+ }
  #endif

Unity

Merge lp:~3v1n0/unity/panel-p-window-buttons into lp:~3v1n0/unity/panel-p-indicators-view

Commit message

Description of the change

Preview Diff

Subscribers