/*
* Copyright (C) 2007 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "WebDragClient.h"
#include "WebDropSource.h"
#include "WebKitGraphics.h"
#include "WebView.h"
#include <shlobj.h>
#pragma warning(push, 0)
#include <WebCore/ClipboardWin.h>
#include <WebCore/DragController.h>
#include <WebCore/DragData.h>
#include <WebCore/Font.h>
#include <WebCore/FontDescription.h>
#include <WebCore/FontSelector.h>
#include <WebCore/FrameView.h>
#include <WebCore/GraphicsContext.h>
#include <WebCore/Page.h>
#include <WebCore/Settings.h>
#include <WebCore/StringTruncator.h>
#include <WebCore/WebCoreTextRenderer.h>
#pragma warning(pop)
namespace WebCore {
HBITMAP allocImage(HDC dc, IntSize size, PlatformGraphicsContext** targetRef);
void deallocContext(PlatformGraphicsContext* target);
}
#define DRAG_LABEL_BORDER_X 4
// Keep border_y in synch with DragController::LinkDragBorderInset
#define DRAG_LABEL_BORDER_Y 2
#define DRAG_LABEL_RADIUS 5
#define DRAG_LABEL_BORDER_Y_OFFSET 2
#define MIN_DRAG_LABEL_WIDTH_BEFORE_CLIP 120
// Observation says max size is 200x200
#define MAX_DRAG_LABEL_WIDTH 200
#define MAX_DRAG_LABEL_STRING_WIDTH (MAX_DRAG_LABEL_WIDTH - 2 * DRAG_LABEL_BORDER_X)
#define DRAG_LINK_LABEL_FONT_SIZE 11
#define DRAG_LINK_URL_FONT_SIZE 10
using namespace WebCore;
static DWORD draggingSourceOperationMaskToDragCursors(DragOperation op)
{
DWORD result = DROPEFFECT_NONE;
if (op == DragOperationEvery)
return DROPEFFECT_COPY | DROPEFFECT_LINK | DROPEFFECT_MOVE;
if (op & DragOperationCopy)
result |= DROPEFFECT_COPY;
if (op & DragOperationLink)
result |= DROPEFFECT_LINK;
if (op & DragOperationMove)
result |= DROPEFFECT_MOVE;
if (op & DragOperationGeneric)
result |= DROPEFFECT_MOVE;
return result;
}
WebDragClient::WebDragClient(WebView* webView)
: m_webView(webView)
{
ASSERT(webView);
}
DragDestinationAction WebDragClient::actionMaskForDrag(DragData* dragData)
{
COMPtr<IWebUIDelegate> delegateRef = 0;
//Default behaviour (eg. no delegate, or callback not implemented) is to allow
//any action
WebDragDestinationAction mask = WebDragDestinationActionAny;
if (SUCCEEDED(m_webView->uiDelegate(&delegateRef)))
delegateRef->dragDestinationActionMaskForDraggingInfo(m_webView, dragData->platformData(), &mask);
return (DragDestinationAction)mask;
}
void WebDragClient::willPerformDragDestinationAction(DragDestinationAction action, DragData* dragData)
{
//Default delegate for willPerformDragDestinationAction has no side effects
//so we just call the delegate, and don't worry about whether it's implemented
COMPtr<IWebUIDelegate> delegateRef = 0;
if (SUCCEEDED(m_webView->uiDelegate(&delegateRef)))
delegateRef->willPerformDragDestinationAction(m_webView, (WebDragDestinationAction)action, dragData->platformData());
}
DragSourceAction WebDragClient::dragSourceActionMaskForPoint(const IntPoint& windowPoint)
{
COMPtr<IWebUIDelegate> delegateRef = 0;
WebDragSourceAction action = WebDragSourceActionAny;
POINT localpt = core(m_webView)->mainFrame()->view()->windowToContents(windowPoint);
if (SUCCEEDED(m_webView->uiDelegate(&delegateRef)))
delegateRef->dragSourceActionMaskForPoint(m_webView, &localpt, &action);
return (DragSourceAction)action;
}
void WebDragClient::willPerformDragSourceAction(DragSourceAction action, const IntPoint& intPoint, Clipboard* clipboard)
{
COMPtr<IWebUIDelegate> uiDelegate;
if (!SUCCEEDED(m_webView->uiDelegate(&uiDelegate)))
return;
POINT point = intPoint;
COMPtr<IDataObject> dataObject = static_cast<ClipboardWin*>(clipboard)->dataObject();
COMPtr<IDataObject> newDataObject;
HRESULT result = uiDelegate->willPerformDragSourceAction(m_webView, static_cast<WebDragSourceAction>(action), &point, dataObject.get(), &newDataObject);
if (result == S_OK && newDataObject != dataObject)
static_cast<ClipboardWin*>(clipboard)->setExternalDataObject(newDataObject.get());
}
void WebDragClient::startDrag(DragImageRef image, const IntPoint& imageOrigin, const IntPoint& dragPoint, Clipboard* clipboard, Frame* frame, bool isLink)
{
//FIXME: Allow UIDelegate to override behaviour <rdar://problem/5015953>
//We liberally protect everything, to protect against a load occurring mid-drag
RefPtr<Frame> frameProtector = frame;
COMPtr<IDragSourceHelper> helper;
COMPtr<IDataObject> dataObject;
COMPtr<WebView> viewProtector = m_webView;
COMPtr<IDropSource> source;
if (FAILED(WebDropSource::createInstance(m_webView, &source)))
return;
dataObject = static_cast<ClipboardWin*>(clipboard)->dataObject();
if (source && (image || dataObject)) {
if (image) {
if(SUCCEEDED(CoCreateInstance(CLSID_DragDropHelper, 0, CLSCTX_INPROC_SERVER,
IID_IDragSourceHelper,(LPVOID*)&helper))) {
BITMAP b;
GetObject(image, sizeof(BITMAP), &b);
SHDRAGIMAGE sdi;
sdi.sizeDragImage.cx = b.bmWidth;
sdi.sizeDragImage.cy = b.bmHeight;
sdi.crColorKey = 0xffffffff;
sdi.hbmpDragImage = image;
sdi.ptOffset.x = dragPoint.x() - imageOrigin.x();
sdi.ptOffset.y = dragPoint.y() - imageOrigin.y();
if (isLink)
sdi.ptOffset.y = b.bmHeight - sdi.ptOffset.y;
helper->InitializeFromBitmap(&sdi, dataObject.get());
}
}
DWORD okEffect = draggingSourceOperationMaskToDragCursors(m_webView->page()->dragController()->sourceDragOperation());
DWORD effect = DROPEFFECT_NONE;
COMPtr<IWebUIDelegate> ui;
HRESULT hr = E_NOTIMPL;
if (SUCCEEDED(m_webView->uiDelegate(&ui))) {
COMPtr<IWebUIDelegatePrivate> uiPrivate;
if (SUCCEEDED(ui->QueryInterface(IID_IWebUIDelegatePrivate, (void**)&uiPrivate)))
hr = uiPrivate->doDragDrop(m_webView, dataObject.get(), source.get(), okEffect, &effect);
}
if (hr == E_NOTIMPL)
hr = DoDragDrop(dataObject.get(), source.get(), okEffect, &effect);
DragOperation operation = DragOperationNone;
if (hr == DRAGDROP_S_DROP) {
if (effect & DROPEFFECT_COPY)
operation = DragOperationCopy;
else if (effect & DROPEFFECT_LINK)
operation = DragOperationLink;
else if (effect & DROPEFFECT_MOVE)
operation = DragOperationMove;
}
frame->eventHandler()->dragSourceEndedAt(generateMouseEvent(m_webView, false), operation);
}
}
static Font dragLabelFont(int size, bool bold, FontRenderingMode renderingMode)
{
NONCLIENTMETRICS metrics;
metrics.cbSize = sizeof(metrics);
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, metrics.cbSize, &metrics, 0);
FontDescription desc;
desc.setWeight(bold ? FontWeightBold : FontWeightNormal);
FontFamily family;
family.setFamily(metrics.lfSmCaptionFont.lfFaceName);
desc.setFamily(family);
desc.setSpecifiedSize((float)size);
desc.setComputedSize((float)size);
desc.setRenderingMode(renderingMode);
Font result = Font(desc, 0, 0);
result.update(0);
return result;
}
DragImageRef WebDragClient::createDragImageForLink(KURL& url, const String& inLabel, Frame* frame)
{
// This is more or less an exact match for the Mac OS X code.
const Font* labelFont;
const Font* urlFont;
if (frame->settings() && frame->settings()->fontRenderingMode() == AlternateRenderingMode) {
static const Font alternateRenderingModeLabelFont = dragLabelFont(DRAG_LINK_LABEL_FONT_SIZE, true, AlternateRenderingMode);
static const Font alternateRenderingModeURLFont = dragLabelFont(DRAG_LINK_URL_FONT_SIZE, false, AlternateRenderingMode);
labelFont = &alternateRenderingModeLabelFont;
urlFont = &alternateRenderingModeURLFont;
} else {
static const Font normalRenderingModeLabelFont = dragLabelFont(DRAG_LINK_LABEL_FONT_SIZE, true, NormalRenderingMode);
static const Font normalRenderingModeURLFont = dragLabelFont(DRAG_LINK_URL_FONT_SIZE, false, NormalRenderingMode);
labelFont = &normalRenderingModeLabelFont;
urlFont = &normalRenderingModeURLFont;
}
bool drawURLString = true;
bool clipURLString = false;
bool clipLabelString = false;
String urlString = url.string();
String label = inLabel;
if (label.isEmpty()) {
drawURLString = false;
label = urlString;
}
//First step in drawing the link drag image width
TextRun labelRun(label.impl());
TextRun urlRun(urlString.impl());
IntSize labelSize(labelFont->width(labelRun), labelFont->ascent() + labelFont->descent());
if (labelSize.width() > MAX_DRAG_LABEL_STRING_WIDTH){
labelSize.setWidth(MAX_DRAG_LABEL_STRING_WIDTH);
clipLabelString = true;
}
IntSize urlStringSize;
IntSize imageSize(labelSize.width() + DRAG_LABEL_BORDER_X * 2,
labelSize.height() + DRAG_LABEL_BORDER_Y * 2);
if (drawURLString) {
urlStringSize.setWidth(urlFont->width(urlRun));
urlStringSize.setHeight(urlFont->ascent() + urlFont->descent());
imageSize.setHeight(imageSize.height() + urlStringSize.height());
if (urlStringSize.width() > MAX_DRAG_LABEL_STRING_WIDTH) {
imageSize.setWidth(MAX_DRAG_LABEL_WIDTH);
clipURLString = true;
} else {
imageSize.setWidth(std::max(labelSize.width(), urlStringSize.width()) + DRAG_LABEL_BORDER_X * 2);
}
}
// We now know how big the image needs to be, so we create and
// fill the background
HBITMAP image = 0;
HDC dc = GetDC(0);
HDC workingDC = CreateCompatibleDC(dc);
if (!workingDC) {
ReleaseDC(0, dc);
return 0;
}
PlatformGraphicsContext* contextRef;
image = allocImage(workingDC, imageSize, &contextRef);
if (!image) {
DeleteDC(workingDC);
ReleaseDC(0, dc);
return 0;
}
::SelectObject(workingDC, image);
GraphicsContext context(contextRef);
// On Mac alpha is {0.7, 0.7, 0.7, 0.8}, however we can't control alpha
// for drag images on win, so we use 1
static const Color backgroundColor(140, 140, 140);
static const IntSize radii(DRAG_LABEL_RADIUS, DRAG_LABEL_RADIUS);
IntRect rect(0, 0, imageSize.width(), imageSize.height());
context.fillRoundedRect(rect, radii, radii, radii, radii, backgroundColor, DeviceColorSpace);
// Draw the text
static const Color topColor(0, 0, 0, 255); //original alpha = 0.75
static const Color bottomColor(255, 255, 255, 127); //original alpha = 0.5
if (drawURLString) {
if (clipURLString)
urlString = StringTruncator::rightTruncate(urlString, imageSize.width() - (DRAG_LABEL_BORDER_X * 2.0f), *urlFont, false);
IntPoint textPos(DRAG_LABEL_BORDER_X, imageSize.height() - (DRAG_LABEL_BORDER_Y_OFFSET + urlFont->descent()));
WebCoreDrawDoubledTextAtPoint(context, urlString, textPos, *urlFont, topColor, bottomColor);
}
if (clipLabelString)
label = StringTruncator::rightTruncate(label, imageSize.width() - (DRAG_LABEL_BORDER_X * 2.0f), *labelFont, false);
IntPoint textPos(DRAG_LABEL_BORDER_X, DRAG_LABEL_BORDER_Y + labelFont->pixelSize());
WebCoreDrawDoubledTextAtPoint(context, label, textPos, *labelFont, topColor, bottomColor);
deallocContext(contextRef);
DeleteDC(workingDC);
ReleaseDC(0, dc);
return image;
}
void WebDragClient::dragControllerDestroyed()
{
delete this;
}