Popup changes

chrome/browser/gtk/browser_window_gtk.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <X11/XF86keysym.h>
 
 #include "app/resource_bundle.h"
@@ skipping 38 matching lines @@
 #include "chrome/browser/renderer_host/render_widget_host_view_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "grit/app_resources.h"
 #include "grit/theme_resources.h"
 
 #if defined(LINUX2)
+#include "chrome/browser/views/panel_controller.h"
 #include "chrome/browser/views/tabs/tab_overview_types.h"
 #endif
 
 namespace {
 
 // The number of milliseconds between loading animation frames.
 const int kLoadingAnimationFrameTimeMs = 30;
 
 const char* kBrowserWindowKey = "__BROWSER_WINDOW_GTK__";
 
@@ skipping 283 matching lines @@
 
 }  // namespace
 
 std::map<XID, GtkWindow*> BrowserWindowGtk::xid_map_;
 
 BrowserWindowGtk::BrowserWindowGtk(Browser* browser)
     :  browser_(browser),
        full_screen_(false),
 #if defined(LINUX2)
        drag_active_(false),
+       panel_controller_(NULL),
 #endif
        frame_cursor_(NULL) {
   use_custom_frame_.Init(prefs::kUseCustomChromeFrame,
       browser_->profile()->GetPrefs(), this);
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
   g_object_set_data(G_OBJECT(window_), kBrowserWindowKey, this);
   gtk_widget_add_events(GTK_WIDGET(window_), GDK_BUTTON_PRESS_MASK |
                                              GDK_POINTER_MOTION_MASK);
 
   SetWindowIcon();
@@ skipping 77 matching lines @@
           IDR_WINDOW_BOTTOM_RIGHT_CORNER);
     }
 
     custom_frame_border->RenderToWidget(widget);
   }
 
   return FALSE;  // Allow subwidgets to paint.
 }
 
 void BrowserWindowGtk::Show() {
-  gtk_widget_show(GTK_WIDGET(window_));
-
   // The Browser associated with this browser window must become the active
   // browser at the time Show() is called. This is the natural behaviour under
   // Windows, but gtk_widget_show won't show the widget (and therefore won't
   // call OnFocusIn()) until we return to the runloop. Therefore any calls to
   // BrowserList::GetLastActive() (for example, in bookmark_util), will return
   // the previous browser instead if we don't explicitly set it here.
   BrowserList::SetLastActive(browser());
 
 #if defined(LINUX2)
-  TabOverviewTypes::instance()->SetWindowType(
-      GTK_WIDGET(window_), TabOverviewTypes::WINDOW_TYPE_CHROME_TOPLEVEL,
-      NULL);
+  if (browser_->type() == Browser::TYPE_POPUP) {
+    panel_controller_ = new PanelController(this);
+  } else {
+    TabOverviewTypes::instance()->SetWindowType(
+        GTK_WIDGET(window_),
+        TabOverviewTypes::WINDOW_TYPE_CHROME_TOPLEVEL,
+        NULL);
+  }
 #endif
+
+  gtk_widget_show(GTK_WIDGET(window_));
 }
 
 void BrowserWindowGtk::SetBounds(const gfx::Rect& bounds) {
   gint x = static_cast<gint>(bounds.x());
   gint y = static_cast<gint>(bounds.y());
   gint width = static_cast<gint>(bounds.width());
   gint height = static_cast<gint>(bounds.height());
 
   gtk_window_move(window_, x, y);
   gtk_window_resize(window_, width, height);
 }
 
 void BrowserWindowGtk::Close() {
   // We're already closing.  Do nothing.
   if (!window_)
     return;
 
   if (!CanClose())
     return;
 
   SaveWindowPosition();
 
   GtkWidget* window = GTK_WIDGET(window_);
   // To help catch bugs in any event handlers that might get fired during the
   // destruction, set window_ to NULL before any handlers will run.
   window_ = NULL;
   gtk_widget_destroy(window);
+
+#if defined(LINUX2)
+  if (panel_controller_) {
+    panel_controller_->Close();
+  }
+#endif
 }
 
 void BrowserWindowGtk::Activate() {
   gtk_window_present(window_);
 }
 
 bool BrowserWindowGtk::IsActive() const {
   NOTIMPLEMENTED();
   return true;
 }
@@ skipping 15 matching lines @@
 StatusBubble* BrowserWindowGtk::GetStatusBubble() {
   return status_bubble_.get();
 }
 
 void BrowserWindowGtk::SelectedTabToolbarSizeChanged(bool is_animating) {
   // On Windows, this is used for a performance optimization.
   // http://code.google.com/p/chromium/issues/detail?id=12291
 }
 
 void BrowserWindowGtk::UpdateTitleBar() {
+#if defined(LINUX2)
+  if (panel_controller_)
+    panel_controller_->UpdateTitleBar();
+#endif
+
   std::wstring title = browser_->GetCurrentPageTitle();
   gtk_window_set_title(window_, WideToUTF8(title).c_str());
   if (ShouldShowWindowIcon()) {
     // TODO(tc): If we're showing a title bar, we should update the app icon.
   }
 }
 
 void BrowserWindowGtk::UpdateDevTools() {
   NOTIMPLEMENTED();
 }
@@ skipping 449 matching lines @@
   titlebar_.reset(new BrowserTitlebar(this, window_));
   gtk_box_pack_start(GTK_BOX(window_vbox), titlebar_->widget(), FALSE, FALSE,
                      0);
 
   // The content_vbox_ surrounds the "content": toolbar+bookmarks bar+page.
   content_vbox_ = gtk_vbox_new(FALSE, 0);
   gtk_widget_show(content_vbox_);
 
   toolbar_.reset(new BrowserToolbarGtk(browser_.get(), this));
   toolbar_->Init(browser_->profile(), window_);
-  toolbar_->AddToolbarToBox(content_vbox_);
+  bool hide_tools = false;
+#if defined(LINUX2)
+  if (browser_->type() == Browser::TYPE_POPUP)
+    hide_tools = true;
+#endif
+
+  if (!hide_tools)
+    toolbar_->AddToolbarToBox(content_vbox_);
 
   bookmark_bar_.reset(new BookmarkBarGtk(browser_->profile(), browser_.get(),
                                          this));
   bookmark_bar_->AddBookmarkbarToBox(content_vbox_);
 
   // This vbox surrounds the render area: find bar, info bars and render view.
   // The reason is that this area as a whole needs to be grouped in its own
   // GdkWindow hierarchy so that animations originating inside it (infobar,
   // download shelf, find bar) are all clipped to that area. This is why
   // |render_area_vbox_| is packed in |event_box|.
   render_area_vbox_ = gtk_vbox_new(FALSE, 0);
   infobar_container_.reset(new InfoBarContainerGtk(this));
   gtk_box_pack_start(GTK_BOX(render_area_vbox_),
                      infobar_container_->widget(),
                      FALSE, FALSE, 0);
 
   status_bubble_.reset(new StatusBubbleGtk());
 
   contents_container_.reset(new TabContentsContainerGtk(status_bubble_.get()));
   contents_container_->AddContainerToBox(render_area_vbox_);
   gtk_widget_show_all(render_area_vbox_);
 
+#if defined(LINUX2)
+  if (browser_->type() == Browser::TYPE_POPUP) {
+    // The window manager needs the min size for popups
+    gtk_widget_set_size_request(
+        GTK_WIDGET(window_), bounds_.width(), bounds_.height());
+  }
+#endif
+
   // We have to realize the window before we try to apply a window shape mask.
   gtk_widget_realize(GTK_WIDGET(window_));
   state_ = gdk_window_get_state(GTK_WIDGET(window_)->window);
   // Note that calling this the first time is necessary to get the
   // proper control layout.
   UpdateCustomFrame();
 
   GtkWidget* event_box = gtk_event_box_new();
   gtk_container_add(GTK_CONTAINER(event_box), render_area_vbox_);
   gtk_widget_show(event_box);
@@ skipping 311 matching lines @@
       *edge = GDK_WINDOW_EDGE_NORTH_EAST;
     } else if (y < bounds_.height() - kResizeAreaCornerSize) {
       *edge = GDK_WINDOW_EDGE_EAST;
     } else {
       *edge = GDK_WINDOW_EDGE_SOUTH_EAST;
     }
     return true;
   }
   NOTREACHED();
 }