chrome/browser/ui/gtk/tabs/dragged_view_gtk.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/gtk/tabs/dragged_view_gtk.h"
   6
   7 #include <gdk/gdk.h>
   8
   9 #include <algorithm>
  10
  11 #include "base/debug/trace_event.h"
  12 #include "base/i18n/rtl.h"
  13 #include "base/stl_util.h"
  14 #include "chrome/browser/extensions/tab_helper.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/themes/theme_service.h"
  17 #include "chrome/browser/themes/theme_service_factory.h"
  18 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
  19 #include "chrome/browser/ui/gtk/gtk_util.h"
  20 #include "chrome/browser/ui/gtk/tabs/drag_data.h"
  21 #include "chrome/browser/ui/gtk/tabs/tab_renderer_gtk.h"
  22 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  23 #include "content/public/browser/render_view_host.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "third_party/skia/include/core/SkShader.h"
  26 #include "ui/base/gtk/gtk_screen_util.h"
  27 #include "ui/base/x/x11_util.h"
  28 #include "ui/gfx/gtk_util.h"
  29
  30 using content::WebContents;
  31
  32 namespace {
  33
  34 // The size of the dragged window frame.
  35 const int kDragFrameBorderSize = 1;
  36 const int kTwiceDragFrameBorderSize = 2 * kDragFrameBorderSize;
  37
  38 // Used to scale the dragged window sizes.
  39 const float kScalingFactor = 0.5;
  40
  41 const int kAnimateToBoundsDurationMs = 150;
  42
  43 const gdouble kTransparentAlpha = (200.0f / 255.0f);
  44 const gdouble kOpaqueAlpha = 1.0f;
  45 const double kDraggedTabBorderColor[] = { 103.0 / 0xff,
  46                                           129.0 / 0xff,
  47                                           162.0 / 0xff };
  48
  49 }  // namespace
  50
  51 ////////////////////////////////////////////////////////////////////////////////
  52 // DraggedViewGtk, public:
  53
  54 DraggedViewGtk::DraggedViewGtk(DragData* drag_data,
  55                                const gfx::Point& mouse_tab_offset,
  56                                const gfx::Size& contents_size)
  57     : drag_data_(drag_data),
  58       mini_width_(-1),
  59       normal_width_(-1),
  60       attached_(false),
  61       parent_window_width_(-1),
  62       mouse_tab_offset_(mouse_tab_offset),
  63       attached_tab_size_(TabRendererGtk::GetMinimumSelectedSize()),
  64       contents_size_(contents_size),
  65       close_animation_(this) {
  66   std::vector<WebContents*> data_sources(drag_data_->GetDraggedTabsContents());
  67   for (size_t i = 0; i < data_sources.size(); i++) {
  68     renderers_.push_back(new TabRendererGtk(GtkThemeService::GetFrom(
  69         Profile::FromBrowserContext(data_sources[i]->GetBrowserContext()))));
  70   }
  71
  72   for (size_t i = 0; i < drag_data_->size(); i++) {
  73     WebContents* web_contents = drag_data_->get(i)->contents_;
  74     renderers_[i]->UpdateData(
  75         web_contents,
  76         extensions::TabHelper::FromWebContents(web_contents)->is_app(),
  77         false); // loading_only
  78     renderers_[i]->set_is_active(
  79         static_cast<int>(i) == drag_data_->source_tab_index());
  80   }
  81
  82   container_ = gtk_window_new(GTK_WINDOW_POPUP);
  83   SetContainerColorMap();
  84   gtk_widget_set_app_paintable(container_, TRUE);
  85   g_signal_connect(container_, "expose-event", G_CALLBACK(OnExposeThunk), this);
  86   gtk_widget_add_events(container_, GDK_STRUCTURE_MASK);
  87
  88   // We contain the tab renderer in a GtkFixed in order to maintain the
  89   // requested size.  Otherwise, the widget will fill the entire window and
  90   // cause a crash when rendering because the bounds don't match our images.
  91   fixed_ = gtk_fixed_new();
  92   for (size_t i = 0; i < renderers_.size(); i++)
  93     gtk_fixed_put(GTK_FIXED(fixed_), renderers_[i]->widget(), 0, 0);
  94
  95   gtk_container_add(GTK_CONTAINER(container_), fixed_);
  96   gtk_widget_show_all(container_);
  97 }
  98
  99 DraggedViewGtk::~DraggedViewGtk() {
 100   gtk_widget_destroy(container_);
 101   STLDeleteElements(&renderers_);
 102 }
 103
 104 void DraggedViewGtk::MoveDetachedTo(const gfx::Point& screen_point) {
 105   DCHECK(!attached_);
 106   gfx::Point distance_from_origin =
 107       GetDistanceFromTabStripOriginToMousePointer();
 108   int y = screen_point.y() - ScaleValue(distance_from_origin.y());
 109   int x = screen_point.x() - ScaleValue(distance_from_origin.x());
 110   gtk_window_move(GTK_WINDOW(container_), x, y);
 111 }
 112
 113 void DraggedViewGtk::MoveAttachedTo(const gfx::Point& tabstrip_point) {
 114   DCHECK(attached_);
 115   int x = tabstrip_point.x() + GetWidthInTabStripUpToMousePointer() -
 116       ScaleValue(GetWidthInTabStripUpToMousePointer());
 117   int y = tabstrip_point.y() + mouse_tab_offset_.y() -
 118       ScaleValue(mouse_tab_offset_.y());
 119   gtk_window_move(GTK_WINDOW(container_), x, y);
 120 }
 121
 122 gfx::Point DraggedViewGtk::GetDistanceFromTabStripOriginToMousePointer() {
 123   gfx::Point start_point(GetWidthInTabStripUpToMousePointer(),
 124                          mouse_tab_offset_.y());
 125   if (base::i18n::IsRTL())
 126     start_point.Offset(parent_window_width_ - GetTotalWidthInTabStrip(), 0);
 127   return start_point;
 128 }
 129
 130 void DraggedViewGtk::Attach(
 131     int normal_width, int mini_width, int window_width) {
 132   attached_ = true;
 133   parent_window_width_ = window_width;
 134   normal_width_ = normal_width;
 135   mini_width_ = mini_width;
 136
 137   int dragged_tab_width =
 138       drag_data_->GetSourceTabData()->mini_ ? mini_width : normal_width;
 139
 140   Resize(dragged_tab_width);
 141
 142   if (ui::IsScreenComposited()) {
 143     GdkWindow* gdk_window = gtk_widget_get_window(container_);
 144     gdk_window_set_opacity(gdk_window, kOpaqueAlpha);
 145   }
 146 }
 147
 148 void DraggedViewGtk::Resize(int width) {
 149   attached_tab_size_.set_width(width);
 150   ResizeContainer();
 151 }
 152
 153 void DraggedViewGtk::Detach() {
 154   attached_ = false;
 155   ResizeContainer();
 156
 157   if (ui::IsScreenComposited()) {
 158     GdkWindow* gdk_window = gtk_widget_get_window(container_);
 159     gdk_window_set_opacity(gdk_window, kTransparentAlpha);
 160   }
 161 }
 162
 163 void DraggedViewGtk::Update() {
 164   gtk_widget_queue_draw(container_);
 165 }
 166
 167 int DraggedViewGtk::GetWidthInTabStripFromTo(int from, int to) {
 168   DCHECK(from <= static_cast<int>(drag_data_->size()));
 169   DCHECK(to <= static_cast<int>(drag_data_->size()));
 170
 171   // TODO(dpapad): Get 16 from TabStripGtk::kTabHOffset.
 172   int mini_tab_count = 0, non_mini_tab_count = 0;
 173   drag_data_->GetNumberOfMiniNonMiniTabs(from, to,
 174                                          &mini_tab_count, &non_mini_tab_count);
 175   int width = non_mini_tab_count * static_cast<int>(floor(normal_width_ + 0.5))
 176       + mini_tab_count * mini_width_ - std::max(to - from - 1, 0) * 16;
 177   return width;
 178 }
 179
 180 int DraggedViewGtk::GetTotalWidthInTabStrip() {
 181   return GetWidthInTabStripFromTo(0, drag_data_->size());
 182 }
 183
 184 int DraggedViewGtk::GetWidthInTabStripUpToSourceTab() {
 185   if (!base::i18n::IsRTL()) {
 186     return GetWidthInTabStripFromTo(0, drag_data_->source_tab_index());
 187   } else {
 188     return GetWidthInTabStripFromTo(
 189         drag_data_->source_tab_index() + 1, drag_data_->size());
 190   }
 191 }
 192
 193 int DraggedViewGtk::GetWidthInTabStripUpToMousePointer() {
 194    int width = GetWidthInTabStripUpToSourceTab() + mouse_tab_offset_.x();
 195    if (!base::i18n::IsRTL() && drag_data_->source_tab_index() > 0) {
 196      width -= 16;
 197    } else if (base::i18n::IsRTL() &&
 198               drag_data_->source_tab_index() <
 199                   static_cast<int>(drag_data_->size()) - 1) {
 200      width -= 16;
 201    }
 202    return width;
 203 }
 204
 205 void DraggedViewGtk::AnimateToBounds(const gfx::Rect& bounds,
 206                                      const base::Closure& callback) {
 207   animation_callback_ = callback;
 208
 209   gint x, y, width, height;
 210   GdkWindow* gdk_window = gtk_widget_get_window(container_);
 211   gdk_window_get_origin(gdk_window, &x, &y);
 212   gdk_window_get_geometry(gdk_window, NULL, NULL,
 213                           &width, &height, NULL);
 214
 215   animation_start_bounds_ = gfx::Rect(x, y, width, height);
 216   animation_end_bounds_ = bounds;
 217
 218   close_animation_.SetSlideDuration(kAnimateToBoundsDurationMs);
 219   close_animation_.SetTweenType(gfx::Tween::EASE_OUT);
 220   if (!close_animation_.IsShowing()) {
 221     close_animation_.Reset();
 222     close_animation_.Show();
 223   }
 224 }
 225
 226 ////////////////////////////////////////////////////////////////////////////////
 227 // DraggedViewGtk, gfx::AnimationDelegate implementation:
 228
 229 void DraggedViewGtk::AnimationProgressed(const gfx::Animation* animation) {
 230   int delta_x = (animation_end_bounds_.x() - animation_start_bounds_.x());
 231   int x = animation_start_bounds_.x() +
 232       static_cast<int>(delta_x * animation->GetCurrentValue());
 233   int y = animation_end_bounds_.y();
 234   GdkWindow* gdk_window = gtk_widget_get_window(container_);
 235   gdk_window_move(gdk_window, x, y);
 236 }
 237
 238 void DraggedViewGtk::AnimationEnded(const gfx::Animation* animation) {
 239   animation_callback_.Run();
 240 }
 241
 242 void DraggedViewGtk::AnimationCanceled(const gfx::Animation* animation) {
 243   AnimationEnded(animation);
 244 }
 245
 246 ////////////////////////////////////////////////////////////////////////////////
 247 // DraggedViewGtk, private:
 248
 249 void DraggedViewGtk::Layout() {
 250   if (attached_) {
 251     for (size_t i = 0; i < renderers_.size(); i++) {
 252       gfx::Rect rect(GetPreferredSize());
 253       rect.set_width(GetAttachedTabWidthAt(i));
 254       renderers_[i]->SetBounds(rect);
 255     }
 256   } else {
 257     int left = 0;
 258     if (base::i18n::IsRTL())
 259       left = GetPreferredSize().width() - attached_tab_size_.width();
 260
 261     // The renderer_'s width should be attached_tab_size_.width() in both LTR
 262     // and RTL locales. Wrong width will cause the wrong positioning of the tab
 263     // view in dragging. Please refer to http://crbug.com/6223 for details.
 264     renderers_[drag_data_->source_tab_index()]->SetBounds(
 265         gfx::Rect(left, 0, attached_tab_size_.width(),
 266                   attached_tab_size_.height()));
 267   }
 268 }
 269
 270 gfx::Size DraggedViewGtk::GetPreferredSize() {
 271   if (attached_) {
 272     gfx::Size preferred_size(attached_tab_size_);
 273     preferred_size.set_width(GetTotalWidthInTabStrip());
 274     return preferred_size;
 275   }
 276
 277   int width = std::max(attached_tab_size_.width(), contents_size_.width()) +
 278       kTwiceDragFrameBorderSize;
 279   int height = attached_tab_size_.height() + kDragFrameBorderSize +
 280       contents_size_.height();
 281   return gfx::Size(width, height);
 282 }
 283
 284 void DraggedViewGtk::ResizeContainer() {
 285   gfx::Size size = GetPreferredSize();
 286   gtk_window_resize(GTK_WINDOW(container_),
 287                     ScaleValue(size.width()), ScaleValue(size.height()));
 288   Layout();
 289 }
 290
 291 int DraggedViewGtk::ScaleValue(int value) {
 292   return attached_ ? value : static_cast<int>(value * kScalingFactor);
 293 }
 294
 295 gfx::Rect DraggedViewGtk::bounds() const {
 296   gint x, y, width, height;
 297   gtk_window_get_position(GTK_WINDOW(container_), &x, &y);
 298   gtk_window_get_size(GTK_WINDOW(container_), &width, &height);
 299   return gfx::Rect(x, y, width, height);
 300 }
 301
 302 int DraggedViewGtk::GetAttachedTabWidthAt(int index) {
 303   return drag_data_->get(index)->mini_? mini_width_ : normal_width_;
 304 }
 305
 306 void DraggedViewGtk::SetContainerColorMap() {
 307   GdkScreen* screen = gtk_widget_get_screen(container_);
 308   GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen);
 309
 310   // If rgba is not available, use rgb instead.
 311   if (!colormap)
 312     colormap = gdk_screen_get_rgb_colormap(screen);
 313
 314   gtk_widget_set_colormap(container_, colormap);
 315 }
 316
 317 void DraggedViewGtk::SetContainerTransparency() {
 318   cairo_t* cairo_context = gdk_cairo_create(gtk_widget_get_window(container_));
 319   if (!cairo_context)
 320     return;
 321
 322   // Make the background of the dragged tab window fully transparent.  All of
 323   // the content of the window (child widgets) will be completely opaque.
 324   gfx::Size size = bounds().size();
 325   cairo_scale(cairo_context, static_cast<double>(size.width()),
 326               static_cast<double>(size.height()));
 327   cairo_set_source_rgba(cairo_context, 1.0f, 1.0f, 1.0f, 0.0f);
 328   cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
 329   cairo_paint(cairo_context);
 330   cairo_destroy(cairo_context);
 331 }
 332
 333 void DraggedViewGtk::SetContainerShapeMask() {
 334   // Create a 1bpp bitmap the size of |container_|.
 335   gfx::Size size(GetPreferredSize());
 336   GdkPixmap* pixmap = gdk_pixmap_new(NULL, size.width(), size.height(), 1);
 337   cairo_t* cairo_context = gdk_cairo_create(GDK_DRAWABLE(pixmap));
 338
 339   // Set the transparency.
 340   cairo_set_source_rgba(cairo_context, 1.0f, 1.0f, 1.0f, 0.0f);
 341
 342   // Blit the rendered bitmap into a pixmap.  Any pixel set in the pixmap will
 343   // be opaque in the container window.
 344   if (!attached_)
 345     cairo_scale(cairo_context, kScalingFactor, kScalingFactor);
 346   for (size_t i = 0; i < renderers_.size(); i++) {
 347     if (static_cast<int>(i) == 0)
 348       cairo_set_operator(cairo_context, CAIRO_OPERATOR_SOURCE);
 349     else
 350       cairo_set_operator(cairo_context, CAIRO_OPERATOR_OVER);
 351
 352     GtkAllocation allocation;
 353     gtk_widget_get_allocation(container_, &allocation);
 354     PaintTab(i, container_, cairo_context, allocation.width);
 355   }
 356
 357   if (!attached_) {
 358     // Make the render area depiction opaque (leaving enough room for the
 359     // border).
 360     cairo_identity_matrix(cairo_context);
 361     // On Lucid running VNC, the X server will reject RGBA (1,1,1,1) as an
 362     // invalid value below in gdk_window_shape_combine_mask(). Using (0,0,0,1)
 363     // instead. The value doesn't really matter, as long as the alpha is not 0.
 364     cairo_set_source_rgba(cairo_context, 0.0f, 0.0f, 0.0f, 1.0f);
 365     int tab_height = static_cast<int>(
 366         kScalingFactor * renderers_[drag_data_->source_tab_index()]->height() -
 367             kDragFrameBorderSize);
 368     cairo_rectangle(cairo_context,
 369                     0, tab_height,
 370                     size.width(), size.height() - tab_height);
 371     cairo_fill(cairo_context);
 372   }
 373
 374   cairo_destroy(cairo_context);
 375
 376   // Set the shape mask.
 377   GdkWindow* gdk_window = gtk_widget_get_window(container_);
 378   gdk_window_shape_combine_mask(gdk_window, pixmap, 0, 0);
 379   g_object_unref(pixmap);
 380 }
 381
 382 gboolean DraggedViewGtk::OnExpose(GtkWidget* widget, GdkEventExpose* event) {
 383   TRACE_EVENT0("ui::gtk", "DraggedViewGtk::OnExpose");
 384
 385   if (ui::IsScreenComposited())
 386     SetContainerTransparency();
 387   else
 388     SetContainerShapeMask();
 389
 390   // Only used when not attached.
 391   int tab_height = static_cast<int>(
 392       kScalingFactor * renderers_[drag_data_->source_tab_index()]->height());
 393
 394   GtkAllocation allocation;
 395   gtk_widget_get_allocation(widget, &allocation);
 396
 397   // Draw the render area.
 398   if (!attached_) {
 399     content::RenderWidgetHost* render_widget_host =
 400         drag_data_->GetSourceWebContents()->GetRenderViewHost();
 401
 402     // This leaves room for the border.
 403     gfx::Rect dest_rect(kDragFrameBorderSize, tab_height,
 404                         allocation.width - kTwiceDragFrameBorderSize,
 405                         allocation.height - tab_height -
 406                         kDragFrameBorderSize);
 407     render_widget_host->CopyFromBackingStoreToGtkWindow(
 408         dest_rect, GDK_DRAWABLE(gtk_widget_get_window(widget)));
 409   }
 410
 411   cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
 412   // Draw the border.
 413   if (!attached_) {
 414     cairo_set_line_width(cr, kDragFrameBorderSize);
 415     cairo_set_source_rgb(cr, kDraggedTabBorderColor[0],
 416                              kDraggedTabBorderColor[1],
 417                              kDraggedTabBorderColor[2]);
 418     // |offset| is the distance from the edge of the image to the middle of
 419     // the border line.
 420     double offset = kDragFrameBorderSize / 2.0 - 0.5;
 421     double left_x = offset;
 422     double top_y = tab_height - kDragFrameBorderSize + offset;
 423     double right_x = allocation.width - offset;
 424     double bottom_y = allocation.height - offset;
 425
 426     cairo_move_to(cr, left_x, top_y);
 427     cairo_line_to(cr, left_x, bottom_y);
 428     cairo_line_to(cr, right_x, bottom_y);
 429     cairo_line_to(cr, right_x, top_y);
 430     cairo_line_to(cr, left_x, top_y);
 431     cairo_stroke(cr);
 432   }
 433
 434   // Draw the tab.
 435   if (!attached_)
 436     cairo_scale(cr, kScalingFactor, kScalingFactor);
 437   // Painting all but the active tab first, from last to first.
 438   for (int i = renderers_.size() - 1; i >= 0; i--) {
 439     if (i == drag_data_->source_tab_index())
 440       continue;
 441     PaintTab(i, widget, cr, allocation.width);
 442   }
 443   // Painting the active tab last, so that it appears on top.
 444   PaintTab(drag_data_->source_tab_index(), widget, cr,
 445            allocation.width);
 446
 447   cairo_destroy(cr);
 448
 449   // We've already drawn the tab, so don't propagate the expose-event signal.
 450   return TRUE;
 451 }
 452
 453 void DraggedViewGtk::PaintTab(int index, GtkWidget* widget, cairo_t* cr,
 454                               int widget_width) {
 455   renderers_[index]->set_mini(drag_data_->get(index)->mini_);
 456   cairo_surface_t* surface = renderers_[index]->PaintToSurface(widget, cr);
 457
 458   int paint_at = 0;
 459   if (!base::i18n::IsRTL()) {
 460     paint_at = std::max(GetWidthInTabStripFromTo(0, index) - 16, 0);
 461   } else {
 462     paint_at = GetTotalWidthInTabStrip() -
 463         GetWidthInTabStripFromTo(0, index + 1);
 464     if (!attached_) {
 465       paint_at = widget_width / kScalingFactor -
 466           GetWidthInTabStripFromTo(0, index + 1);
 467     }
 468   }
 469
 470   cairo_set_source_surface(cr, surface, paint_at, 0);
 471   cairo_paint(cr);
 472   cairo_surface_destroy(surface);
 473 }