Mac: implement drag-and-drop of URLs to tabs/tab strip.

chrome/browser/cocoa/tab_strip_controller.mm

 // 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.
 
 #import "chrome/browser/cocoa/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <limits>
+#include <string>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/mac_util.h"
 #include "base/nsimage_cache_mac.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/find_bar.h"
 #include "chrome/browser/find_bar_controller.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #import "chrome/browser/cocoa/browser_window_controller.h"
 #import "chrome/browser/cocoa/constrained_window_mac.h"
 #import "chrome/browser/cocoa/tab_strip_view.h"
 #import "chrome/browser/cocoa/tab_contents_controller.h"
 #import "chrome/browser/cocoa/tab_controller.h"
 #import "chrome/browser/cocoa/tab_strip_model_observer_bridge.h"
 #import "chrome/browser/cocoa/tab_view.h"
 #import "chrome/browser/cocoa/throbber_view.h"
+#include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "skia/ext/skia_utils_mac.h"
 #import "third_party/GTM/AppKit/GTMNSAnimation+Duration.h"
 
 NSString* const kTabStripNumberOfTabsChanged = @"kTabStripNumberOfTabsChanged";
 
+namespace {
+
 // A value to indicate tab layout should use the full available width of the
 // view.
-static const CGFloat kUseFullAvailableWidth = -1.0;
+const CGFloat kUseFullAvailableWidth = -1.0;
 
 // Left-side indent for tab layout so tabs don't overlap with the window
 // controls.
-static const CGFloat kIndentLeavingSpaceForControls = 64.0;
+const CGFloat kIndentLeavingSpaceForControls = 64.0;
+
+// The amount by which tabs overlap.
+const CGFloat kTabOverlap = 20.0;
+
+// The amount by which the new tab button is offset (from the tabs).
+const CGFloat kNewTabButtonOffset = 8.0;
 
 // Time (in seconds) in which tabs animate to their final position.
-static const NSTimeInterval kAnimationDuration = 0.2;
-
-namespace {
+const NSTimeInterval kAnimationDuration = 0.2;
 
 // Helper class for doing NSAnimationContext calls that takes a bool to disable
 // all the work.  Useful for code that wants to conditionally animate.
 class ScopedNSAnimationContextGroup {
  public:
   explicit ScopedNSAnimationContextGroup(bool animate)
       : animate_(animate) {
     if (animate_) {
       [NSAnimationContext beginGrouping];
     }
@@ skipping 40 matching lines @@
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate;
 - (void)animationDidStopForController:(TabController*)controller
                              finished:(BOOL)finished;
 - (NSInteger)indexFromModelIndex:(NSInteger)index;
 - (NSInteger)numberOfOpenTabs;
 - (NSInteger)numberOfOpenPinnedTabs;
 - (NSInteger)numberOfOpenUnpinnedTabs;
 - (void)mouseMoved:(NSEvent*)event;
 - (void)setTabTrackingAreasEnabled:(BOOL)enabled;
+- (void)droppingURLsAt:(NSPoint)location
+            givesIndex:(NSInteger*)index
+           disposition:(WindowOpenDisposition*)disposition;
 @end
 
 // A simple view class that prevents the Window Server from dragging the area
 // behind tabs. Sometimes core animation confuses it. Unfortunately, it can also
 // falsely pick up clicks during rapid tab closure, so we have to account for
 // that.
 @interface TabStripControllerDragBlockingView : NSView {
   TabStripController* controller_;  // weak; owns us
 }
 
@@ skipping 157 matching lines @@
     [newTabButton_ setAction:@selector(commandDispatch:)];
     [newTabButton_ setTag:IDC_NEW_TAB];
     newTabTrackingArea_.reset(
         [[NSTrackingArea alloc] initWithRect:[newTabButton_ bounds]
                                      options:(NSTrackingMouseEnteredAndExited |
                                               NSTrackingActiveAlways)
                                        owner:self
                                     userInfo:nil]);
     [newTabButton_ addTrackingArea:newTabTrackingArea_.get()];
     targetFrames_.reset([[NSMutableDictionary alloc] init]);
+
     dragBlockingView_.reset(
         [[TabStripControllerDragBlockingView alloc] initWithFrame:NSZeroRect
                                                        controller:self]);
     [self addSubviewToPermanentList:dragBlockingView_];
+
     newTabTargetFrame_ = NSMakeRect(0, 0, 0, 0);
     availableResizeWidth_ = kUseFullAvailableWidth;
 
     closingControllers_.reset([[NSMutableSet alloc] init]);
 
     // Install the permanent subviews.
     [self regenerateSubviewList];
 
     // Watch for notifications that the tab strip view has changed size so
     // we can tell it to layout for the new size.
@@ skipping 12 matching lines @@
                owner:self
             userInfo:nil]);
     [tabView_ addTrackingArea:trackingArea_.get()];
   }
   return self;
 }
 
 - (void)dealloc {
   if (trackingArea_.get())
     [tabView_ removeTrackingArea:trackingArea_.get()];
+
   [newTabButton_ removeTrackingArea:newTabTrackingArea_.get()];
   // Invalidate all closing animations so they don't call back to us after
   // we're gone.
   for (TabController* controller in closingControllers_.get()) {
     NSView* view = [controller view];
     [[[view animationForKey:@"frameOrigin"] delegate] invalidate];
   }
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
@@ skipping 255 matching lines @@
 // subclass of TabContentsController with everything stubbed out or by
 // abstracting a base class interface.
 // TODO(pinkerton): Note this doesn't do too well when the number of min-sized
 // tabs would cause an overflow.
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate {
   DCHECK([NSThread isMainThread]);
   if (![tabArray_ count])
     return;
 
-  const CGFloat kTabOverlap = 20.0;
-  const CGFloat kNewTabButtonOffset = 8.0;
   const CGFloat kMaxTabWidth = [TabController maxTabWidth];
   const CGFloat kMinTabWidth = [TabController minTabWidth];
   const CGFloat kMinSelectedTabWidth = [TabController minSelectedTabWidth];
   const CGFloat kPinnedTabWidth = [TabController pinnedTabWidth];
 
   NSRect enclosingRect = NSZeroRect;
   ScopedNSAnimationContextGroup mainAnimationGroup(animate);
   mainAnimationGroup.SetCurrentContextDuration(kAnimationDuration);
 
   // Update the current subviews and their z-order if requested.
@@ skipping 779 matching lines @@
       [subviews addObject:tabView];
     }
   }
   if (selectedTabView) {
     [subviews addObject:selectedTabView];
   }
   [tabView_ setSubviews:subviews];
   [self setTabTrackingAreasEnabled:mouseInside_];
 }
 
+// Get the index and disposition for a potential URL(s) drop given a location
+// (in window base coordinates). It considers x coordinate of the given
+// location. If it's in the "middle" of a tab, it drops on that tab. If it's to
+// the left, it inserts to the left, and similarly for the right.
+- (void)droppingURLsAt:(NSPoint)location
+            givesIndex:(NSInteger*)index
+           disposition:(WindowOpenDisposition*)disposition {
+  // Proportion of the tab which is considered the "middle" (and causes things
+  // to drop on that tab).
+  const double kMiddleProportion = 0.5;
+  const double kLRProportion = (1.0 - kMiddleProportion) / 2.0;
+
+  DCHECK(index && disposition);
+  NSInteger i = 0;
+  for (TabController* tab in tabArray_.get()) {
+    NSView* view = [tab view];
+    DCHECK([view isKindOfClass:[TabView class]]);
+
+    // Recall that |-[NSView frame]| is in its superview's coordinates, so a
+    // |TabView|'s frame is in the coordinates of the |TabStripView| (which is
+    // confusingly called |tabView_|).
+    NSRect frame = [tabView_ convertRectToBase:[view frame]];
+
+    // Modify the frame to make it "unoverlapped".
+    frame.origin.x += kTabOverlap / 2.0;
+    frame.size.width -= kTabOverlap;
+    if (frame.size.width < 1.0)
+      frame.size.width = 1.0;  // try to avoid complete failure
+
+    // Drop in a new tab to the left of tab |i|?
+    if (location.x < (frame.origin.x + kLRProportion * frame.size.width)) {
+      *index = i;
+      *disposition = NEW_FOREGROUND_TAB;
+      return;
+    }
+
+    // Drop on tab |i|?
+    if (location.x <= (frame.origin.x +
+                       (1.0 - kLRProportion) * frame.size.width)) {
+      *index = i;
+      *disposition = CURRENT_TAB;
+      return;
+    }
+
+    // (Dropping in a new tab to the right of tab |i| will be taken care of in
+    // the next iteration.)
+    i++;
+  }
+
+  // If we've made it here, we want to append a new tab to the end.
+  *index = -1;
+  *disposition = NEW_FOREGROUND_TAB;
+}
+
+// Drop URLs at the given location.
+- (void)dropURLs:(NSArray*)urls at:(NSPoint)location {
+  if ([urls count] < 1) {
+    NOTREACHED();
+    return;
+  }
+
+  //TODO(viettrungluu): dropping multiple URLs.
+  if ([urls count] > 1)
+    NOTIMPLEMENTED();
+
+  // Get the first URL and fix it up.
+  GURL url(URLFixerUpper::FixupURL(
+      base::SysNSStringToUTF8([urls objectAtIndex:0]), std::string()));
+
+  // Get the index and disposition.
+  NSInteger index;
+  WindowOpenDisposition disposition;
+  [self droppingURLsAt:location
+            givesIndex:&index
+           disposition:&disposition];
+
+  // Either insert a new tab or open in a current tab.
+  switch (disposition) {
+    case NEW_FOREGROUND_TAB:
+      browser_->AddTabWithURL(url, GURL(), PageTransition::TYPED, true, index,
+                              true, NULL);
+      break;
+    case CURRENT_TAB:
+      tabModel_->GetTabContentsAt(index)->OpenURL(url, GURL(), CURRENT_TAB,
+                                                  PageTransition::TYPED);
+      tabModel_->SelectTabContentsAt(index, true);
+      break;
+    default:
+      NOTIMPLEMENTED();
+  }
+}
+
+// Update (possibly showing) the indicator which indicates where an URL drop
+// would happen.
+- (void)indicateDropURLsAt:(NSPoint)location {
+// TODO(viettrungluu): Make the tabs move around, show an indicator, etc. This
+// requires a re-work of the tabs code....
+#if 0
+  NSInteger index;
+  WindowOpenDisposition disposition;
+  [self droppingURLsAt:location
+            givesIndex:&index
+           disposition:&disposition];
+
+  if (index == -1) {
+    // Append a tab at the end.
+    DCHECK(disposition == NEW_FOREGROUND_TAB);
+    // TODO(viettrungluu): ...
+  } else {
+    NSRect overRect = [[[tabArray_ objectAtIndex:index] view] frame];
+    switch (disposition) {
+      case NEW_FOREGROUND_TAB:
+        // Insert tab (to the left of the given tab).
+        // TODO(viettrungluu): ...
+        break;
+      case CURRENT_TAB:
+        // Overwrite the given tab.
+        // TODO(viettrungluu): ...
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  // TODO(viettrungluu): ...
+#endif
+}
+
+// Hide the indicator which indicates where an URL drop would happen.
+- (void)hideDropURLsIndicator {
+// TODO(viettrungluu): See TODO in |-indicateDropURLsAt:| above.
+}
+
 - (GTMWindowSheetController*)sheetController {
   if (!sheetController_.get())
     sheetController_.reset([[GTMWindowSheetController alloc]
         initWithWindow:[switchView_ window] delegate:self]);
   return sheetController_.get();
 }
 
 - (void)gtm_systemRequestsVisibilityForView:(NSView*)view {
   // This implementation is required by GTMWindowSheetController.
 
@@ skipping 82 matching lines @@
       // Show next sheet
       NSWindowController* controller = [[tab window] windowController];
       DCHECK([controller isKindOfClass:[BrowserWindowController class]]);
       windows.front()->Realize(
           static_cast<BrowserWindowController*>(controller));
     }
   }
 }
 
 @end