Merge lp:~3v1n0/unity/lim-panel into lp:unity

[Marco Trevisan (Treviño)]

UI work for the Locally Integrated Menus support for the unity panel.

I've made some code improvements and rewrite to PanelStyle, PanelMenuView, PanelIndicatorEntryView, PanelTitlebarGrabArea and WindowButtons, plus I've added the new class PanelIndicatorAppmenuView which is a special indicator that is created when the PanelMenu is in the "integrated-mode". In that case the appmenu view is populated with the indicator entry (that won't ever change) and updated against the window status changes to match the content of the currently maximized window on top of the stack.

Using the integrated menu, the appmenu-indicator is also capable of being dragged down, middle-clicked and double-clicked exactly like the PanelTitlebarGrabArea. When clicking on it, if the mouse-up event happens after 120ms the mouse-down, we just consider that action as a grab and we start acting accordingly.

Updated 17/02:
Fixed also bug #934680, added some new features to WindowManager, some of them imported from lp:~3v1n0/unity/super-arrows-shortcuts:

GetWindowSavedGeometry: returns the window saved geometry, that it doesn't
                        consider if the window is maximized or not.
MoveResizeWindow: the name should say what it does ;)
GetWorkAreaGeometry: returns the size of the work-area for the given
                     window of for the current output (if xid = 0),
                     It considers the struts geometries.
RestoreAt: restores a window and move it at the given x, y position
           keeping the standard geometry.

[Michal Hruby (mhr3)]

8 +BuilderWrapper& BuilderWrapper::add(char const* name, long int value)
9 +{
10 + g_variant_builder_add(builder_, "{sv}", name, g_variant_new_int64(value));

long is 32-bit on i386, if you really need 64bit value this should be changed to "long long".

[Marco Trevisan (Treviño) (3v1n0)]

> 8 +BuilderWrapper& BuilderWrapper::add(char const* name, long int value)
> 9 +{
> 10 + g_variant_builder_add(builder_, "{sv}", name,
> g_variant_new_int64(value));
>
> long is 32-bit on i386, if you really need 64bit value this should be changed
> to "long long".

Right. I've added wrappers for long long too, anyway I'm keeping the variant as a gint64 also for long int, to make sure it's working also on 64bit...

[Sam Spilsbury (smspillaz)]

"The diff has been truncated for viewing. "

Try to avoid doing too much rewriting in any one branch :)

466 PanelIndicatorEntryView::~PanelIndicatorEntryView()
467 {
468 - on_indicator_activate_changed_connection_.disconnect();
469 - on_indicator_updated_connection_.disconnect();
470 - on_panelstyle_changed_connection_.disconnect();
471 - g_signal_handler_disconnect(gtk_settings_get_default(), on_font_changed_connection_);
472 - if (texture_layer_)
473 - delete texture_layer_;
474 + // Nothing to do...
475 }

The empty destructor's definition can be removed (unless its virtual)

+ if (!wm->IsExpoActive() && !wm->IsScaleActive())
490 + {

This probably doesn't make sense living where it is. The Panel views should block all clicks if if the screen is grabbed by compiz period (eg, add a wrapper method in WindowManager around CompScreen::otherGrabExist (NULL);)

3181 + /* FIXME, this can be removed when window_unmapped WindowManager signal
3182 + * will emit the proper xid */
3183 + Window xid = bamf_window_get_xid(reinterpret_cast<BamfWindow*>(view));
3184 + OnWindowUnmapped(xid);

Can you explain this? It could be emitting the frame xid, and that needs to be fixed there :)

nvm found it

3391 + // FIXME: compiz doesn't give us a valid xid (is always 0 on unmap)
3392 + // we need to do this again on BamfView closed signal.

Great. I'll fix that in compiz then. (This is probably the case when the window is destroyed and the xid is changed to zero, and then the unmap signal happens)

The window management stuff looks great.

[Marco Trevisan (Treviño) (3v1n0)]

> "The diff has been truncated for viewing. "
>
> Try to avoid doing too much rewriting in any one branch :)

Yes, I know, but things often come in mind when doing it, and as I'm touching a lot of panel stuff, I'd prefer to keep all here.
You can just use bzr send lp:unity -o branch-changes.diff to check them locally ;)

> The empty destructor's definition can be removed (unless its virtual)
>
> + if (!wm->IsExpoActive() && !wm->IsScaleActive())
> 490 + {
>
> This probably doesn't make sense living where it is. The Panel views should
> block all clicks if if the screen is grabbed by compiz period (eg, add a
> wrapper method in WindowManager around CompScreen::otherGrabExist (NULL);)

Well, if the dash grab isn't considered by that, I could try to do it.

> 3391 + // FIXME: compiz doesn't give us a valid xid (is always 0 on unmap)
> 3392 + // we need to do this again on BamfView closed signal.
>
> Great. I'll fix that in compiz then. (This is probably the case when the
> window is destroyed and the xid is changed to zero, and then the unmap signal
> happens)

Let me know when your fix will be landed, so we can remove this.

> The window management stuff looks great.

Cool! ;)

=== modified file 'UnityCore/AppmenuIndicator.cpp'
--- UnityCore/AppmenuIndicator.cpp	2012-03-29 12:06:35 +0000
+++ UnityCore/AppmenuIndicator.cpp	2012-04-18 08:58:24 +0000
@@ -24,13 +24,55 @@
 namespace indicator
 {
 
+namespace 
+{
+const std::string SETTING_NAME("com.canonical.indicator.appmenu");
+const std::string SETTING_KEY("menu-mode");
+}
+
 AppmenuIndicator::AppmenuIndicator(std::string const& name)
   : Indicator(name)
-{}
-
-void AppmenuIndicator::ShowAppmenu(unsigned int xid, int x, int y, unsigned int timestamp) const
-{
-  on_show_appmenu.emit(xid, x, y, timestamp);
+  , gsettings_(g_settings_new(SETTING_NAME.c_str()))
+  , integrated_(false)
+{
+  setting_changed_.Connect(gsettings_, "changed::menu-mode", [&] (GSettings*, gchar*) {
+    CheckSettingValue();
+  });
+
+  CheckSettingValue();
+}
+
+bool AppmenuIndicator::ShowAppmenu(unsigned int xid, int x, int y, unsigned int timestamp) const
+{
+  if (integrated_)
+  {
+    on_show_appmenu.emit(xid, x, y, timestamp);
+    return true;
+  }
+
+  return false;
+}
+
+bool AppmenuIndicator::IsIntegrated() const
+{
+  return integrated_;
+}
+
+void AppmenuIndicator::CheckSettingValue()
+{
+  glib::String menu_mode(g_settings_get_string(gsettings_, SETTING_KEY.c_str()));
+  bool integrated_menus = false;
+
+  if (menu_mode.Str() == "locally-integrated")
+  {
+    integrated_menus = true;
+  }
+
+  if (integrated_menus != integrated_)
+  {
+    integrated_ = integrated_menus;
+    integrated_changed.emit(integrated_);
+  }
 }
 
 } // namespace indicator

=== modified file 'UnityCore/AppmenuIndicator.h'
--- UnityCore/AppmenuIndicator.h	2012-03-29 12:06:35 +0000
+++ UnityCore/AppmenuIndicator.h	2012-04-18 08:58:24 +0000
@@ -21,6 +21,10 @@
 #define UNITY_APPMENU_INDICATOR_H
 
 #include "Indicator.h"
+#include "GLibWrapper.h"
+#include "GLibSignal.h"
+
+#include <gio/gio.h>
 
 namespace unity
 {
@@ -33,12 +37,22 @@
   AppmenuIndicator(std::string const& name);
 
   virtual bool IsAppmenu() const { return true; }
-
-  void ShowAppmenu(unsigned int xid, int x, int y, unsigned int timestamp) const;
-
+  bool IsIntegrated() const;
+
+  bool ShowAppmenu(unsigned int xid, int x, int y, unsigned int timestamp) const;
+
+  sigc::signal<void, bool> integrated_changed;
   sigc::signal<void, unsigned int, int, int, unsigned int> on_show_appmenu;
+
+private:
+  void CheckSettingValue();
+
+  glib::Object<GSettings> gsettings_;
+  glib::Signal<void, GSettings*, gchar*> setting_changed_;
+  bool integrated_;
 };
 
+
 }
 }
 

=== added file 'plugins/unityshell/src/PanelIndicatorAppmenuView.cpp'
--- plugins/unityshell/src/PanelIndicatorAppmenuView.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/PanelIndicatorAppmenuView.cpp	2012-04-18 08:58:24 +0000
@@ -0,0 +1,238 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include <UnityCore/Variant.h>
+#include <UnityCore/GLibWrapper.h>
+#include <libbamf/libbamf.h>
+
+#include "PanelIndicatorAppmenuView.h"
+#include "WindowManager.h"
+#include "PanelStyle.h"
+
+namespace unity
+{
+namespace
+{
+  const std::string MENU_ATOM = "_UBUNTU_APPMENU_UNIQUE_NAME";
+}
+
+using namespace indicator;
+
+PanelIndicatorAppmenuView::PanelIndicatorAppmenuView(Entry::Ptr const& proxy)
+  : PanelIndicatorEntryView(proxy, 0, APPMENU)
+  , xid_(0)
+  , has_menu_(false)
+{
+  spacing_ = 2;
+  right_padding_ = 7;
+  SetVisible(false);
+}
+
+void PanelIndicatorAppmenuView::GetGeometryForSync(EntryLocationMap& locations)
+{
+  if (!IsFocused())
+    return;
+
+  PanelIndicatorEntryView::GetGeometryForSync(locations);
+}
+
+void PanelIndicatorAppmenuView::Activate(int button)
+{
+  /* If the button is 0, the entry is activated using a keyboard shortcut,
+   * so we need to check the fucus status of the entry */
+  if (button != 0 || (button == 0 && IsFocused()))
+  {
+    SetActiveState(true, 1);
+  }
+}
+
+void PanelIndicatorAppmenuView::ShowMenu(int button)
+{
+  if (xid_ && has_menu_)
+  {
+    WindowManager::Default()->Raise(xid_);
+    WindowManager::Default()->Activate(xid_);
+
+    proxy_->ShowMenu(xid_,
+                     GetAbsoluteX(),
+                     GetAbsoluteY() + panel::Style::Instance().panel_height,
+                     button,
+                     time(nullptr));
+  }
+}
+
+std::string PanelIndicatorAppmenuView::GetLabel()
+{
+  glib::String escaped(g_markup_escape_text(label_.c_str(), -1));
+
+  std::ostringstream bold_label;
+  bold_label << "<b>" << escaped.Str() << "</b>";
+
+  return bold_label.str();
+}
+
+bool PanelIndicatorAppmenuView::IsLabelSensitive() const
+{
+  return (!label_.empty() && has_menu_);
+}
+
+bool PanelIndicatorAppmenuView::IsLabelVisible() const
+{
+  return !label_.empty();
+}
+
+bool PanelIndicatorAppmenuView::IsIconSensitive() const
+{
+  return has_menu_;
+}
+
+bool PanelIndicatorAppmenuView::IsIconVisible() const
+{
+  return has_menu_;
+}
+
+void PanelIndicatorAppmenuView::SetLabel(std::string const& label)
+{
+  if (label_ != label)
+  {
+    label_ = label;
+    SetVisible(!label_.empty());
+    Refresh();
+  }
+}
+
+void PanelIndicatorAppmenuView::SetControlledWindow(Window xid)
+{
+  if (xid_ != xid)
+  {
+    xid_ = xid;
+    SetVisible(xid_ != 0);
+    CheckWindowMenu();
+  }
+}
+
+bool PanelIndicatorAppmenuView::CheckWindowMenu()
+{
+  /* FIXME this is a temporary workaround */
+  has_menu_ = true;
+  glib::Object<BamfMatcher> matcher(bamf_matcher_get_default());
+  BamfWindow *win = bamf_matcher_get_active_window(matcher);
+
+  if (BAMF_IS_WINDOW(win))
+  {
+    if (xid_ == bamf_window_get_xid(win))
+    {
+      has_menu_ = proxy_->image_sensitive();
+    }
+  }
+
+  /* FIXME re-enable this when all the clients will support the APPMENU atom.
+  has_menu_ = false;
+
+  if (!xid_)
+    return false;
+
+  glib::Object<BamfMatcher> matcher(bamf_matcher_get_default());
+
+  GList* windows = bamf_matcher_get_windows(matcher);
+
+  for (GList* l = windows; l; l = l->next)
+  {
+    if (BAMF_IS_WINDOW(l->data))
+    {
+      auto window = static_cast<BamfWindow*>(l->data);
+
+      if (bamf_window_get_xid(window) == xid_)
+      {
+        glib::String property(bamf_window_get_utf8_prop(window, MENU_ATOM.c_str()));
+        has_menu_ = bool(property);
+        break;
+      }
+    }
+  }
+
+  g_list_free(windows);*/
+
+  return has_menu_;
+}
+
+void PanelIndicatorAppmenuView::DrawEntryPrelight(cairo_t* cr, unsigned int width, unsigned int height)
+{
+  nux::Rect const& geo = proxy_->geometry();
+
+  if (geo == nux::Geometry())
+    return;
+
+  GtkStyleContext* style_context = panel::Style::Instance().GetStyleContext();
+  int flair_width = std::min(geo.width, GetMinimumWidth());
+
+  cairo_translate (cr, geo.x - GetAbsoluteX(), geo.y - height);
+
+  gtk_style_context_save(style_context);
+
+  GtkWidgetPath* widget_path = gtk_widget_path_new();
+  gtk_widget_path_iter_set_name(widget_path, -1 , "UnityPanelWidget");
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_BAR);
+  gtk_widget_path_append_type(widget_path, GTK_TYPE_MENU_ITEM);
+
+  gtk_style_context_set_path(style_context, widget_path);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
+  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
+  gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
+
+  cairo_save(cr);
+  cairo_push_group(cr);
+
+  gtk_render_background(style_context, cr, 0, 0, flair_width, height);
+  gtk_render_frame(style_context, cr, 0, 0, flair_width, height);
+
+  cairo_pattern_t* pat = cairo_pop_group(cr);
+  cairo_pattern_t* mask = cairo_pattern_create_linear(0, 0, 0, height);
+  cairo_pattern_add_color_stop_rgba(mask, 0.0f, 0, 0, 0, 0.0f);
+  cairo_pattern_add_color_stop_rgba(mask, 0.6f, 0, 0, 0, 0.0f);
+  cairo_pattern_add_color_stop_rgba(mask, 1.0f, 0, 0, 0, 1.0f);
+
+  cairo_rectangle(cr, 0, 0, flair_width, height);
+  cairo_set_source(cr, pat);
+  cairo_mask(cr, mask);
+
+  cairo_pattern_destroy(pat);
+  cairo_pattern_destroy(mask);
+  cairo_restore(cr);
+
+  gtk_widget_path_free(widget_path);
+
+  gtk_style_context_restore(style_context);
+}
+
+std::string PanelIndicatorAppmenuView::GetName() const
+{
+  return "Appmenu";
+}
+
+void PanelIndicatorAppmenuView::AddProperties(GVariantBuilder* builder)
+{
+  PanelIndicatorEntryView::AddProperties(builder);
+
+  variant::BuilderWrapper(builder)
+  .add("controlled-window", xid_)
+  .add("has_menu", has_menu_);
+}
+
+} // NAMESPACE

=== added file 'plugins/unityshell/src/PanelIndicatorAppmenuView.h'
--- plugins/unityshell/src/PanelIndicatorAppmenuView.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/PanelIndicatorAppmenuView.h	2012-04-18 08:58:24 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef PANEL_INDICATOR_APPMENU_VIEW_H
+#define PANEL_INDICATOR_APPMENU_VIEW_H
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+
+#include "PanelIndicatorEntryView.h"
+
+namespace unity
+{
+using indicator::Entry;
+
+class PanelIndicatorAppmenuView : public PanelIndicatorEntryView
+{
+public:
+  PanelIndicatorAppmenuView(Entry::Ptr const& proxy);
+
+  std::string GetLabel();
+  void SetLabel(std::string const& label);
+  bool IsLabelVisible() const;
+  bool IsLabelSensitive() const;
+
+  bool IsIconVisible() const;
+  bool IsIconSensitive() const;
+
+  void GetGeometryForSync(indicator::EntryLocationMap& locations);
+
+  void SetControlledWindow(Window xid);
+
+  void Activate(int button = 1);
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+  void ShowMenu(int button);
+  void DrawEntryPrelight(cairo_t* cr, unsigned int w, unsigned int h);
+
+private:
+  bool CheckWindowMenu();
+
+  Window xid_;
+  bool has_menu_;
+  std::string label_;
+};
+
+}
+
+#endif // PANEL_INDICATOR_APPMENU_VIEW_H

=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.cpp'
--- plugins/unityshell/src/PanelIndicatorEntryView.cpp	2012-04-10 01:30:04 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.cpp	2012-04-18 08:58:24 +0000
@@ -72,7 +72,7 @@
 
   InputArea::SetAcceptMouseWheelEvent(true);
 
-  if (type_ != MENU)
+  if (type_ != MENU && type_ != APPMENU)
     InputArea::mouse_wheel.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseWheel));
 
   panel::Style::Instance().changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
@@ -275,7 +275,7 @@
     {
       gtk_style_context_set_state(style_context, GTK_STATE_FLAG_BACKDROP);
     }
-    else if (IsActive())
+    else if (IsActive() && type_ != APPMENU)
     {
       gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
     }
@@ -344,7 +344,7 @@
     {
       gtk_style_context_set_state(style_context, GTK_STATE_FLAG_BACKDROP);
     }
-    else if (IsActive())
+    else if (IsActive() && type_ != APPMENU)
     {
       gtk_style_context_set_state(style_context, GTK_STATE_FLAG_PRELIGHT);
     }
@@ -358,7 +358,10 @@
     {
       cairo_pattern_t* linpat;
       int out_pixels = text_width - text_space;
-      const int fading_pixels = 15;
+      int fading_pixels = 20;
+
+      if (type_ == APPMENU)
+        fading_pixels = 35;
 
       int fading_width = out_pixels < fading_pixels ? out_pixels : fading_pixels;
 
@@ -448,6 +451,15 @@
     PangoFontDescription* desc = nullptr;
     PanelItem panel_item = (type_ == MENU) ? PanelItem::MENU : PanelItem::INDICATOR;
 
+    if (type_ == MENU)
+    {
+      panel_item = PanelItem::INDICATOR;
+    }
+    else if (type_ == APPMENU)
+    {
+      panel_item = PanelItem::TITLE;
+    }
+
     Style& panel_style = Style::Instance();
     std::string const& font_description = panel_style.GetFontDescription(panel_item);
     int dpi = panel_style.GetTextDPI();
@@ -475,8 +487,15 @@
 
     pango_layout_set_font_description(layout, desc);
 
-    boost::erase_all(label, "_");
-    pango_layout_set_text(layout, label.c_str(), -1);
+    if (type_ == APPMENU)
+    {
+      pango_layout_set_markup(layout, label.c_str(), -1);
+    }
+    else
+    {
+      boost::erase_all(label, "_");
+      pango_layout_set_text(layout, label.c_str(), -1);
+    }
 
     cxt = pango_layout_get_context(layout);
     pango_cairo_context_set_font_options(cxt, gdk_screen_get_font_options(screen));

=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.h'
--- plugins/unityshell/src/PanelIndicatorEntryView.h	2012-04-10 00:30:33 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.h	2012-04-18 08:58:24 +0000
@@ -43,6 +43,7 @@
   enum IndicatorEntryType {
     INDICATOR,
     MENU,
+    APPMENU,
     OTHER
   };
 

=== modified file 'plugins/unityshell/src/PanelIndicatorsView.cpp'
--- plugins/unityshell/src/PanelIndicatorsView.cpp	2012-04-03 16:01:38 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.cpp	2012-04-18 08:58:24 +0000
@@ -111,6 +111,17 @@
   return indicators_;
 }
 
+bool
+PanelIndicatorsView::IsAppmenu()
+{
+  if (indicators_.size() == 1 && indicators_[0]->IsAppmenu())
+  {
+    return true;
+  }
+
+  return false;
+}
+
 void
 PanelIndicatorsView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {

=== modified file 'plugins/unityshell/src/PanelIndicatorsView.h'
--- plugins/unityshell/src/PanelIndicatorsView.h	2012-04-02 10:25:16 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.h	2012-04-18 08:58:24 +0000
@@ -66,6 +66,8 @@
   void SetOpacity(double opacity);
   double GetOpacity();
 
+  bool IsAppmenu();
+
   void SetMaximumEntriesWidth(int max_width);
   void GetGeometryForSync(indicator::EntryLocationMap& locations);
 

=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2012-04-16 12:12:05 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2012-04-18 08:58:24 +0000
@@ -29,6 +29,7 @@
 #include "UScreen.h"
 
 #include <UnityCore/Variant.h>
+#include <UnityCore/AppmenuIndicator.h>
 
 #include <glib/gi18n-lib.h>
 
@@ -51,9 +52,11 @@
 
 PanelMenuView::PanelMenuView()
   : _matcher(bamf_matcher_get_default()),
+    _is_integrated(false),
     _is_inside(false),
     _is_grabbed(false),
     _is_maximized(false),
+    _integrated_menu(nullptr),
     _last_active_view(nullptr),
     _new_application(nullptr),
     _overlay_showing(false),
@@ -181,6 +184,7 @@
   _fade_out_animator.animation_updated.clear();
   _fade_out_animator.animation_ended.clear();
   _style_changed_connection.disconnect();
+  _mode_changed_connection.disconnect();
 
   if (_active_moved_id)
     g_source_remove(_active_moved_id);
@@ -207,6 +211,40 @@
   QueueDraw();
 }
 
+void PanelMenuView::SetIntegrated(bool integrated)
+{
+  if (_is_integrated == integrated)
+    return;
+
+  _is_integrated = integrated;
+  panel::Style::Instance().integrated_menus = _is_integrated;
+
+  if (!_is_integrated)
+  {
+    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+
+    _window_buttons->SetFocusedState(true);
+    _window_buttons->SetControlledWindow(_is_maximized ? _active_xid : 0);
+
+    _integrated_menu = nullptr;
+  }
+  else
+  {
+    Window maximized = GetMaximizedWindow();
+    _window_buttons->SetFocusedState(maximized == _active_xid);
+    _window_buttons->SetControlledWindow(maximized);
+  }
+
+  Refresh(true);
+  FullRedraw();
+}
+
+bool PanelMenuView::IsIntegrated() const
+{
+  return _is_integrated;
+}
+
 void PanelMenuView::AddIndicator(indicator::Indicator::Ptr const& indicator)
 {
   if (!GetIndicators().empty())
@@ -216,6 +254,27 @@
   }
 
   PanelIndicatorsView::AddIndicator(indicator);
+
+  if (indicator->IsAppmenu())
+  {
+    auto appmenuindicator = dynamic_cast<indicator::AppmenuIndicator*>(indicator.get());
+
+    if (appmenuindicator)
+    {
+      SetIntegrated(appmenuindicator->IsIntegrated());
+
+      _mode_changed_connection =
+        appmenuindicator->integrated_changed.connect(sigc::mem_fun(this, &PanelMenuView::SetIntegrated));
+    }
+  }
+}
+
+void PanelMenuView::RemoveIndicator(indicator::Indicator::Ptr const& indicator)
+{
+  PanelIndicatorsView::RemoveIndicator(indicator);
+
+  if (indicator->IsAppmenu())
+    _mode_changed_connection.disconnect();
 }
 
 void PanelMenuView::SetMenuShowTimings(int fadein, int fadeout, int discovery,
@@ -271,7 +330,7 @@
       return _titlebar_grab_area;
   }
 
-  if (_is_maximized)
+  if (_is_maximized || (_is_integrated && GetMaximizedWindow()))
   {
     if (_window_buttons)
     {
@@ -284,6 +343,18 @@
   {
     found_area = _titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
     NUX_RETURN_VALUE_IF_NOTNULL(found_area, found_area);
+
+    /* When the integrated menus are enabled, that area must act both like an
+     * indicator-entry view and like a panel-grab-area, so not to re-implement
+     * what we have done into PanelTitleGrabAreaView inside PanelIndicatorAppmenuView
+     * we can just redirect the input events directed to the integrated menus
+     * to the grab_area, then we just have to use few tricks when we get the
+     * signals back from the grab-area to check where they really were */
+    if (_is_integrated && _integrated_menu)
+    {
+      if (_integrated_menu->GetAbsoluteGeometry().IsInside(mouse_position))
+        return _titlebar_grab_area;
+    }
   }
 
   return PanelIndicatorsView::FindAreaUnderMouse(mouse_position, event_type);
@@ -338,6 +409,16 @@
   auto wm = WindowManager::Default();
   bool screen_grabbed = (wm->IsExpoActive() || wm->IsScaleActive());
 
+  if (_is_integrated && _integrated_menu)
+  {
+    if (!_overlay_showing && !screen_grabbed)
+    {
+      return (GetMaximizedWindow() != 0);
+    }
+
+    return false;
+  }
+
   if (_we_control_active && !_overlay_showing && !screen_grabbed &&
       !_switcher_showing && !_launcher_keynav)
   {
@@ -358,6 +439,16 @@
   if (_overlay_showing)
     return true;
 
+  if (_is_integrated)
+  {
+    if (!screen_grabbed)
+    {
+      return (GetMaximizedWindow() != 0);
+    }
+
+    return false;
+  }
+
   if (_we_control_active && _is_maximized && !screen_grabbed &&
       !_launcher_keynav && !_switcher_showing)
   {
@@ -528,7 +619,8 @@
     {
       double title_opacity = 0.0f;
 
-      if (_we_control_active && _window_buttons->GetOpacity() == 0.0 &&
+      if ((_we_control_active || (_is_integrated && !draw_menus)) &&
+          _window_buttons->GetOpacity() == 0.0 &&
           (!has_menu || (has_menu && GetOpacity() == 0.0)))
       {
         title_opacity = 1.0f;
@@ -610,7 +702,7 @@
 
     _fade_in_animator.Stop();
 
-    if (!_new_app_menu_shown)
+    if (_is_integrated || !_new_app_menu_shown)
     {
       _fade_out_animator.Start(1.0f - GetOpacity());
     }
@@ -711,6 +803,36 @@
   return label;
 }
 
+std::string PanelMenuView::GetMaximizedViewName(bool use_appname) const
+{
+  Window maximized = GetMaximizedWindow();
+  BamfWindow* window = nullptr;
+  std::string label;
+
+  window = GetBamfWindowForXid(maximized);
+
+  if (BAMF_IS_WINDOW(window) && IsWindowUnderOurControl(maximized))
+  {
+    BamfView* view = reinterpret_cast<BamfView*>(window);
+    label = glib::String(bamf_view_get_name(view)).Str();
+
+    if (use_appname || label.empty())
+    {
+      BamfApplication* app = bamf_matcher_get_application_for_window(_matcher, window);
+
+      if (BAMF_IS_APPLICATION(app))
+        view = reinterpret_cast<BamfView*>(app);
+
+      label = glib::String(bamf_view_get_name(view)).Str();
+    }
+  }
+
+  if (label.empty() && _is_integrated && !DrawMenus() && _integrated_menu)
+    label = _desktop_name;
+
+  return label;
+}
+
 void PanelMenuView::DrawTitle(cairo_t *cr_real, nux::Geometry const& geo, std::string const& label) const
 {
   using namespace panel;
@@ -829,13 +951,34 @@
   {
     new_title = "";
   }
+  else if (_is_integrated)
+  {
+    Window maximized = GetMaximizedWindow();
+    new_title = GetMaximizedViewName();
+
+    _window_buttons->SetControlledWindow(maximized);
+    _window_buttons->SetFocusedState(_active_xid == maximized);
+
+    if (_integrated_menu)
+    {
+      _integrated_menu->SetControlledWindow(maximized);
+
+      if (DrawMenus())
+      {
+        _integrated_menu->SetLabel(new_title);
+        _integrated_menu->SetFocusedState(_active_xid == maximized);
+
+        return;
+      }
+    }
+  }
   else if (!_switcher_showing && !_launcher_keynav)
   {
     new_title = GetActiveViewName();
     _window_buttons->SetControlledWindow(_active_xid);
   }
 
-  if (!_switcher_showing && !_launcher_keynav)
+  if ((!_switcher_showing && !_launcher_keynav) || _is_integrated)
   {
     if (_panel_title != new_title)
     {
@@ -894,9 +1037,23 @@
 {
   PanelIndicatorEntryView* view;
 
-  view = new PanelIndicatorEntryView(entry, MENU_ENTRIES_PADDING, IndicatorEntryType::MENU);
-  view->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
-  view->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
+  if (!_is_integrated)
+  {
+    view = new PanelIndicatorEntryView(entry, MENU_ENTRIES_PADDING, IndicatorEntryType::MENU);
+    view->mouse_enter.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseEnter));
+    view->mouse_leave.connect(sigc::mem_fun(this, &PanelMenuView::OnPanelViewMouseLeave));
+  }
+  else
+  {
+    if (_integrated_menu)
+    {
+      LOG_ERROR(logger) << "Another integrated menu has already been defined, this shouldn't happen!";
+    }
+
+    _integrated_menu = new PanelIndicatorAppmenuView(entry);
+    view = _integrated_menu;
+    Refresh();
+  }
 
   entry->show_now_changed.connect(sigc::mem_fun(this, &PanelMenuView::UpdateShowNow));
   view->active_changed.connect(sigc::mem_fun(this, &PanelMenuView::OnActiveChanged));
@@ -904,13 +1061,24 @@
   AddEntryView(view, IndicatorEntryPosition::END);
 }
 
+void PanelMenuView::OnEntryRemoved(std::string const& entry_id)
+{
+  if (_integrated_menu && _integrated_menu->GetEntryID() == entry_id)
+    _integrated_menu = nullptr;
+
+  RemoveEntry(entry_id);
+}
+
 void PanelMenuView::NotifyAllMenusClosed()
 {
   _last_active_view = nullptr;
 
-  auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-  _is_inside = GetAbsoluteGeometry().IsInside(mouse);
-  FullRedraw();
+  if (!_is_integrated)
+  {
+    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+    FullRedraw();
+  }
 }
 
 void PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
@@ -1009,7 +1177,7 @@
                                        BamfApplication* old_app,
                                        BamfApplication* new_app)
 {
-  if (BAMF_IS_APPLICATION(new_app))
+  if (BAMF_IS_APPLICATION(new_app) && !_is_integrated)
   {
     if (std::find(_new_apps.begin(), _new_apps.end(), new_app) != _new_apps.end())
     {
@@ -1097,7 +1265,10 @@
     _view_name_changed_signal.Connect(new_view, "name-changed",
                                       sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
 
-    _window_buttons->SetControlledWindow(_is_maximized ? _active_xid : 0);
+    if (!_is_integrated)
+    {
+      _window_buttons->SetControlledWindow(_is_maximized ? _active_xid : 0);
+    }
   }
 
   Refresh();
@@ -1213,9 +1384,12 @@
 
   if (is_active)
   {
-    // We need to update the _is_inside state in the case of maximization by grab
-    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+    if (!_is_integrated)
+    {
+      // We need to update the _is_inside state in the case of maximization by grab
+      auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+      _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+    }
 
     _is_maximized = true;
     updated = true;
@@ -1229,7 +1403,7 @@
 
   _maximized_set.insert(xid);
 
-  if (updated)
+  if (updated || _is_integrated)
   {
     Refresh();
     FullRedraw();
@@ -1410,6 +1584,23 @@
   {
     WindowManager::Default()->Activate(maximized);
   }
+
+  /* If the user clicked over the integrated_menu we need to adjust
+   * the coordinates we got, because they're relative to the grab area,
+   * but due to the workaround we used, the point clicked could be
+   * also in the integrated-menu geometry, so we can easiliy set them
+   * correctly to check where we are and to eventually activate the
+   * integrated menu */
+  if (_is_integrated && _integrated_menu)
+  {
+    x += _titlebar_grab_area->GetAbsoluteX();
+    y += _titlebar_grab_area->GetAbsoluteY();
+
+    if (_integrated_menu->GetAbsoluteGeometry().IsPointInside(x, y))
+    {
+      _integrated_menu->Activate();
+    }
+  }
 }
 
 void PanelMenuView::OnMaximizedRestore(int x, int y)
@@ -1468,6 +1659,17 @@
   x += _titlebar_grab_area->GetAbsoluteX();
   y += _titlebar_grab_area->GetAbsoluteY();
 
+  /* If the user clicked over the integrated_menu we need to adjust
+   * the coordinates again, because they are still relative to the grab area */
+  if (_is_integrated && _integrated_menu)
+  {
+    if (_integrated_menu->GetAbsoluteGeometry().IsPointInside(x, y))
+    {
+      x += _integrated_menu->GetAbsoluteX();
+      y += _integrated_menu->GetAbsoluteY();
+    }
+  }
+
   Window maximized = GetMaximizedWindow();
 
   /* When the drag goes out from the Panel, start the real movement.
@@ -1543,6 +1745,7 @@
   PanelIndicatorsView::AddProperties(builder);
 
   variant::BuilderWrapper(builder)
+  .add("integrated", _is_integrated)
   .add("mouse_inside", _is_inside)
   .add("grabbed", _is_grabbed)
   .add("active_win_maximized", _is_maximized)
@@ -1574,7 +1777,7 @@
 
   _switcher_showing = switcher_shown;
 
-  if (!_switcher_showing)
+  if (!_switcher_showing && !_is_integrated)
   {
     auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     _is_inside = GetAbsoluteGeometry().IsInside(mouse);
@@ -1619,8 +1822,11 @@
 
   _launcher_keynav = false;
 
-  auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
-  _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+  if (!_is_integrated)
+  {
+    auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
+    _is_inside = GetAbsoluteGeometry().IsInside(mouse);
+  }
 
   Refresh();
   QueueDraw();
@@ -1670,6 +1876,9 @@
    * If the status is false, we just check that the menus entries are hidden
    * and we remove any eventual delayed request */
 
+  if (_is_integrated)
+    return;
+
   if (!status && _show_now_activated)
   {
     _show_now_activated = false;
@@ -1726,7 +1935,18 @@
   }
 
   Window maximized = GetMaximizedWindow();
-  Window buttons_win = (maximized == _active_xid) ? maximized : 0;
+  Window buttons_win = 0;
+
+  if (_is_integrated)
+  {
+    buttons_win = maximized;
+    _window_buttons->SetFocusedState(maximized == _active_xid);
+  }
+  else
+  {
+    buttons_win = (maximized == _active_xid) ? maximized : 0;
+    _window_buttons->SetControlledWindow(buttons_win);
+  }
 
   _window_buttons->SetMonitor(_monitor);
   _window_buttons->SetControlledWindow(buttons_win);

=== modified file 'plugins/unityshell/src/PanelMenuView.h'
--- plugins/unityshell/src/PanelMenuView.h	2012-04-09 13:13:16 +0000
+++ plugins/unityshell/src/PanelMenuView.h	2012-04-18 08:58:24 +0000
@@ -28,6 +28,7 @@
 #include "PanelIndicatorsView.h"
 #include "StaticCairoText.h"
 #include "WindowButtons.h"
+#include "PanelIndicatorAppmenuView.h"
 #include "PanelTitlebarGrabAreaView.h"
 #include "PluginAdapter.h"
 #include "Animator.h"
@@ -47,14 +48,17 @@
 
   void SetMousePosition(int x, int y);
   void SetMonitor(int monitor);
+  void SetIntegrated(bool integrated);
 
   Window GetTopWindow() const;
   Window GetMaximizedWindow() const;
   bool GetControlsActive() const;
+  bool IsIntegrated() const;
 
   void NotifyAllMenusClosed();
 
   virtual void AddIndicator(indicator::Indicator::Ptr const& indicator);
+  virtual void RemoveIndicator(indicator::Indicator::Ptr const& indicator);
 
   virtual void OverlayShown();
   virtual void OverlayHidden();
@@ -69,6 +73,7 @@
   virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_position,
                                         nux::NuxEventType event_type);
   virtual void OnEntryAdded(indicator::Entry::Ptr const& entry);
+  virtual void OnEntryRemoved(std::string const& entry_id);
 
 private:
   void OnActiveChanged(PanelIndicatorEntryView* view, bool is_active);
@@ -110,6 +115,7 @@
 
   BamfWindow* GetBamfWindowForXid(Window xid) const;
 
+  std::string GetMaximizedViewName(bool use_appname = false) const;
   std::string GetActiveViewName(bool use_appname = false) const;
 
   void OnSwitcherShown(GVariant* data);
@@ -141,10 +147,12 @@
   nux::ObjectPtr<nux::BaseTexture> _title_texture;
   nux::ObjectPtr<nux::IOpenGLBaseTexture> _gradient_texture;
 
+  bool _is_integrated;
   bool _is_inside;
   bool _is_grabbed;
   bool _is_maximized;
 
+  PanelIndicatorAppmenuView* _integrated_menu;
   PanelIndicatorEntryView* _last_active_view;
   WindowButtons* _window_buttons;
   PanelTitlebarGrabArea* _titlebar_grab_area;
@@ -178,6 +186,7 @@
   glib::Signal<void, BamfMatcher*, BamfApplication*, BamfApplication*> _active_app_changed_signal;
   glib::Signal<void, BamfView*, gchar*, gchar*> _view_name_changed_signal;
   sigc::connection _style_changed_connection;
+  sigc::connection _mode_changed_connection;
 
   UBusManager _ubus_manager;
 

=== modified file 'plugins/unityshell/src/PanelStyle.cpp'
--- plugins/unityshell/src/PanelStyle.cpp	2012-04-02 09:34:58 +0000
+++ plugins/unityshell/src/PanelStyle.cpp	2012-04-18 08:58:24 +0000
@@ -61,6 +61,7 @@
 
 Style::Style()
   : panel_height(24)
+  , integrated_menus(false)
   , _style_context(gtk_style_context_new())
 {
   if (style_instance)

=== modified file 'plugins/unityshell/src/PanelStyle.h'
--- plugins/unityshell/src/PanelStyle.h	2012-03-30 13:01:12 +0000
+++ plugins/unityshell/src/PanelStyle.h	2012-04-18 08:58:24 +0000
@@ -77,6 +77,7 @@
   int GetTextDPI();
 
   nux::Property<int> panel_height;
+  nux::Property<bool> integrated_menus;
 
   sigc::signal<void> changed;
 

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2012-04-15 10:44:39 +0000
+++ plugins/unityshell/src/unityshell.cpp	2012-04-18 08:58:24 +0000
@@ -2259,14 +2259,15 @@
     uScreen->setPanelShadowMatrix(matrix);
 
   Window active_window = screen->activeWindow();
-  if (window->id() == active_window && window->type() != CompWindowTypeDesktopMask)
+  bool integrated_menus = panel::Style::Instance().integrated_menus;
+  if (window->id() == active_window && window->type() != CompWindowTypeDesktopMask && !integrated_menus)
   {
     uScreen->paintPanelShadow(matrix);
   }
 
   bool ret = gWindow->glDraw(matrix, attrib, region, mask);
 
-  if ((active_window == 0 || active_window == window->id()) &&
+  if ((active_window == 0 || active_window == window->id() || integrated_menus) &&
       (window->type() == CompWindowTypeDesktopMask))
   {
     uScreen->paintPanelShadow(matrix);

=== modified file 'tests/test_indicator_appmenu.cpp'
--- tests/test_indicator_appmenu.cpp	2012-03-29 12:06:35 +0000
+++ tests/test_indicator_appmenu.cpp	2012-04-18 08:58:24 +0000
@@ -30,16 +30,74 @@
 
 TEST(TestAppmenuIndicator, Construction)
 {
+  g_setenv("GSETTINGS_BACKEND", "memory", true);
+
   AppmenuIndicator indicator("indicator-appmenu");
 
   EXPECT_EQ(indicator.name(), "indicator-appmenu");
   EXPECT_TRUE(indicator.IsAppmenu());
+  EXPECT_FALSE(indicator.IsIntegrated());
+}
+
+TEST(TestAppmenuIndicator, ConstructionIntegrated)
+{
+  g_setenv("GSETTINGS_BACKEND", "memory", true);
+
+  glib::Object<GSettings> gsettings(g_settings_new("com.canonical.indicator.appmenu"));
+  g_settings_set_string(gsettings, "menu-mode", "locally-integrated");
+
+  AppmenuIndicator indicator("indicator-appmenu-integrated");
+
+  EXPECT_EQ(indicator.name(), "indicator-appmenu-integrated");
+  EXPECT_TRUE(indicator.IsAppmenu());
+  EXPECT_TRUE(indicator.IsIntegrated());
+}
+
+TEST(TestAppmenuIndicator, IntegratedValue)
+{
+  g_setenv("GSETTINGS_BACKEND", "memory", true);
+
+  glib::Object<GSettings> gsettings(g_settings_new("com.canonical.indicator.appmenu"));
+  g_settings_set_string(gsettings, "menu-mode", "global");
+
+  AppmenuIndicator indicator("indicator-appmenu");
+  EXPECT_FALSE(indicator.IsIntegrated());
+
+  bool integrated_changed = false;
+  bool integrated_value = false;
+  indicator.integrated_changed.connect([&] (bool new_value) {
+    integrated_changed = true;
+    integrated_value = new_value;
+  });
+
+  g_settings_set_string(gsettings, "menu-mode", "locally-integrated");
+  EXPECT_TRUE(integrated_changed);
+  EXPECT_TRUE(integrated_value);
+  EXPECT_TRUE(indicator.IsIntegrated());
+
+  integrated_changed = false;
+  g_settings_set_string(gsettings, "menu-mode", "locally-integrated");
+  EXPECT_FALSE(integrated_changed);
+  EXPECT_TRUE(integrated_value);
+  EXPECT_TRUE(indicator.IsIntegrated());
+
+  integrated_changed = false;
+  g_settings_set_string(gsettings, "menu-mode", "global");
+  EXPECT_TRUE(integrated_changed);
+  EXPECT_FALSE(integrated_value);
+  EXPECT_FALSE(indicator.IsIntegrated());
 }
 
 TEST(TestAppmenuIndicator, ShowAppmenu)
 {
+  g_setenv("GSETTINGS_BACKEND", "memory", true);
+
+  glib::Object<GSettings> gsettings(g_settings_new("com.canonical.indicator.appmenu"));
+  g_settings_set_string(gsettings, "menu-mode", "global");
+
   AppmenuIndicator indicator("indicator-appmenu");
 
+  bool ret;
   bool signal_emitted = false;
   int show_x, show_y;
   unsigned int show_xid, show_timestamp;
@@ -54,7 +112,14 @@
     show_timestamp = timestamp;
   });
 
-  indicator.ShowAppmenu(123456789, 50, 100, 1328308554);
+  ret = indicator.ShowAppmenu(123456789, 50, 100, 1328063758);
+  EXPECT_FALSE(ret);
+  EXPECT_FALSE(signal_emitted);
+
+  g_settings_set_string(gsettings, "menu-mode", "locally-integrated");
+
+  ret = indicator.ShowAppmenu(123456789, 50, 100, 1328308554);
+  EXPECT_TRUE(ret);
   EXPECT_TRUE(signal_emitted);
 
   EXPECT_EQ(show_xid, 123456789);