Changeset 63339 in webkit


Ignore:
Timestamp:
Jul 14, 2010 11:54:34 AM (14 years ago)
Author:
weinig@apple.com
Message:

Patch for ​https://bugs.webkit.org/show_bug.cgi?id=42232
Make changing Cursors work in WebKit2.

Reviewed by Darin Adler.

WebCore:

  • Converted Mac and Windows Cursor implementations to lazily create the platform cursor.
  • Add HostWindow function to set the cursor and use it from Widget::setCursor.
  • Rework Windows cursor code to use fewer global variables.
  • WebCore.exp.in: Updated
  • loader/EmptyClients.h:

(WebCore::EmptyChromeClient::setCursor):
(WebCore::EmptyChromeClient::setLastSetCursorToCurrentCursor):
Added empty implementations.

  • page/Chrome.cpp:

(WebCore::Chrome::setCursor):

  • page/Chrome.h:
  • page/ChromeClient.h:

Change existing setCursor() function to take a Cursor instead of a
PlatformCursorHandle. Added setLastSetCursorToCurrentCursor.

  • platform/Cursor.cpp:
  • platform/Cursor.h:

Added Cursor Type and the option of lazily creating the native cursor
(used on Mac and Windows for now).

  • platform/HostWindow.h:

Add setCursor.

  • platform/mac/CursorMac.mm:

(WebCore::createCustomCursor): This no longer needs to call determineHotSpot
as that is done when on construction of the cursor now and the hotSpot passed
in is correct.
(WebCore::Cursor::ensurePlatformCursor):
(WebCore::Cursor::Cursor):
(WebCore::Cursor::~Cursor):
(WebCore::Cursor::operator=):
(WebCore::Cursor::platformCursor):
Convert to lazily creating the native cursor on the first request and
storing the type.

  • platform/mac/WidgetMac.mm:

(WebCore::Widget::setCursor):
Use HostWindow::setCursor to set the cursor. This in turn will call the
ChromeClient.

  • platform/win/CursorWin.cpp:

(WebCore::createSharedCursor):
(WebCore::loadSharedCursor):
(WebCore::loadCursorByName):
(WebCore::Cursor::ensurePlatformCursor):
(WebCore::SharedCursor::~SharedCursor):
(WebCore::Cursor::Cursor):
(WebCore::Cursor::~Cursor):
(WebCore::Cursor::operator=):
(WebCore::Cursor::platformCursor):
Convert to lazily creating the native cursor on the first request and
storing the type.

  • platform/win/WidgetWin.cpp:

(WebCore::Widget::setCursor):
Use HostWindow::setCursor to set the cursor. This in turn will call the
ChromeClient.

  • plugins/win/PluginViewWin.cpp:

(WebCore::PluginView::handleMouseEvent):
Use the new setLastSetCursorToCurrentCursor client function to ensure
the cursor is properly updated when over a plugin.

  • platform/chromium/CursorChromium.cpp:
  • platform/efl/CursorEfl.cpp:
  • platform/gtk/CursorGtk.cpp:
  • platform/haiku/CursorHaiku.cpp:
  • platform/wince/CursorWince.cpp:
  • platform/wx/CursorWx.cpp:
  • platform/qt/CursorQt.cpp:

Change m_impl -> m_platformCursor.

WebKit:

  • efl/WebCoreSupport/ChromeClientEfl.cpp:

(WebCore::ChromeClientEfl::setCursor):

  • efl/WebCoreSupport/ChromeClientEfl.h:

Change prototype to match new one.

WebKit/chromium:

  • src/ChromeClientImpl.h:

(WebKit::ChromeClientImpl::setCursor):
Change prototype to match new one.

  • src/WebPopupMenuImpl.cpp:

(WebKit::WebPopupMenuImpl::setCursor):

  • src/WebPopupMenuImpl.h:

Add empty setCursor function to satisfy the HostWindow interface.

WebKit/gtk:

  • WebCoreSupport/ChromeClientGtk.cpp:

(WebKit::ChromeClient::setCursor):

  • WebCoreSupport/ChromeClientGtk.h:

Change prototype to match new one.

WebKit/haiku:

  • WebCoreSupport/ChromeClientHaiku.cpp:

(WebCore::ChromeClientHaiku::setCursor):

  • WebCoreSupport/ChromeClientHaiku.h:

Change prototype to match new one.

WebKit/mac:

  • WebCoreSupport/WebChromeClient.h:
  • WebCoreSupport/WebChromeClient.mm:

(WebChromeClient::setCursor):

  • WebView/WebView.mm:

Implement cursor changing at the WebKit level for the sake of WebKit2.
This functionality is being moved from WidgetMac.mm.
(+[WebView _pointingHandCursor]):
Update to use platformCursor() instead of impl().

WebKit/qt:

  • WebCoreSupport/ChromeClientQt.cpp:

(WebCore::ChromeClientQt::setCursor):

  • WebCoreSupport/ChromeClientQt.h:

Change prototype to match new one.

WebKit/win:

  • WebCoreSupport/WebChromeClient.cpp:

(WebChromeClient::setCursor):
We now need to grab the native cursor out of the WebCore cursor.

(WebChromeClient::setLastSetCursorToCurrentCursor):
Sets the WebView's "last set cursor" to be the current cursor so that
the cursor is set correctly for plugins.

  • WebCoreSupport/WebChromeClient.h:
  • WebView.cpp:

(WebView::WebView):
(WebView::WebViewWndProc):

  • WebView.h:

(WebView::setLastCursor):
Change the "last set cursor" to be stored as a member instead of a global.

WebKit/wx:

  • WebKitSupport/ChromeClientWx.cpp:

(WebCore::ChromeClientWx::setCursor):

  • WebKitSupport/ChromeClientWx.h:

Change prototype to match new one.

WebKit2:

  • Shared/CoreIPCSupport/WebPageProxyMessageKinds.h:

Add SetCursor message.

  • Shared/WebCoreArgumentCoders.h:

Add encoding/decoding of Cursors. For now we don't support Custom
cursors.

  • UIProcess/API/mac/PageClientImpl.h:
  • UIProcess/API/mac/PageClientImpl.mm:

(WebKit::PageClientImpl::setCursor):

  • UIProcess/PageClient.h:

Add pass through functions to get the cursor from the WebPageProxy
to the WKView.

  • UIProcess/API/mac/WKView.mm:

(-[WKView _setCursor:]):

  • UIProcess/API/mac/WKViewInternal.h:

Implement changing the cursor.

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::didReceiveMessage):
(WebKit::WebPageProxy::setCursor):

  • UIProcess/WebPageProxy.h:

Decode the cursor.

  • UIProcess/win/WebView.cpp:

(WebKit::WebView::wndProc):
(WebKit::WebView::WebView):
(WebKit::WebView::onSetCursor):
(WebKit::WebView::setCursor):

  • UIProcess/win/WebView.h:

Implement changing the cursor.

  • WebProcess/WebCoreSupport/WebChromeClient.cpp:

(WebKit::WebChromeClient::setCursor):
(WebKit::WebChromeClient::setLastSetCursorToCurrentCursor):

  • WebProcess/WebCoreSupport/WebChromeClient.h:

Encode the cursor when setCursor is called.

Location:
trunk
Files:
63 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r63338 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        - Converted Mac and Windows Cursor implementations to lazily
     9          create the platform cursor.
     10        - Add HostWindow function to set the cursor and use it from Widget::setCursor.
     11        - Rework Windows cursor code to use fewer global variables.
     12
     13        * WebCore.exp.in: Updated
     14        * loader/EmptyClients.h:
     15        (WebCore::EmptyChromeClient::setCursor):
     16        (WebCore::EmptyChromeClient::setLastSetCursorToCurrentCursor):
     17        Added empty implementations.
     18
     19        * page/Chrome.cpp:
     20        (WebCore::Chrome::setCursor):
     21        * page/Chrome.h:
     22        * page/ChromeClient.h:
     23        Change existing setCursor() function to take a Cursor instead of a
     24        PlatformCursorHandle. Added setLastSetCursorToCurrentCursor.
     25
     26        * platform/Cursor.cpp:
     27        * platform/Cursor.h:
     28        Added Cursor Type and the option of lazily creating the native cursor
     29        (used on Mac and Windows for now).
     30
     31        * platform/HostWindow.h:
     32        Add setCursor.
     33
     34        * platform/mac/CursorMac.mm:
     35        (WebCore::createCustomCursor): This no longer needs to call determineHotSpot
     36        as that is done when on construction of the cursor now and the hotSpot passed
     37        in is correct.
     38        (WebCore::Cursor::ensurePlatformCursor):
     39        (WebCore::Cursor::Cursor):
     40        (WebCore::Cursor::~Cursor):
     41        (WebCore::Cursor::operator=):
     42        (WebCore::Cursor::platformCursor):
     43        Convert to lazily creating the native cursor on the first request and
     44        storing the type.
     45
     46        * platform/mac/WidgetMac.mm:
     47        (WebCore::Widget::setCursor):
     48        Use HostWindow::setCursor to set the cursor. This in turn will call the
     49        ChromeClient.
     50
     51        * platform/win/CursorWin.cpp:
     52        (WebCore::createSharedCursor):
     53        (WebCore::loadSharedCursor):
     54        (WebCore::loadCursorByName):
     55        (WebCore::Cursor::ensurePlatformCursor):
     56        (WebCore::SharedCursor::~SharedCursor):
     57        (WebCore::Cursor::Cursor):
     58        (WebCore::Cursor::~Cursor):
     59        (WebCore::Cursor::operator=):
     60        (WebCore::Cursor::platformCursor):
     61        Convert to lazily creating the native cursor on the first request and
     62        storing the type.
     63
     64        * platform/win/WidgetWin.cpp:
     65        (WebCore::Widget::setCursor):
     66        Use HostWindow::setCursor to set the cursor. This in turn will call the
     67        ChromeClient.
     68
     69        * plugins/win/PluginViewWin.cpp:
     70        (WebCore::PluginView::handleMouseEvent):
     71        Use the new setLastSetCursorToCurrentCursor client function to ensure
     72        the cursor is properly updated when over a plugin.
     73
     74        * platform/chromium/CursorChromium.cpp:
     75        * platform/efl/CursorEfl.cpp:
     76        * platform/gtk/CursorGtk.cpp:
     77        * platform/haiku/CursorHaiku.cpp:
     78        * platform/wince/CursorWince.cpp:
     79        * platform/wx/CursorWx.cpp:
     80        * platform/qt/CursorQt.cpp:
     81        Change m_impl -> m_platformCursor.
     82
    1832010-07-13  Eric Seidel  <eric@webkit.org>
    284

  • trunk/WebCore/WebCore.exp.in

    r63335 r63339  
    395395__ZN7WebCore17HTMLPlugInElement11getNPObjectEv
    396396__ZN7WebCore17HistoryController26saveDocumentAndScrollStateEv
     397__ZN7WebCore17nameForCursorTypeENS_6Cursor4TypeE
    397398__ZN7WebCore18deprecatedParseURLERKNS_6StringE
    398399__ZN7WebCore18isStartOfParagraphERKNS_15VisiblePositionE
    … …  
    542543__ZN7WebCore5RangeD1Ev
    543544__ZN7WebCore5cacheEv
     545__ZN7WebCore6Cursor8fromTypeENS0_4TypeE
     546__ZN7WebCore6CursorD1Ev
     547__ZN7WebCore6CursoraSERKS0_
    544548__ZN7WebCore6Editor10applyStyleEPNS_19CSSStyleDeclarationENS_10EditActionE
    545549__ZN7WebCore6Editor10insertTextERKNS_6StringEPNS_5EventE
    … …  
    934938__ZNK7WebCore5Range9firstNodeEv
    935939__ZNK7WebCore6Chrome12createWindowEPNS_5FrameERKNS_16FrameLoadRequestERKNS_14WindowFeaturesE
     940__ZNK7WebCore6Cursor14platformCursorEv
    936941__ZNK7WebCore6Editor13canEditRichlyEv
    937942__ZNK7WebCore6Editor16compositionRangeEv

  • trunk/WebCore/loader/EmptyClients.h

    r61113 r63339  
    154154    virtual PassOwnPtr<HTMLParserQuirks> createHTMLParserQuirks() { return 0; }
    155155
    156     virtual bool setCursor(PlatformCursorHandle) { return false; }
     156    virtual void setCursor(const Cursor&) { }
    157157
    158158    virtual void scrollRectIntoView(const IntRect&, const ScrollView*) const {}
    … …  
    167167#endif
    168168
     169#if PLATFORM(WIN)
     170    virtual void setLastSetCursorToCurrentCursor() { }
     171#endif
    169172#if ENABLE(TOUCH_EVENTS)
    170173    virtual void needTouchEvents(bool) { }

  • trunk/WebCore/page/Chrome.cpp

    r62834 r63339  
    427427}
    428428
    429 bool Chrome::setCursor(PlatformCursorHandle cursor)
    430 {
    431     return m_client->setCursor(cursor);
     429void Chrome::setCursor(const Cursor& cursor)
     430{
     431    m_client->setCursor(cursor);
    432432}
    433433

  • trunk/WebCore/page/Chrome.h

    r62834 r63339  
    7070        virtual PlatformPageClient platformPageClient() const;
    7171        virtual void scrollbarsModeDidChange() const;
     72        virtual void setCursor(const Cursor&);
    7273
    7374        void scrollRectIntoView(const IntRect&) const;
    … …  
    136137        void chooseIconForFiles(const Vector<String>&, FileChooser*);
    137138
    138         bool setCursor(PlatformCursorHandle);
    139 
    140139#if PLATFORM(MAC)
    141140        void focusNSView(NSView*);

  • trunk/WebCore/page/ChromeClient.h

    r62875 r63339  
    136136        virtual IntRect windowToScreen(const IntRect&) const = 0;
    137137        virtual PlatformPageClient platformPageClient() const = 0;
     138        virtual void scrollbarsModeDidChange() const = 0;
     139        virtual void setCursor(const Cursor&) = 0;
     140        // End methods used by HostWindow.
     141
    138142        virtual void contentsSizeChanged(Frame*, const IntSize&) const = 0;
    139143        virtual void scrollRectIntoView(const IntRect&, const ScrollView*) const = 0; // Currently only Mac has a non empty implementation.
    140         // End methods used by HostWindow.
    141 
    142         virtual void scrollbarsModeDidChange() const = 0;
     144       
    143145        virtual bool shouldMissingPluginMessageBeButton() const { return false; }
    144146        virtual void missingPluginButtonClicked(Element*) const { }
    … …  
    194196        // Asynchronous request to load an icon for specified filenames.
    195197        virtual void chooseIconForFiles(const Vector<String>&, FileChooser*) = 0;
    196 
    197         virtual bool setCursor(PlatformCursorHandle) = 0;
    198198
    199199        // Notification that the given form element has changed. This function
    … …  
    237237#endif
    238238
     239#if PLATFORM(WIN)
     240        virtual void setLastSetCursorToCurrentCursor() = 0;
     241#endif
     242
    239243#if ENABLE(TOUCH_EVENTS)
    240244        virtual void needTouchEvents(bool) = 0;

  • trunk/WebCore/platform/Cursor.cpp

    r60849 r63339  
    4747}
    4848
    49 }
     49const Cursor& Cursor::fromType(Cursor::Type type)
     50{
     51    switch (type) {
     52    case Cursor::Pointer:
     53        return pointerCursor();
     54    case Cursor::Cross:
     55        return crossCursor();
     56    case Cursor::Hand:
     57        return handCursor();
     58    case Cursor::IBeam:
     59        return iBeamCursor();
     60    case Cursor::Wait:
     61        return waitCursor();
     62    case Cursor::Help:
     63        return helpCursor();
     64    case Cursor::EastResize:
     65        return eastResizeCursor();
     66    case Cursor::NorthResize:
     67        return northResizeCursor();
     68    case Cursor::NorthEastResize:
     69        return northEastResizeCursor();
     70    case Cursor::NorthWestResize:
     71        return northWestResizeCursor();
     72    case Cursor::SouthResize:
     73        return southResizeCursor();
     74    case Cursor::SouthEastResize:
     75        return southEastResizeCursor();
     76    case Cursor::SouthWestResize:
     77        return southWestResizeCursor();
     78    case Cursor::WestResize:
     79        return westResizeCursor();
     80    case Cursor::NorthSouthResize:
     81        return northSouthResizeCursor();
     82    case Cursor::EastWestResize:
     83        return eastWestResizeCursor();
     84    case Cursor::NorthEastSouthWestResize:
     85        return northEastSouthWestResizeCursor();
     86    case Cursor::NorthWestSouthEastResize:
     87        return northWestSouthEastResizeCursor();
     88    case Cursor::ColumnResize:
     89        return columnResizeCursor();
     90    case Cursor::RowResize:
     91        return rowResizeCursor();
     92    case Cursor::MiddlePanning:
     93        return middlePanningCursor();
     94    case Cursor::EastPanning:
     95        return eastPanningCursor();
     96    case Cursor::NorthPanning:
     97        return northPanningCursor();
     98    case Cursor::NorthEastPanning:
     99        return northEastPanningCursor();
     100    case Cursor::NorthWestPanning:
     101        return northWestPanningCursor();
     102    case Cursor::SouthPanning:
     103        return southPanningCursor();
     104    case Cursor::SouthEastPanning:
     105        return southEastPanningCursor();
     106    case Cursor::SouthWestPanning:
     107        return southWestPanningCursor();
     108    case Cursor::WestPanning:
     109        return westPanningCursor();
     110    case Cursor::Move:
     111        return moveCursor();
     112    case Cursor::VerticalText:
     113        return verticalTextCursor();
     114    case Cursor::Cell:
     115        return cellCursor();
     116    case Cursor::ContextMenu:
     117        return contextMenuCursor();
     118    case Cursor::Alias:
     119        return aliasCursor();
     120    case Cursor::Progress:
     121        return progressCursor();
     122    case Cursor::NoDrop:
     123        return noDropCursor();
     124    case Cursor::Copy:
     125        return copyCursor();
     126    case Cursor::None:
     127        return noneCursor();
     128    case Cursor::NotAllowed:
     129        return notAllowedCursor();
     130    case Cursor::ZoomIn:
     131        return zoomInCursor();
     132    case Cursor::ZoomOut:
     133        return zoomOutCursor();
     134    case Cursor::Grab:
     135        return grabCursor();
     136    case Cursor::Grabbing:
     137        return grabbingCursor();
     138    case Cursor::Custom:
     139        ASSERT_NOT_REACHED();
     140    }
     141    return pointerCursor();
     142}
     143
     144const char* nameForCursorType(Cursor::Type type)
     145{
     146    switch (type) {
     147    case Cursor::Pointer:
     148        return "Pointer";
     149    case Cursor::Cross:
     150        return "Cross";
     151    case Cursor::Hand:
     152        return "Hand";
     153    case Cursor::IBeam:
     154        return "IBeam";
     155    case Cursor::Wait:
     156        return "Wait";
     157    case Cursor::Help:
     158        return "Help";
     159    case Cursor::EastResize:
     160        return "EastResize";
     161    case Cursor::NorthResize:
     162        return "NorthResize";
     163    case Cursor::NorthEastResize:
     164        return "NorthEastResize";
     165    case Cursor::NorthWestResize:
     166        return "NorthWestResize";
     167    case Cursor::SouthResize:
     168        return "SouthResize";
     169    case Cursor::SouthEastResize:
     170        return "SouthEastResize";
     171    case Cursor::SouthWestResize:
     172        return "SouthWestResize";
     173    case Cursor::WestResize:
     174        return "WestResize";
     175    case Cursor::NorthSouthResize:
     176        return "NorthSouthResize";
     177    case Cursor::EastWestResize:
     178        return "EastWestResize";
     179    case Cursor::NorthEastSouthWestResize:
     180        return "NorthEastSouthWestResize";
     181    case Cursor::NorthWestSouthEastResize:
     182        return "NorthWestSouthEastResize";
     183    case Cursor::ColumnResize:
     184        return "ColumnResize";
     185    case Cursor::RowResize:
     186        return "RowResize";
     187    case Cursor::MiddlePanning:
     188        return "MiddlePanning";
     189    case Cursor::EastPanning:
     190        return "EastPanning";
     191    case Cursor::NorthPanning:
     192        return "NorthPanning";
     193    case Cursor::NorthEastPanning:
     194        return "NorthEastPanning";
     195    case Cursor::NorthWestPanning:
     196        return "NorthWestPanning";
     197    case Cursor::SouthPanning:
     198        return "SouthPanning";
     199    case Cursor::SouthEastPanning:
     200        return "SouthEastPanning";
     201    case Cursor::SouthWestPanning:
     202        return "SouthWestPanning";
     203    case Cursor::WestPanning:
     204        return "WestPanning";
     205    case Cursor::Move:
     206        return "Move";
     207    case Cursor::VerticalText:
     208        return "VerticalText";
     209    case Cursor::Cell:
     210        return "Cell";
     211    case Cursor::ContextMenu:
     212        return "ContextMenu";
     213    case Cursor::Alias:
     214        return "Alias";
     215    case Cursor::Progress:
     216        return "Progress";
     217    case Cursor::NoDrop:
     218        return "NoDrop";
     219    case Cursor::Copy:
     220        return "Copy";
     221    case Cursor::None:
     222        return "None";
     223    case Cursor::NotAllowed:
     224        return "NotAllowed";
     225    case Cursor::ZoomIn:
     226        return "ZoomIn";
     227    case Cursor::ZoomOut:
     228        return "ZoomOut";
     229    case Cursor::Grab:
     230        return "Grab";
     231    case Cursor::Grabbing:
     232        return "Grabbing";
     233    case Cursor::Custom:
     234        return "Custom";
     235    }
     236
     237    return "ERROR";
     238}
     239
     240#if USE(LAZY_NATIVE_CURSOR)
     241
     242Cursor::Cursor(Image* image, const IntPoint& hotSpot)
     243    : m_type(Custom)
     244    , m_image(image)
     245    , m_hotSpot(determineHotSpot(image, hotSpot))
     246    , m_platformCursor(0)
     247{
     248}
     249
     250Cursor::Cursor(Type type)
     251    : m_type(type)
     252    , m_platformCursor(0)
     253{
     254}
     255
     256PlatformCursor Cursor::platformCursor() const
     257{
     258    ensurePlatformCursor();
     259    return m_platformCursor;
     260}
     261
     262const Cursor& pointerCursor()
     263{
     264    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Pointer));
     265    return c;
     266}
     267
     268const Cursor& crossCursor()
     269{
     270    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Cross));
     271    return c;
     272}
     273
     274const Cursor& handCursor()
     275{
     276    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Hand));
     277    return c;
     278}
     279
     280const Cursor& moveCursor()
     281{
     282    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Move));
     283    return c;
     284}
     285
     286const Cursor& verticalTextCursor()
     287{
     288    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::VerticalText));
     289    return c;
     290}
     291
     292const Cursor& cellCursor()
     293{
     294    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Cell));
     295    return c;
     296}
     297
     298const Cursor& contextMenuCursor()
     299{
     300    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::ContextMenu));
     301    return c;
     302}
     303
     304const Cursor& aliasCursor()
     305{
     306    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Alias));
     307    return c;
     308}
     309
     310const Cursor& zoomInCursor()
     311{
     312    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::ZoomIn));
     313    return c;
     314}
     315
     316const Cursor& zoomOutCursor()
     317{
     318    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::ZoomOut));
     319    return c;
     320}
     321
     322const Cursor& copyCursor()
     323{
     324    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Copy));
     325    return c;
     326}
     327
     328const Cursor& noneCursor()
     329{
     330    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::None));
     331    return c;
     332}
     333
     334const Cursor& progressCursor()
     335{
     336    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Progress));
     337    return c;
     338}
     339
     340const Cursor& noDropCursor()
     341{
     342    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NoDrop));
     343    return c;
     344}
     345
     346const Cursor& notAllowedCursor()
     347{
     348    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NotAllowed));
     349    return c;
     350}
     351
     352const Cursor& iBeamCursor()
     353{
     354    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::IBeam));
     355    return c;
     356}
     357
     358const Cursor& waitCursor()
     359{
     360    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Wait));
     361    return c;
     362}
     363
     364const Cursor& helpCursor()
     365{
     366    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Help));
     367    return c;
     368}
     369
     370const Cursor& eastResizeCursor()
     371{
     372    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::EastResize));
     373    return c;
     374}
     375
     376const Cursor& northResizeCursor()
     377{
     378    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthResize));
     379    return c;
     380}
     381
     382const Cursor& northEastResizeCursor()
     383{
     384    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthEastResize));
     385    return c;
     386}
     387
     388const Cursor& northWestResizeCursor()
     389{
     390    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthWestResize));
     391    return c;
     392}
     393
     394const Cursor& southResizeCursor()
     395{
     396    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthResize));
     397    return c;
     398}
     399
     400const Cursor& southEastResizeCursor()
     401{
     402    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthEastResize));
     403    return c;
     404}
     405
     406const Cursor& southWestResizeCursor()
     407{
     408    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthWestResize));
     409    return c;
     410}
     411
     412const Cursor& westResizeCursor()
     413{
     414    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::WestResize));
     415    return c;
     416}
     417
     418const Cursor& northSouthResizeCursor()
     419{
     420    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthSouthResize));
     421    return c;
     422}
     423
     424const Cursor& eastWestResizeCursor()
     425{
     426    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::EastWestResize));
     427    return c;
     428}
     429
     430const Cursor& northEastSouthWestResizeCursor()
     431{
     432    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthEastSouthWestResize));
     433    return c;
     434}
     435
     436const Cursor& northWestSouthEastResizeCursor()
     437{
     438    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthWestSouthEastResize));
     439    return c;
     440}
     441
     442const Cursor& columnResizeCursor()
     443{
     444    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::ColumnResize));
     445    return c;
     446}
     447
     448const Cursor& rowResizeCursor()
     449{
     450    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::RowResize));
     451    return c;
     452}
     453
     454const Cursor& middlePanningCursor()
     455{
     456    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::MiddlePanning));
     457    return c;
     458}
     459   
     460const Cursor& eastPanningCursor()
     461{
     462    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::EastPanning));
     463    return c;
     464}
     465   
     466const Cursor& northPanningCursor()
     467{
     468    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthPanning));
     469    return c;
     470}
     471   
     472const Cursor& northEastPanningCursor()
     473{
     474    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthEastPanning));
     475    return c;
     476}
     477   
     478const Cursor& northWestPanningCursor()
     479{
     480    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::NorthWestPanning));
     481    return c;
     482}
     483   
     484const Cursor& southPanningCursor()
     485{
     486    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthPanning));
     487    return c;
     488}
     489   
     490const Cursor& southEastPanningCursor()
     491{
     492    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthEastPanning));
     493    return c;
     494}
     495   
     496const Cursor& southWestPanningCursor()
     497{
     498    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::SouthWestPanning));
     499    return c;
     500}
     501   
     502const Cursor& westPanningCursor()
     503{
     504    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::WestPanning));
     505    return c;
     506}
     507
     508const Cursor& grabCursor()
     509{
     510    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Grab));
     511    return c;
     512}
     513
     514const Cursor& grabbingCursor()
     515{
     516    DEFINE_STATIC_LOCAL(Cursor, c, (Cursor::Grabbing));
     517    return c;
     518}
     519
     520#endif
     521
     522} // namespace WebCore

  • trunk/WebCore/platform/Cursor.h

    r60849 r63339  
    2727#define Cursor_h
    2828
     29#include "Image.h"
     30#include "IntPoint.h"
     31#include <wtf/RefPtr.h>
     32
    2933#if PLATFORM(WIN)
    3034typedef struct HICON__* HICON;
    … …  
    3236#include <wtf/PassRefPtr.h>
    3337#include <wtf/RefCounted.h>
    34 #include <wtf/RefPtr.h>
    3538#elif PLATFORM(GTK)
    3639typedef struct _GdkCursor GdkCursor;
    … …  
    6063#endif
    6164
     65#if PLATFORM(WIN) || PLATFORM(MAC)
     66#define WTF_USE_LAZY_NATIVE_CURSOR 1
     67#endif
     68
    6269namespace WebCore {
    6370
    6471    class Image;
    65     class IntPoint;
    6672
    6773#if PLATFORM(WIN)
    … …  
    7682    };
    7783    typedef RefPtr<SharedCursor> PlatformCursor;
    78     typedef HCURSOR PlatformCursorHandle;
    7984#elif PLATFORM(MAC)
    8085    typedef NSCursor* PlatformCursor;
    81     typedef NSCursor* PlatformCursorHandle;
    8286#elif PLATFORM(GTK)
    8387    typedef GdkCursor* PlatformCursor;
    84     typedef GdkCursor* PlatformCursorHandle;
    8588#elif PLATFORM(EFL)
    8689    typedef const char* PlatformCursor;
    87     typedef const char* PlatformCursorHandle;
    8890#elif PLATFORM(QT) && !defined(QT_NO_CURSOR)
    8991    typedef QCursor PlatformCursor;
    90     typedef QCursor* PlatformCursorHandle;
    9192#elif PLATFORM(WX)
    9293    typedef wxCursor* PlatformCursor;
    93     typedef wxCursor* PlatformCursorHandle;
    9494#elif PLATFORM(CHROMIUM)
    9595    // See PlatformCursor.h
    96     typedef void* PlatformCursorHandle;
    9796#elif PLATFORM(HAIKU)
    9897    typedef BCursor* PlatformCursor;
    99     typedef BCursor* PlatformCursorHandle;
    10098#else
    10199    typedef void* PlatformCursor;
    102     typedef void* PlatformCursorHandle;
    103100#endif
    104101
    105102    class Cursor {
    106103    public:
     104        enum Type {
     105            Pointer,
     106            Cross,
     107            Hand,
     108            IBeam,
     109            Wait,
     110            Help,
     111            EastResize,
     112            NorthResize,
     113            NorthEastResize,
     114            NorthWestResize,
     115            SouthResize,
     116            SouthEastResize,
     117            SouthWestResize,
     118            WestResize,
     119            NorthSouthResize,
     120            EastWestResize,
     121            NorthEastSouthWestResize,
     122            NorthWestSouthEastResize,
     123            ColumnResize,
     124            RowResize,
     125            MiddlePanning,
     126            EastPanning,
     127            NorthPanning,
     128            NorthEastPanning,
     129            NorthWestPanning,
     130            SouthPanning,
     131            SouthEastPanning,
     132            SouthWestPanning,
     133            WestPanning,
     134            Move,
     135            VerticalText,
     136            Cell,
     137            ContextMenu,
     138            Alias,
     139            Progress,
     140            NoDrop,
     141            Copy,
     142            None,
     143            NotAllowed,
     144            ZoomIn,
     145            ZoomOut,
     146            Grab,
     147            Grabbing,
     148            Custom
     149        };
     150
     151        static const Cursor& fromType(Cursor::Type);
     152
    107153        Cursor()
    108154#if !PLATFORM(QT) && !PLATFORM(EFL)
    109         : m_impl(0)
    110 #endif
    111         { }
     155            : m_platformCursor(0)
     156#endif
     157        {
     158        }
    112159
    113160        Cursor(Image*, const IntPoint& hotSpot);
    … …  
    116163        Cursor& operator=(const Cursor&);
    117164
     165#if USE(LAZY_NATIVE_CURSOR)
     166        Cursor(Type);
     167        Type type() const { return m_type; }
     168        Image* image() const { return m_image.get(); }
     169        const IntPoint& hotSpot() const { return m_hotSpot; }
     170        PlatformCursor platformCursor() const;
     171#else
    118172        Cursor(PlatformCursor);
    119         PlatformCursor impl() const { return m_impl; }
     173        PlatformCursor impl() const { return m_platformCursor; }
     174#endif
    120175
    121176     private:
    122         PlatformCursor m_impl;
     177#if USE(LAZY_NATIVE_CURSOR)
     178        void ensurePlatformCursor() const;
     179
     180        Type m_type;
     181        RefPtr<Image> m_image;
     182        IntPoint m_hotSpot;
     183#endif
     184
     185        mutable PlatformCursor m_platformCursor;
    123186    };
    124187
    125188    IntPoint determineHotSpot(Image*, const IntPoint& specifiedHotSpot);
    126 
     189    const char* nameForCursorType(Cursor::Type);
     190   
    127191    const Cursor& pointerCursor();
    128192    const Cursor& crossCursor();

  • trunk/WebCore/platform/HostWindow.h

    r58445 r63339  
    3232namespace WebCore {
    3333
     34class Cursor;
     35
    3436class HostWindow : public Noncopyable {
    3537public:
    … …  
    5759    // To notify WebKit of scrollbar mode changes.
    5860    virtual void scrollbarsModeDidChange() const = 0;
     61
     62    // Request that the cursor change.
     63    virtual void setCursor(const Cursor&) = 0;
    5964};
    6065

  • trunk/WebCore/platform/chromium/CursorChromium.cpp

    r39903 r63339  
    3535
    3636Cursor::Cursor(const Cursor& other)
    37     : m_impl(other.m_impl)
     37    : m_platformCursor(other.m_platformCursor)
    3838{
    3939}
    4040
    4141Cursor::Cursor(Image* image, const IntPoint& hotSpot)
    42     : m_impl(image, hotSpot)
     42    : m_platformCursor(image, hotSpot)
    4343{
    4444}
    … …  
    5050Cursor& Cursor::operator=(const Cursor& other)
    5151{
    52     m_impl = other.m_impl;
     52    m_platformCursor = other.m_platformCursor;
    5353    return *this;
    5454}
    5555
    5656Cursor::Cursor(PlatformCursor c)
    57     : m_impl(c)
     57    : m_platformCursor(c)
    5858{
    5959}

  • trunk/WebCore/platform/efl/CursorEfl.cpp

    r55344 r63339  
    4646Cursor::Cursor(PlatformCursor p)
    4747{
    48     m_impl = eina_stringshare_add(p);
     48    m_platformCursor = eina_stringshare_add(p);
    4949}
    5050
    5151Cursor::Cursor(const Cursor& other)
    5252{
    53     m_impl = eina_stringshare_ref(other.m_impl);
     53    m_platformCursor = eina_stringshare_ref(other.m_platformCursor);
    5454}
    5555
    5656Cursor::~Cursor()
    5757{
    58     if (m_impl) {
    59         eina_stringshare_del(m_impl);
    60         m_impl = 0;
     58    if (m_platformCursor) {
     59        eina_stringshare_del(m_platformCursor);
     60        m_platformCursor = 0;
    6161    }
    6262}
    6363
    6464Cursor::Cursor(Image* image, const IntPoint& hotspot)
    65     : m_impl(0)
     65    : m_platformCursor(0)
    6666{
    6767    notImplemented();
    … …  
    7070Cursor& Cursor::operator=(const Cursor& other)
    7171{
    72     eina_stringshare_ref(other.m_impl);
    73     eina_stringshare_del(m_impl);
    74     m_impl = other.m_impl;
     72    eina_stringshare_ref(other.m_platformCursor);
     73    eina_stringshare_del(m_platformCursor);
     74    m_platformCursor = other.m_platformCursor;
    7575    return *this;
    7676}

  • trunk/WebCore/platform/gtk/CursorGtk.cpp

    r60849 r63339  
    5858
    5959Cursor::Cursor(const Cursor& other)
    60     : m_impl(other.m_impl)
    61 {
    62     if (m_impl)
    63         gdk_cursor_ref(m_impl);
     60    : m_platformCursor(other.m_platformCursor)
     61{
     62    if (m_platformCursor)
     63        gdk_cursor_ref(m_platformCursor);
    6464}
    6565
    … …  
    6868    IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);
    6969    GdkPixbuf* pixbuf = image->getGdkPixbuf();
    70     m_impl = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, effectiveHotSpot.x(), effectiveHotSpot.y());
     70    m_platformCursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, effectiveHotSpot.x(), effectiveHotSpot.y());
    7171    g_object_unref(pixbuf);
    7272}
    … …  
    7474Cursor::~Cursor()
    7575{
    76     if (m_impl)
    77         gdk_cursor_unref(m_impl);
     76    if (m_platformCursor)
     77        gdk_cursor_unref(m_platformCursor);
    7878}
    7979
    8080Cursor& Cursor::operator=(const Cursor& other)
    8181{
    82     gdk_cursor_ref(other.m_impl);
    83     gdk_cursor_unref(m_impl);
    84     m_impl = other.m_impl;
     82    gdk_cursor_ref(other.m_platformCursor);
     83    gdk_cursor_unref(m_platformCursor);
     84    m_platformCursor = other.m_platformCursor;
    8585    return *this;
    8686}
    8787
    8888Cursor::Cursor(GdkCursor* c)
    89     : m_impl(c)
    90 {
    91     m_impl = c;
     89    : m_platformCursor(c)
     90{
     91    m_platformCursor = c;
    9292
    9393    // The GdkCursor may be NULL - the default cursor for the window.

  • trunk/WebCore/platform/haiku/CursorHaiku.cpp

    r57512 r63339  
    3535
    3636Cursor::Cursor(PlatformCursor cursor)
    37     : m_impl(cursor)
     37    : m_platformCursor(cursor)
    3838{
    3939}
    4040
    4141Cursor::Cursor(const Cursor& other)
    42     : m_impl(0)
     42    : m_platformCursor(0)
    4343{
    4444    *this = other;
    … …  
    4747Cursor::~Cursor()
    4848{
    49     delete m_impl;
     49    delete m_platformCursor;
    5050}
    5151
    5252Cursor::Cursor(Image*, const IntPoint&)
    53     : m_impl(0)
     53    : m_platformCursor(0)
    5454{
    5555    notImplemented();
    … …  
    5858Cursor& Cursor::operator=(const Cursor& other)
    5959{
    60     delete m_impl;
    61     m_impl = other.m_impl ? new BCursor(*other.m_impl) : 0;
     60    delete m_platformCursor;
     61    m_platformCursor = other.m_platformCursor ? new BCursor(*other.m_platformCursor) : 0;
    6262    return *this;
    6363}

  • trunk/WebCore/platform/mac/CursorMac.mm

    r60849 r63339  
    2929#import "BlockExceptions.h"
    3030#import "FoundationExtras.h"
    31 #import "Image.h"
    32 #import "IntPoint.h"
    3331#import <wtf/StdLibExtras.h>
    3432
    … …  
    5149        return 0;
    5250    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    53     return [[NSCursor alloc] initWithImage:img hotSpot:determineHotSpot(image, hotSpot)];
     51    return [[NSCursor alloc] initWithImage:img hotSpot:hotSpot];
    5452    END_BLOCK_OBJC_EXCEPTIONS;
    5553    return 0;
    … …  
    7775}
    7876
    79 Cursor::Cursor(Image* image, const IntPoint& hotSpot)
    80     : m_impl(HardRetainWithNSRelease(createCustomCursor(image, hotSpot)))
    81 {
     77void Cursor::ensurePlatformCursor() const
     78{
     79    if (m_platformCursor)
     80        return;
     81
     82    switch (m_type) {
     83    case Cursor::Pointer:
     84        m_platformCursor = HardRetain([NSCursor arrowCursor]);
     85        break;
     86    case Cursor::Cross:
     87        m_platformCursor = HardRetain(leakNamedCursor("crossHairCursor", 11, 11));
     88        break;
     89    case Cursor::Hand:
     90        m_platformCursor = HardRetain(leakNamedCursor("linkCursor", 6, 1));
     91        break;
     92    case Cursor::IBeam:
     93        m_platformCursor = HardRetain([NSCursor IBeamCursor]);
     94        break;
     95    case Cursor::Wait:
     96        m_platformCursor = HardRetain(leakNamedCursor("waitCursor", 7, 7));
     97        break;
     98    case Cursor::Help:
     99        m_platformCursor = HardRetain(leakNamedCursor("helpCursor", 8, 8));
     100        break;
     101    case Cursor::Move:
     102    case Cursor::MiddlePanning:
     103        m_platformCursor = HardRetain(leakNamedCursor("moveCursor", 7, 7));
     104        break;
     105    case Cursor::EastResize:
     106    case Cursor::EastPanning:
     107        m_platformCursor = HardRetain(leakNamedCursor("eastResizeCursor", 14, 7));
     108        break;
     109    case Cursor::NorthResize:
     110    case Cursor::NorthPanning:
     111        m_platformCursor = HardRetain(leakNamedCursor("northResizeCursor", 7, 1));
     112        break;
     113    case Cursor::NorthEastResize:
     114    case Cursor::NorthEastPanning:
     115        m_platformCursor = HardRetain(leakNamedCursor("northEastResizeCursor", 14, 1));
     116        break;
     117    case Cursor::NorthWestResize:
     118    case Cursor::NorthWestPanning:
     119        m_platformCursor = HardRetain(leakNamedCursor("northWestResizeCursor", 0, 0));
     120        break;
     121    case Cursor::SouthResize:
     122    case Cursor::SouthPanning:
     123        m_platformCursor = HardRetain(leakNamedCursor("southResizeCursor", 7, 14));
     124        break;
     125    case Cursor::SouthEastResize:
     126    case Cursor::SouthEastPanning:
     127        m_platformCursor = HardRetain(leakNamedCursor("southEastResizeCursor", 14, 14));
     128        break;
     129    case Cursor::SouthWestResize:
     130    case Cursor::SouthWestPanning:
     131        m_platformCursor = HardRetain(leakNamedCursor("southWestResizeCursor", 1, 14));
     132        break;
     133    case Cursor::WestResize:
     134        m_platformCursor = HardRetain(leakNamedCursor("westResizeCursor", 1, 7));
     135        break;
     136    case Cursor::NorthSouthResize:
     137        m_platformCursor = HardRetain(leakNamedCursor("northSouthResizeCursor", 7, 7));
     138        break;
     139    case Cursor::EastWestResize:
     140    case Cursor::WestPanning:
     141        m_platformCursor = HardRetain(leakNamedCursor("eastWestResizeCursor", 7, 7));
     142        break;
     143    case Cursor::NorthEastSouthWestResize:
     144        m_platformCursor = HardRetain(leakNamedCursor("northEastSouthWestResizeCursor", 7, 7));
     145        break;
     146    case Cursor::NorthWestSouthEastResize:
     147        m_platformCursor = HardRetain(leakNamedCursor("northWestSouthEastResizeCursor", 7, 7));
     148        break;
     149    case Cursor::ColumnResize:
     150        m_platformCursor = [NSCursor resizeLeftRightCursor];
     151        break;
     152    case Cursor::RowResize:
     153        m_platformCursor = [NSCursor resizeUpDownCursor];
     154        break;
     155    case Cursor::VerticalText:
     156        m_platformCursor = HardRetain(leakNamedCursor("verticalTextCursor", 7, 7));
     157        break;
     158    case Cursor::Cell:
     159        m_platformCursor = HardRetain(leakNamedCursor("cellCursor", 7, 7));
     160        break;
     161    case Cursor::ContextMenu:
     162        m_platformCursor = HardRetain(leakNamedCursor("contextMenuCursor", 3, 2));
     163        break;
     164    case Cursor::Alias:
     165        m_platformCursor = HardRetain(leakNamedCursor("aliasCursor", 11, 3));
     166        break;
     167    case Cursor::Progress:
     168        m_platformCursor = HardRetain(leakNamedCursor("progressCursor", 3, 2));
     169        break;
     170    case Cursor::NoDrop:
     171        m_platformCursor = HardRetain(leakNamedCursor("noDropCursor", 3, 1));
     172        break;
     173    case Cursor::Copy:
     174        m_platformCursor = HardRetain(leakNamedCursor("copyCursor", 3, 2));
     175        break;
     176    case Cursor::None:
     177        m_platformCursor = HardRetain(leakNamedCursor("noneCursor", 7, 7));
     178        break;
     179    case Cursor::NotAllowed:
     180        m_platformCursor = HardRetain(leakNamedCursor("notAllowedCursor", 11, 11));
     181        break;
     182    case Cursor::ZoomIn:
     183        m_platformCursor = HardRetain(leakNamedCursor("zoomInCursor", 7, 7));
     184        break;
     185    case Cursor::ZoomOut:
     186        m_platformCursor = HardRetain(leakNamedCursor("zoomOutCursor", 7, 7));
     187        break;
     188    case Cursor::Grab:
     189        m_platformCursor = HardRetain([NSCursor openHandCursor]);
     190        break;
     191    case Cursor::Grabbing:
     192        m_platformCursor = HardRetain([NSCursor closedHandCursor]);
     193        break;
     194    case Cursor::Custom:
     195        m_platformCursor = HardRetainWithNSRelease(createCustomCursor(m_image.get(), m_hotSpot));
     196        break;
     197    }
    82198}
    83199
    84200Cursor::Cursor(const Cursor& other)
    85     : m_impl(HardRetain(other.m_impl))
    86 {
     201    : m_type(other.m_type)
     202    , m_image(other.m_image)
     203    , m_hotSpot(other.m_hotSpot)
     204    , m_platformCursor(HardRetain(other.m_platformCursor))
     205{
     206}
     207
     208Cursor& Cursor::operator=(const Cursor& other)
     209{
     210    m_type = other.m_type;
     211    m_image = other.m_image;
     212    m_hotSpot = other.m_hotSpot;
     213
     214    HardRetain(other.m_platformCursor);
     215    HardRelease(m_platformCursor);
     216    m_platformCursor = other.m_platformCursor;
     217    return *this;
    87218}
    88219
    89220Cursor::~Cursor()
    90221{
    91     HardRelease(m_impl);
    92 }
    93 
    94 Cursor& Cursor::operator=(const Cursor& other)
    95 {
    96     HardRetain(other.m_impl);
    97     HardRelease(m_impl);
    98     m_impl = other.m_impl;
    99     return *this;
    100 }
    101 
    102 Cursor::Cursor(NSCursor* c)
    103     : m_impl(HardRetain(c))
    104 {
    105 }
    106 
    107 const Cursor& pointerCursor()
    108 {
    109     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor arrowCursor]));
    110     return c;
    111 }
    112 
    113 const Cursor& crossCursor()
    114 {
    115     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("crossHairCursor", 11, 11)));
    116     return c;
    117 }
    118 
    119 const Cursor& handCursor()
    120 {
    121     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("linkCursor", 6, 1)));
    122     return c;
    123 }
    124 
    125 const Cursor& moveCursor()
    126 {
    127     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("moveCursor", 7, 7)));
    128     return c;
    129 }
    130 
    131 const Cursor& verticalTextCursor()
    132 {
    133     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("verticalTextCursor", 7, 7)));
    134     return c;
    135 }
    136 
    137 const Cursor& cellCursor()
    138 {
    139     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("cellCursor", 7, 7)));
    140     return c;
    141 }
    142 
    143 const Cursor& contextMenuCursor()
    144 {
    145     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("contextMenuCursor", 3, 2)));
    146     return c;
    147 }
    148 
    149 const Cursor& aliasCursor()
    150 {
    151     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("aliasCursor", 11, 3)));
    152     return c;
    153 }
    154 
    155 const Cursor& zoomInCursor()
    156 {
    157     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("zoomInCursor", 7, 7)));
    158     return c;
    159 }
    160 
    161 const Cursor& zoomOutCursor()
    162 {
    163     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("zoomOutCursor", 7, 7)));
    164     return c;
    165 }
    166 
    167 const Cursor& copyCursor()
    168 {
    169     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("copyCursor", 3, 2)));
    170     return c;
    171 }
    172 
    173 const Cursor& noneCursor()
    174 {
    175     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("noneCursor", 7, 7)));
    176     return c;
    177 }
    178 
    179 const Cursor& progressCursor()
    180 {
    181     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("progressCursor", 3, 2)));
    182     return c;
    183 }
    184 
    185 const Cursor& noDropCursor()
    186 {
    187     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("noDropCursor", 3, 1)));
    188     return c;
    189 }
    190 
    191 const Cursor& notAllowedCursor()
    192 {
    193     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("notAllowedCursor", 11, 11)));
    194     return c;
    195 }
    196 
    197 const Cursor& iBeamCursor()
    198 {
    199     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor IBeamCursor]));
    200     return c;
    201 }
    202 
    203 const Cursor& waitCursor()
    204 {
    205     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("waitCursor", 7, 7)));
    206     return c;
    207 }
    208 
    209 const Cursor& helpCursor()
    210 {
    211     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("helpCursor", 8, 8)));
    212     return c;
    213 }
    214 
    215 const Cursor& eastResizeCursor()
    216 {
    217     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("eastResizeCursor", 14, 7)));
    218     return c;
    219 }
    220 
    221 const Cursor& northResizeCursor()
    222 {
    223     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northResizeCursor", 7, 1)));
    224     return c;
    225 }
    226 
    227 const Cursor& northEastResizeCursor()
    228 {
    229     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northEastResizeCursor", 14, 1)));
    230     return c;
    231 }
    232 
    233 const Cursor& northWestResizeCursor()
    234 {
    235     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northWestResizeCursor", 0, 0)));
    236     return c;
    237 }
    238 
    239 const Cursor& southResizeCursor()
    240 {
    241     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("southResizeCursor", 7, 14)));
    242     return c;
    243 }
    244 
    245 const Cursor& southEastResizeCursor()
    246 {
    247     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("southEastResizeCursor", 14, 14)));
    248     return c;
    249 }
    250 
    251 const Cursor& southWestResizeCursor()
    252 {
    253     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("southWestResizeCursor", 1, 14)));
    254     return c;
    255 }
    256 
    257 const Cursor& westResizeCursor()
    258 {
    259     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("westResizeCursor", 1, 7)));
    260     return c;
    261 }
    262 
    263 const Cursor& northSouthResizeCursor()
    264 {
    265     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northSouthResizeCursor", 7, 7)));
    266     return c;
    267 }
    268 
    269 const Cursor& eastWestResizeCursor()
    270 {
    271     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("eastWestResizeCursor", 7, 7)));
    272     return c;
    273 }
    274 
    275 const Cursor& northEastSouthWestResizeCursor()
    276 {
    277     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northEastSouthWestResizeCursor", 7, 7)));
    278     return c;
    279 }
    280 
    281 const Cursor& northWestSouthEastResizeCursor()
    282 {
    283     DEFINE_STATIC_LOCAL(Cursor, c, (leakNamedCursor("northWestSouthEastResizeCursor", 7, 7)));
    284     return c;
    285 }
    286 
    287 const Cursor& columnResizeCursor()
    288 {
    289     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor resizeLeftRightCursor]));
    290     return c;
    291 }
    292 
    293 const Cursor& rowResizeCursor()
    294 {
    295     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor resizeUpDownCursor]));
    296     return c;
    297 }
    298 
    299 const Cursor& middlePanningCursor()
    300 {
    301     return moveCursor();
    302 }
    303    
    304 const Cursor& eastPanningCursor()
    305 {
    306     return eastResizeCursor();
    307 }
    308    
    309 const Cursor& northPanningCursor()
    310 {
    311     return northResizeCursor();
    312 }
    313    
    314 const Cursor& northEastPanningCursor()
    315 {
    316     return northEastResizeCursor();
    317 }
    318    
    319 const Cursor& northWestPanningCursor()
    320 {
    321     return northWestResizeCursor();
    322 }
    323    
    324 const Cursor& southPanningCursor()
    325 {
    326     return southResizeCursor();
    327 }
    328    
    329 const Cursor& southEastPanningCursor()
    330 {
    331     return southEastResizeCursor();
    332 }
    333    
    334 const Cursor& southWestPanningCursor()
    335 {
    336     return southWestResizeCursor();
    337 }
    338    
    339 const Cursor& westPanningCursor()
    340 {
    341     return westResizeCursor();
    342 }
    343 
    344 const Cursor& grabCursor()
    345 {
    346     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor openHandCursor]));
    347     return c;
    348 }
    349 
    350 const Cursor& grabbingCursor()
    351 {
    352     DEFINE_STATIC_LOCAL(Cursor, c, ([NSCursor closedHandCursor]));
    353     return c;
    354 }
    355 
    356 }
     222    HardRelease(m_platformCursor);
     223}
     224
     225} // namespace WebCore

  • trunk/WebCore/platform/mac/WidgetMac.mm

    r58821 r63339  
    124124}
    125125
    126  void Widget::setCursor(const Cursor& cursor)
    127  {
    128     if ([NSCursor currentCursor] == cursor.impl())
    129         return;
    130     [cursor.impl() set];
     126void Widget::setCursor(const Cursor& cursor)
     127{
     128    ScrollView* view = root();
     129    if (!view)
     130        return;
     131    view->hostWindow()->setCursor(cursor);
    131132}
    132133

  • trunk/WebCore/platform/qt/CursorQt.cpp

    r60849 r63339  
    4545
    4646Cursor::Cursor(PlatformCursor p)
    47     : m_impl(p)
     47    : m_platformCursor(p)
    4848{
    4949}
    5050
    5151Cursor::Cursor(const Cursor& other)
    52     : m_impl(other.m_impl)
     52    : m_platformCursor(other.m_platformCursor)
    5353{
    5454}
    … …  
    6262#ifndef QT_NO_CURSOR
    6363    IntPoint effectiveHotSpot = determineHotSpot(image, hotSpot);
    64     m_impl = QCursor(*(image->nativeImageForCurrentFrame()), effectiveHotSpot.x(), effectiveHotSpot.y());
     64    m_platformCursor = QCursor(*(image->nativeImageForCurrentFrame()), effectiveHotSpot.x(), effectiveHotSpot.y());
    6565#endif
    6666}
    … …  
    6868Cursor& Cursor::operator=(const Cursor& other)
    6969{
    70     m_impl = other.m_impl;
     70    m_platformCursor = other.m_platformCursor;
    7171    return *this;
    7272}

  • trunk/WebCore/platform/win/CursorWin.cpp

    r60849 r63339  
    4040namespace WebCore {
    4141
    42 Cursor::Cursor(const Cursor& other)
    43     : m_impl(other.m_impl)
    44 {
    45 }
    46 
    4742static inline bool supportsAlphaCursors()
    4843{
    … …  
    5348}
    5449
    55 Cursor::Cursor(Image* img, const IntPoint& hotSpot)
    56 {
     50static PassRefPtr<SharedCursor> createSharedCursor(Image* img, const IntPoint& hotSpot)
     51{
     52    RefPtr<SharedCursor> impl;
     53
    5754    IntPoint effectiveHotSpot = determineHotSpot(img, hotSpot);
    5855    static bool doAlpha = supportsAlphaCursors();
    … …  
    8178        ii.hbmColor = hCursor.get();
    8279
    83         m_impl = SharedCursor::create(CreateIconIndirect(&ii));
     80        impl = SharedCursor::create(CreateIconIndirect(&ii));
    8481    } else {
    8582        // Platform doesn't support alpha blended cursors, so we need
    … …  
    116113        icon.hbmMask = andMask.get();
    117114        icon.hbmColor = xorMask.get();
    118         m_impl = SharedCursor::create(CreateIconIndirect(&icon));
     115        impl = SharedCursor::create(CreateIconIndirect(&icon));
    119116
    120117        DeleteDC(xorMaskDC);
    … …  
    123120    DeleteDC(workingDC);
    124121    ReleaseDC(0, dc);
     122
     123    return impl.release();
     124}
     125
     126static PassRefPtr<SharedCursor> loadSharedCursor(HINSTANCE hInstance, LPCTSTR lpCursorName)
     127{
     128    return SharedCursor::create(::LoadCursor(hInstance, lpCursorName));
     129}
     130
     131static PassRefPtr<SharedCursor> loadCursorByName(char* name, int x, int y)
     132{
     133    IntPoint hotSpot(x, y);
     134    RefPtr<Image> cursorImage(Image::loadPlatformResource(name));
     135    if (cursorImage && !cursorImage->isNull())
     136        return createSharedCursor(cursorImage.get(), hotSpot);
     137    return loadSharedCursor(0, IDC_ARROW);
     138}
     139
     140void Cursor::ensurePlatformCursor() const
     141{
     142    if (m_platformCursor)
     143        return;
     144
     145    switch (m_type) {
     146    case Cursor::Pointer:
     147    case Cursor::Cell:
     148    case Cursor::ContextMenu:
     149    case Cursor::Alias:
     150    case Cursor::Copy:
     151    case Cursor::None:
     152    case Cursor::Grab:
     153    case Cursor::Grabbing:
     154        m_platformCursor = loadSharedCursor(0, IDC_ARROW);
     155        break;
     156    case Cursor::Cross:
     157        m_platformCursor = loadSharedCursor(0, IDC_CROSS);
     158        break;
     159    case Cursor::Hand:
     160        m_platformCursor = loadSharedCursor(0, IDC_HAND);
     161        break;
     162    case Cursor::IBeam:
     163        m_platformCursor = loadSharedCursor(0, IDC_IBEAM);
     164        break;
     165    case Cursor::Wait:
     166        m_platformCursor = loadSharedCursor(0, IDC_WAIT);
     167        break;
     168    case Cursor::Help:
     169        m_platformCursor = loadSharedCursor(0, IDC_HELP);
     170        break;
     171    case Cursor::Move:
     172        m_platformCursor = loadSharedCursor(0, IDC_SIZEALL);
     173        break;
     174    case Cursor::MiddlePanning:
     175        m_platformCursor = loadCursorByName("panIcon", 8, 8);
     176        break;
     177    case Cursor::EastResize:
     178        m_platformCursor = loadSharedCursor(0, IDC_SIZEWE);
     179        break;
     180    case Cursor::EastPanning:
     181        m_platformCursor = loadCursorByName("panEastCursor", 7, 7);
     182        break;
     183    case Cursor::NorthResize:
     184        m_platformCursor = loadSharedCursor(0, IDC_SIZENS);
     185        break;
     186    case Cursor::NorthPanning:
     187        m_platformCursor = loadCursorByName("panNorthCursor", 7, 7);
     188        break;
     189    case Cursor::NorthEastResize:
     190        m_platformCursor = loadSharedCursor(0, IDC_SIZENESW);
     191        break;
     192    case Cursor::NorthEastPanning:
     193        m_platformCursor = loadCursorByName("panNorthEastCursor", 7, 7);
     194        break;
     195    case Cursor::NorthWestResize:
     196        m_platformCursor = loadSharedCursor(0, IDC_SIZENWSE);
     197        break;
     198    case Cursor::NorthWestPanning:
     199        m_platformCursor = loadCursorByName("panNorthWestCursor", 7, 7);
     200        break;
     201    case Cursor::SouthResize:
     202        m_platformCursor = loadSharedCursor(0, IDC_SIZENS);
     203        break;
     204    case Cursor::SouthPanning:
     205        m_platformCursor = loadCursorByName("panSouthCursor", 7, 7);
     206        break;
     207    case Cursor::SouthEastResize:
     208        m_platformCursor = loadSharedCursor(0, IDC_SIZENWSE);
     209        break;
     210    case Cursor::SouthEastPanning:
     211        m_platformCursor = loadCursorByName("panSouthEastCursor", 7, 7);
     212        break;
     213    case Cursor::SouthWestResize:
     214        m_platformCursor = loadSharedCursor(0, IDC_SIZENESW);
     215        break;
     216    case Cursor::SouthWestPanning:
     217        m_platformCursor = loadCursorByName("panSouthWestCursor", 7, 7);
     218        break;
     219    case Cursor::WestResize:
     220        m_platformCursor = loadSharedCursor(0, IDC_SIZEWE);
     221        break;
     222    case Cursor::NorthSouthResize:
     223        m_platformCursor = loadSharedCursor(0, IDC_SIZENS);
     224        break;
     225    case Cursor::EastWestResize:
     226        m_platformCursor = loadSharedCursor(0, IDC_SIZEWE);
     227        break;
     228    case Cursor::WestPanning:
     229        m_platformCursor = loadCursorByName("panWestCursor", 7, 7);
     230        break;
     231    case Cursor::NorthEastSouthWestResize:
     232        m_platformCursor = loadSharedCursor(0, IDC_SIZENESW);
     233        break;
     234    case Cursor::NorthWestSouthEastResize:
     235        m_platformCursor = loadSharedCursor(0, IDC_SIZENWSE);
     236        break;
     237    case Cursor::ColumnResize:
     238        // FIXME: Windows does not have a standard column resize cursor <rdar://problem/5018591>
     239        m_platformCursor = loadSharedCursor(0, IDC_SIZEWE);
     240        break;
     241    case Cursor::RowResize:
     242        // FIXME: Windows does not have a standard row resize cursor <rdar://problem/5018591>
     243        m_platformCursor = loadSharedCursor(0, IDC_SIZENS);
     244        break;
     245    case Cursor::VerticalText:
     246        m_platformCursor = loadCursorByName("verticalTextCursor", 7, 7);
     247        break;
     248    case Cursor::Progress:
     249        m_platformCursor = loadSharedCursor(0, IDC_APPSTARTING);
     250        break;
     251    case Cursor::NoDrop:
     252        break;
     253    case Cursor::NotAllowed:
     254        m_platformCursor = loadSharedCursor(0, IDC_NO);
     255        break;
     256    case Cursor::ZoomIn:
     257        m_platformCursor = loadCursorByName("zoomInCursor", 7, 7);
     258        break;
     259    case Cursor::ZoomOut:
     260        m_platformCursor = loadCursorByName("zoomOutCursor", 7, 7);
     261        break;
     262    case Cursor::Custom:
     263        m_platformCursor = createSharedCursor(m_image.get(), m_hotSpot);
     264        break;
     265    }
     266}
     267
     268SharedCursor::~SharedCursor()
     269{
     270    DestroyIcon(m_nativeCursor);
     271}
     272
     273Cursor::Cursor(const Cursor& other)
     274    : m_type(other.m_type)
     275    , m_image(other.m_image)
     276    , m_hotSpot(other.m_hotSpot)
     277    , m_platformCursor(other.m_platformCursor)
     278{
     279}
     280
     281Cursor& Cursor::operator=(const Cursor& other)
     282{
     283    m_type = other.m_type;
     284    m_image = other.m_image;
     285    m_hotSpot = other.m_hotSpot;
     286    m_platformCursor = other.m_platformCursor;
     287    return *this;
    125288}
    126289
    … …  
    129292}
    130293
    131 Cursor& Cursor::operator=(const Cursor& other)
    132 {
    133     m_impl = other.m_impl;
    134     return *this;
    135 }
    136 
    137 Cursor::Cursor(PlatformCursor c)
    138     : m_impl(c)
    139 {
    140 }
    141 
    142 static Cursor loadCursorByName(char* name, int x, int y)
    143 {
    144     IntPoint hotSpot(x, y);
    145     Cursor c;
    146     RefPtr<Image> cursorImage(Image::loadPlatformResource(name));
    147     if (cursorImage && !cursorImage->isNull())
    148         c = Cursor(cursorImage.get(), hotSpot);
    149     else
    150         c = pointerCursor();
    151     return c;
    152 }
    153 
    154 static PassRefPtr<SharedCursor> loadSharedCursor(HINSTANCE hInstance, LPCTSTR lpCursorName)
    155 {
    156     return SharedCursor::create(LoadCursor(hInstance, lpCursorName));
    157 }
    158 
    159 const Cursor& pointerCursor()
    160 {
    161     static Cursor c = loadSharedCursor(0, IDC_ARROW);
    162     return c;
    163 }
    164 
    165 const Cursor& crossCursor()
    166 {
    167     static Cursor c = loadSharedCursor(0, IDC_CROSS);
    168     return c;
    169 }
    170 
    171 const Cursor& handCursor()
    172 {
    173     static Cursor c = loadSharedCursor(0, IDC_HAND);
    174     return c;
    175 }
    176 
    177 const Cursor& iBeamCursor()
    178 {
    179     static Cursor c = loadSharedCursor(0, IDC_IBEAM);
    180     return c;
    181 }
    182 
    183 const Cursor& waitCursor()
    184 {
    185     static Cursor c = loadSharedCursor(0, IDC_WAIT);
    186     return c;
    187 }
    188 
    189 const Cursor& helpCursor()
    190 {
    191     static Cursor c = loadSharedCursor(0, IDC_HELP);
    192     return c;
    193 }
    194 
    195 const Cursor& eastResizeCursor()
    196 {
    197     static Cursor c = loadSharedCursor(0, IDC_SIZEWE);
    198     return c;
    199 }
    200 
    201 const Cursor& northResizeCursor()
    202 {
    203     static Cursor c = loadSharedCursor(0, IDC_SIZENS);
    204     return c;
    205 }
    206 
    207 const Cursor& northEastResizeCursor()
    208 {
    209     static Cursor c = loadSharedCursor(0, IDC_SIZENESW);
    210     return c;
    211 }
    212 
    213 const Cursor& northWestResizeCursor()
    214 {
    215     static Cursor c = loadSharedCursor(0, IDC_SIZENWSE);
    216     return c;
    217 }
    218 
    219 const Cursor& southResizeCursor()
    220 {
    221     static Cursor c = loadSharedCursor(0, IDC_SIZENS);
    222     return c;
    223 }
    224 
    225 const Cursor& southEastResizeCursor()
    226 {
    227     static Cursor c = loadSharedCursor(0, IDC_SIZENWSE);
    228     return c;
    229 }
    230 
    231 const Cursor& southWestResizeCursor()
    232 {
    233     static Cursor c = loadSharedCursor(0, IDC_SIZENESW);
    234     return c;
    235 }
    236 
    237 const Cursor& westResizeCursor()
    238 {
    239     static Cursor c = loadSharedCursor(0, IDC_SIZEWE);
    240     return c;
    241 }
    242 
    243 const Cursor& northSouthResizeCursor()
    244 {
    245     static Cursor c = loadSharedCursor(0, IDC_SIZENS);
    246     return c;
    247 }
    248 
    249 const Cursor& eastWestResizeCursor()
    250 {
    251     static Cursor c = loadSharedCursor(0, IDC_SIZEWE);
    252     return c;
    253 }
    254 
    255 const Cursor& northEastSouthWestResizeCursor()
    256 {
    257     static Cursor c = loadSharedCursor(0, IDC_SIZENESW);
    258     return c;
    259 }
    260 
    261 const Cursor& northWestSouthEastResizeCursor()
    262 {
    263     static Cursor c = loadSharedCursor(0, IDC_SIZENWSE);
    264     return c;
    265 }
    266 
    267 const Cursor& columnResizeCursor()
    268 {
    269     // FIXME: Windows does not have a standard column resize cursor <rdar://problem/5018591>
    270     static Cursor c = loadSharedCursor(0, IDC_SIZEWE);
    271     return c;
    272 }
    273 
    274 const Cursor& rowResizeCursor()
    275 {
    276     // FIXME: Windows does not have a standard row resize cursor <rdar://problem/5018591>
    277     static Cursor c = loadSharedCursor(0, IDC_SIZENS);
    278     return c;
    279 }
    280 
    281 const Cursor& middlePanningCursor()
    282 {
    283     static const Cursor c = loadCursorByName("panIcon", 8, 8);
    284     return c;
    285 }
    286 
    287 const Cursor& eastPanningCursor()
    288 {
    289     static const Cursor c = loadCursorByName("panEastCursor", 7, 7);
    290     return c;
    291 }
    292 
    293 const Cursor& northPanningCursor()
    294 {
    295     static const Cursor c = loadCursorByName("panNorthCursor", 7, 7);
    296     return c;
    297 }
    298 
    299 const Cursor& northEastPanningCursor()
    300 {
    301     static const Cursor c = loadCursorByName("panNorthEastCursor", 7, 7);
    302     return c;
    303 }
    304 
    305 const Cursor& northWestPanningCursor()
    306 {
    307     static const Cursor c = loadCursorByName("panNorthWestCursor", 7, 7);
    308     return c;
    309 }
    310 
    311 const Cursor& southPanningCursor()
    312 {
    313     static const Cursor c = loadCursorByName("panSouthCursor", 7, 7);
    314     return c;
    315 }
    316 
    317 const Cursor& southEastPanningCursor()
    318 {
    319     static const Cursor c = loadCursorByName("panSouthEastCursor", 7, 7);
    320     return c;
    321 }
    322 
    323 const Cursor& southWestPanningCursor()
    324 {
    325     static const Cursor c = loadCursorByName("panSouthWestCursor", 7, 7);
    326     return c;
    327 }
    328 
    329 const Cursor& westPanningCursor()
    330 {
    331     static const Cursor c = loadCursorByName("panWestCursor", 7, 7);
    332     return c;
    333 }
    334 
    335 const Cursor& moveCursor()
    336 {
    337     static Cursor c = loadSharedCursor(0, IDC_SIZEALL);
    338     return c;
    339 }
    340 
    341 const Cursor& verticalTextCursor()
    342 {
    343     static const Cursor c = loadCursorByName("verticalTextCursor", 7, 7);
    344     return c;
    345 }
    346 
    347 const Cursor& cellCursor()
    348 {
    349     return pointerCursor();
    350 }
    351 
    352 const Cursor& contextMenuCursor()
    353 {
    354     return pointerCursor();
    355 }
    356 
    357 const Cursor& aliasCursor()
    358 {
    359     return pointerCursor();
    360 }
    361 
    362 const Cursor& progressCursor()
    363 {
    364     static Cursor c = loadSharedCursor(0, IDC_APPSTARTING);
    365     return c;
    366 }
    367 
    368 const Cursor& noDropCursor()
    369 {
    370     static Cursor c = loadSharedCursor(0, IDC_NO);
    371     return c;
    372 }
    373 
    374 const Cursor& copyCursor()
    375 {
    376     return pointerCursor();
    377 }
    378 
    379 const Cursor& noneCursor()
    380 {
    381     return pointerCursor();
    382 }
    383 
    384 const Cursor& notAllowedCursor()
    385 {
    386     static Cursor c = loadSharedCursor(0, IDC_NO);
    387     return c;
    388 }
    389 
    390 const Cursor& zoomInCursor()
    391 {
    392     static const Cursor c = loadCursorByName("zoomInCursor", 7, 7);
    393     return c;
    394 }
    395 
    396 const Cursor& zoomOutCursor()
    397 {
    398     static const Cursor c = loadCursorByName("zoomOutCursor", 7, 7);
    399     return c;
    400 }
    401 
    402 const Cursor& grabCursor()
    403 {
    404     return pointerCursor();
    405 }
    406 
    407 const Cursor& grabbingCursor()
    408 {
    409     return pointerCursor();
    410 }
    411 
    412 SharedCursor::~SharedCursor()
    413 {
    414     DestroyIcon(m_nativeCursor);
    415 }
    416 
    417 }
     294} // namespace WebCore

  • trunk/WebCore/platform/win/WidgetWin.cpp

    r58821 r63339  
    6060}
    6161
    62 HCURSOR lastSetCursor = 0;
    6362bool ignoreNextSetCursor = false;
    6463
    … …  
    7271    }
    7372
    74     if (!cursor.impl()->nativeCursor())
     73    ScrollView* view = root();
     74    if (!view)
    7575        return;
    76 
    77     lastSetCursor = cursor.impl()->nativeCursor();
    78 
    79     ScrollView* view = root();
    80     if (!view || !view->isFrameView()) {
    81         SetCursor(lastSetCursor);
    82         return;
    83     }
    84 
    85     Frame* frame = static_cast<FrameView*>(view)->frame();
    86     if (!frame) {
    87         SetCursor(lastSetCursor);
    88         return;
    89     }
    90 
    91     Page* page = frame->page();
    92     if (!page) {
    93         SetCursor(lastSetCursor);
    94         return;
    95     }
    96 
    97     page->chrome()->setCursor(lastSetCursor);
     76    view->hostWindow()->setCursor(cursor);
    9877}
    9978

  • trunk/WebCore/platform/wince/CursorWince.cpp

    r47135 r63339  
    3939
    4040Cursor::Cursor(const Cursor& other)
    41 : m_impl(other.m_impl)
     41: m_platformCursor(other.m_platformCursor)
    4242{
    4343}
    4444
    4545Cursor::Cursor(Image* img, const IntPoint& hotspot)
    46 : m_impl(CursorNone)
     46: m_platformCursor(CursorNone)
    4747{
    4848}
    … …  
    5454Cursor& Cursor::operator=(const Cursor& other)
    5555{
    56     m_impl = other.m_impl;
     56    m_platformCursor = other.m_platformCursor;
    5757    return *this;
    5858}
    5959
    6060Cursor::Cursor(PlatformCursor c)
    61 : m_impl(c)
     61: m_platformCursor(c)
    6262{
    6363}

  • trunk/WebCore/platform/wx/CursorWx.cpp

    r48213 r63339  
    3535
    3636Cursor::Cursor(const Cursor& other)
    37     : m_impl(other.m_impl)
     37    : m_platformCursor(other.m_platformCursor)
    3838{
    3939}
    … …  
    4141Cursor::Cursor(Image* image, const IntPoint&)
    4242{
    43     m_impl = 0;
     43    m_platformCursor = 0;
    4444    // FIXME: figure out why the below code causes a crash 
    45     //m_impl = new wxCursor( image->getWxBitmap()->ConvertToImage() );
     45    //m_platformCursor = new wxCursor( image->getWxBitmap()->ConvertToImage() );
    4646}
    4747
    … …  
    5252Cursor& Cursor::operator=(const Cursor& other)
    5353{
    54     m_impl = other.m_impl;
     54    m_platformCursor = other.m_platformCursor;
    5555    return *this;
    5656}
    5757
    5858Cursor::Cursor(wxCursor* c)
    59     : m_impl(c)
     59    : m_platformCursor(c)
    6060{
    6161}

  • trunk/WebCore/plugins/win/PluginViewWin.cpp

    r59904 r63339  
    3131#include "BitmapImage.h"
    3232#include "Bridge.h"
     33#include "Chrome.h"
     34#include "ChromeClient.h"
    3335#include "Document.h"
    3436#include "DocumentLoader.h"
    … …  
    657659
    658660#if !OS(WINCE)
    659 extern HCURSOR lastSetCursor;
    660661extern bool ignoreNextSetCursor;
    661662#endif
    … …  
    728729    // and since we don't want that we set ignoreNextSetCursor to true here to prevent that.
    729730    ignoreNextSetCursor = true;
    730     lastSetCursor = ::GetCursor();
     731    if (Page* page = m_parentFrame->page())
     732        page->chrome()->client()->setLastSetCursorToCurrentCursor();   
    731733#endif
    732734}

  • trunk/WebKit/ChangeLog

    r63290 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * efl/WebCoreSupport/ChromeClientEfl.cpp:
     9        (WebCore::ChromeClientEfl::setCursor):
     10        * efl/WebCoreSupport/ChromeClientEfl.h:
     11        Change prototype to match new one.
     12
    1132010-07-14  Lucas De Marchi  <lucas.demarchi@profusion.mobi>
    214

  • trunk/WebKit/chromium/ChangeLog

    r63332 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * src/ChromeClientImpl.h:
     9        (WebKit::ChromeClientImpl::setCursor):
     10        Change prototype to match new one.
     11
     12        * src/WebPopupMenuImpl.cpp:
     13        (WebKit::WebPopupMenuImpl::setCursor):
     14        * src/WebPopupMenuImpl.h:
     15        Add empty setCursor function to satisfy the HostWindow interface.
     16
    1172010-07-13  Alexey Proskuryakov  <ap@apple.com>
    218

  • trunk/WebKit/chromium/src/ChromeClientImpl.h

    r60934 r63339  
    127127    virtual void runOpenPanel(WebCore::Frame*, PassRefPtr<WebCore::FileChooser>);
    128128    virtual void chooseIconForFiles(const Vector<WebCore::String>&, WebCore::FileChooser*);
    129     virtual bool setCursor(WebCore::PlatformCursorHandle) { return false; }
     129    virtual void setCursor(const WebCore::Cursor&) { }
    130130    virtual void formStateDidChange(const WebCore::Node*);
    131131    virtual PassOwnPtr<WebCore::HTMLParserQuirks> createHTMLParserQuirks() { return 0; }

  • trunk/WebKit/chromium/src/WebPopupMenuImpl.cpp

    r62791 r63339  
    319319}
    320320
     321void WebPopupMenuImpl::setCursor(const Cursor&)
     322{
     323}
     324
    321325//-----------------------------------------------------------------------------
    322326// WebCore::FramelessScrollViewClient

  • trunk/WebKit/chromium/src/WebPopupMenuImpl.h

    r62039 r63339  
    111111    virtual void scrollRectIntoView(const WebCore::IntRect&, const WebCore::ScrollView*) const;
    112112    virtual void scrollbarsModeDidChange() const;
     113    virtual void setCursor(const WebCore::Cursor&);
    113114
    114115    // WebCore::FramelessScrollViewClient methods:

  • trunk/WebKit/efl/WebCoreSupport/ChromeClientEfl.cpp

    r62666 r63339  
    438438}
    439439
    440 bool ChromeClientEfl::setCursor(PlatformCursorHandle)
    441 {
    442     notImplemented();
    443     return false;
     440void ChromeClientEfl::setCursor(const Cursor&)
     441{
     442    notImplemented();
    444443}
    445444

  • trunk/WebKit/efl/WebCoreSupport/ChromeClientEfl.h

    r62666 r63339  
    120120    virtual PassOwnPtr<HTMLParserQuirks> createHTMLParserQuirks() { return 0; }
    121121
    122     virtual bool setCursor(PlatformCursorHandle);
     122    virtual void setCursor(const Cursor&);
    123123
    124124    virtual void scrollRectIntoView(const IntRect&, const ScrollView*) const {}

  • trunk/WebKit/gtk/ChangeLog

    r63128 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebCoreSupport/ChromeClientGtk.cpp:
     9        (WebKit::ChromeClient::setCursor):
     10        * WebCoreSupport/ChromeClientGtk.h:
     11        Change prototype to match new one.
     12
    1132010-07-12  Martin Robinson  <mrobinson@igalia.com>
    214

  • trunk/WebKit/gtk/WebCoreSupport/ChromeClientGtk.cpp

    r62329 r63339  
    592592}
    593593
    594 bool ChromeClient::setCursor(PlatformCursorHandle)
     594void ChromeClient::setCursor(const Cursor&)
    595595{
    596596    notImplemented();
    597     return false;
    598597}
    599598

  • trunk/WebKit/gtk/WebCoreSupport/ChromeClientGtk.h

    r57903 r63339  
    117117        virtual PassOwnPtr<WebCore::HTMLParserQuirks> createHTMLParserQuirks() { return 0; }
    118118
    119         virtual bool setCursor(WebCore::PlatformCursorHandle);
     119        virtual void setCursor(const WebCore::Cursor&);
    120120
    121121        virtual void scrollRectIntoView(const WebCore::IntRect&, const WebCore::ScrollView*) const {}

  • trunk/WebKit/haiku/ChangeLog

    r61113 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebCoreSupport/ChromeClientHaiku.cpp:
     9        (WebCore::ChromeClientHaiku::setCursor):
     10        * WebCoreSupport/ChromeClientHaiku.h:
     11        Change prototype to match new one.
     12
    1132010-06-14  Ilya Tikhonovsky  <loislo@chromium.org>
    214

  • trunk/WebKit/haiku/WebCoreSupport/ChromeClientHaiku.cpp

    r57903 r63339  
    363363}
    364364
    365 bool ChromeClientHaiku::setCursor(PlatformCursorHandle)
    366 {
    367     notImplemented();
    368     return false;
     365void ChromeClientHaiku::setCursor(const Cursor&)
     366{
     367    notImplemented();
    369368}
    370369

  • trunk/WebKit/haiku/WebCoreSupport/ChromeClientHaiku.h

    r57903 r63339  
    141141        void chooseIconForFiles(const Vector<String>&, FileChooser*);
    142142
    143         bool setCursor(PlatformCursorHandle);
     143        void setCursor(const Cursor&);
    144144
    145145        // Notification that the given form element has changed. This function

  • trunk/WebKit/mac/ChangeLog

    r63271 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebCoreSupport/WebChromeClient.h:
     9        * WebCoreSupport/WebChromeClient.mm:
     10        (WebChromeClient::setCursor):
     11        * WebView/WebView.mm:
     12        Implement cursor changing at the WebKit level for the sake of WebKit2.
     13        This functionality is being moved from WidgetMac.mm.
     14        (+[WebView _pointingHandCursor]):
     15        Update to use platformCursor() instead of impl().
     16
    1172010-07-13  Simon Fraser  <simon.fraser@apple.com>
    218

  • trunk/WebKit/mac/WebCoreSupport/WebChromeClient.h

    r62875 r63339  
    128128    virtual void chooseIconForFiles(const Vector<WebCore::String>&, WebCore::FileChooser*);
    129129
    130     virtual bool setCursor(WebCore::PlatformCursorHandle) { return false; }
     130    virtual void setCursor(const WebCore::Cursor&);
    131131
    132132    virtual WebCore::FloatRect customHighlightRect(WebCore::Node*, const WebCore::AtomicString& type,

  • trunk/WebKit/mac/WebCoreSupport/WebChromeClient.mm

    r62875 r63339  
    4949#import <WebCore/BlockExceptions.h>
    5050#import <WebCore/Console.h>
     51#import <WebCore/Cursor.h>
    5152#import <WebCore/Element.h>
    5253#import <WebCore/FileChooser.h>
    … …  
    660661}
    661662
     663void WebChromeClient::setCursor(const WebCore::Cursor& cursor)
     664{
     665    NSCursor *platformCursor = cursor.platformCursor();
     666    if ([NSCursor currentCursor] == platformCursor)
     667        return;
     668    [platformCursor set];
     669}
     670
    662671KeyboardUIMode WebChromeClient::keyboardUIMode()
    663672{

  • trunk/WebKit/mac/WebView/WebView.mm

    r63188 r63339  
    22212221+ (NSCursor *)_pointingHandCursor
    22222222{
    2223     return handCursor().impl();
     2223    return handCursor().platformCursor();
    22242224}
    22252225

  • trunk/WebKit/qt/ChangeLog

    r63191 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebCoreSupport/ChromeClientQt.cpp:
     9        (WebCore::ChromeClientQt::setCursor):
     10        * WebCoreSupport/ChromeClientQt.h:
     11        Change prototype to match new one.
     12
    1132010-07-07  Tor Arne Vestbø  <tor.arne.vestbo@nokia.com>
    214

  • trunk/WebKit/qt/WebCoreSupport/ChromeClientQt.cpp

    r61615 r63339  
    530530}
    531531
    532 bool ChromeClientQt::setCursor(PlatformCursorHandle)
    533 {
    534     notImplemented();
    535     return false;
     532void ChromeClientQt::setCursor(const Cursor&)
     533{
     534    notImplemented();
    536535}
    537536

  • trunk/WebKit/qt/WebCoreSupport/ChromeClientQt.h

    r61342 r63339  
    162162        virtual PassOwnPtr<HTMLParserQuirks> createHTMLParserQuirks() { return 0; }
    163163
    164         virtual bool setCursor(PlatformCursorHandle);
     164        virtual void setCursor(const Cursor&);
    165165
    166166        virtual void scrollRectIntoView(const IntRect&, const ScrollView*) const {}

  • trunk/WebKit/win/ChangeLog

    r63223 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebCoreSupport/WebChromeClient.cpp:
     9        (WebChromeClient::setCursor):
     10        We now need to grab the native cursor out of the WebCore cursor.
     11
     12        (WebChromeClient::setLastSetCursorToCurrentCursor):
     13        Sets the WebView's "last set cursor" to be the current cursor so that
     14        the cursor is set correctly for plugins.
     15        * WebCoreSupport/WebChromeClient.h:
     16        * WebView.cpp:
     17        (WebView::WebView):
     18        (WebView::WebViewWndProc):
     19        * WebView.h:
     20        (WebView::setLastCursor):
     21        Change the "last set cursor" to be stored as a member instead of a global.
     22
    1232010-07-13  Steve Falkenburg  <sfalken@apple.com>
    224

  • trunk/WebKit/win/WebCoreSupport/WebChromeClient.cpp

    r62875 r63339  
    783783}
    784784
    785 bool WebChromeClient::setCursor(PlatformCursorHandle cursor)
    786 {
    787     if (!cursor)
    788         return false;
     785void WebChromeClient::setCursor(const Cursor& cursor)
     786{
     787    HCURSOR platformCursor = cursor.platformCursor()->nativeCursor();
     788    if (!platformCursor)
     789        return;
    789790
    790791    if (COMPtr<IWebUIDelegate> delegate = uiDelegate()) {
    791792        COMPtr<IWebUIDelegatePrivate> delegatePrivate(Query, delegate);
    792793        if (delegatePrivate) {
    793             if (SUCCEEDED(delegatePrivate->webViewSetCursor(m_webView, reinterpret_cast<OLE_HANDLE>(cursor))))
    794                 return true;
     794            if (SUCCEEDED(delegatePrivate->webViewSetCursor(m_webView, reinterpret_cast<OLE_HANDLE>(platformCursor))))
     795                return;
    795796        }
    796797    }
    797798
    798     ::SetCursor(cursor);
    799     return true;
     799    m_webView->setLastCursor(platformCursor);
     800    ::SetCursor(platformCursor);
     801    return;
     802}
     803
     804void WebChromeClient::setLastSetCursorToCurrentCursor()
     805{
     806    m_webView->setLastCursor(::GetCursor());
    800807}
    801808

  • trunk/WebKit/win/WebCoreSupport/WebChromeClient.h

    r62875 r63339  
    131131    virtual void chooseIconForFiles(const Vector<WebCore::String>&, WebCore::FileChooser*);
    132132
    133     virtual bool setCursor(WebCore::PlatformCursorHandle cursor);
     133    virtual void setCursor(const WebCore::Cursor&);
     134    virtual void setLastSetCursorToCurrentCursor();
    134135
    135136    WebView* webView() const { return m_webView; }

  • trunk/WebKit/win/WebView.cpp

    r62876 r63339  
    345345#endif
    346346    , m_nextDisplayIsSynchronous(false)
     347    , m_lastSetCursor(0)
    347348{
    348349    JSC::initializeThreading();
    … …  
    19711972
    19721973    return !!RegisterClassEx(&wcex);
    1973 }
    1974 
    1975 namespace WebCore {
    1976     extern HCURSOR lastSetCursor;
    19771974}
    19781975
    … …  
    22512248            break;
    22522249        case WM_SETCURSOR:
    2253             if (handled = webView->page()->chrome()->setCursor(lastSetCursor))
    2254                 break;
    2255 
    2256             __fallthrough;
     2250            handled = ::SetCursor(webView->m_lastSetCursor);
     2251            break;
    22572252        case WM_VSCROLL:
    22582253            handled = webView->verticalScroll(wParam, lParam);

  • trunk/WebKit/win/WebView.h

    r60722 r63339  
    904904    void exitFullscreen();
    905905
     906    void setLastCursor(HCURSOR cursor) { m_lastSetCursor = cursor; }
     907
    906908private:
    907909    void setZoomMultiplier(float multiplier, bool isTextOnly);
    … …  
    10431045
    10441046    bool m_nextDisplayIsSynchronous;
     1047
     1048    HCURSOR m_lastSetCursor;
    10451049};
    10461050

  • trunk/WebKit/wx/ChangeLog

    r62690 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * WebKitSupport/ChromeClientWx.cpp:
     9        (WebCore::ChromeClientWx::setCursor):
     10        * WebKitSupport/ChromeClientWx.h:
     11        Change prototype to match new one.
     12
    1132010-07-07  Kevin Ollivier  <kevino@theolliviers.com>
    214

  • trunk/WebKit/wx/WebKitSupport/ChromeClientWx.cpp

    r57903 r63339  
    448448}
    449449
    450 bool ChromeClientWx::setCursor(PlatformCursorHandle)
    451 {
    452     notImplemented();
    453     return false;
     450void ChromeClientWx::setCursor(const Cursor&)
     451{
     452    notImplemented();
    454453}
    455454

  • trunk/WebKit/wx/WebKitSupport/ChromeClientWx.h

    r57903 r63339  
    135135    virtual PassOwnPtr<HTMLParserQuirks> createHTMLParserQuirks() { return 0; }
    136136
    137     virtual bool setCursor(PlatformCursorHandle);
     137    virtual void setCursor(const Cursor&);
    138138
    139139    virtual void scrollRectIntoView(const IntRect&, const ScrollView*) const {}

  • trunk/WebKit2/ChangeLog

    r63335 r63339  
     12010-07-14  Sam Weinig  <sam@webkit.org>
     2
     3        Reviewed by Darin Adler.
     4
     5        Patch for https://bugs.webkit.org/show_bug.cgi?id=42232
     6        Make changing Cursors work in WebKit2.
     7
     8        * Shared/CoreIPCSupport/WebPageProxyMessageKinds.h:
     9        Add SetCursor message.
     10
     11        * Shared/WebCoreArgumentCoders.h:
     12        Add encoding/decoding of Cursors. For now we don't support Custom
     13        cursors.
     14
     15        * UIProcess/API/mac/PageClientImpl.h:
     16        * UIProcess/API/mac/PageClientImpl.mm:
     17        (WebKit::PageClientImpl::setCursor):
     18        * UIProcess/PageClient.h:
     19        Add pass through functions to get the cursor from the WebPageProxy
     20        to the WKView.
     21
     22        * UIProcess/API/mac/WKView.mm:
     23        (-[WKView _setCursor:]):
     24        * UIProcess/API/mac/WKViewInternal.h:
     25        Implement changing the cursor.
     26
     27        * UIProcess/WebPageProxy.cpp:
     28        (WebKit::WebPageProxy::didReceiveMessage):
     29        (WebKit::WebPageProxy::setCursor):
     30        * UIProcess/WebPageProxy.h:
     31        Decode the cursor.
     32
     33        * UIProcess/win/WebView.cpp:
     34        (WebKit::WebView::wndProc):
     35        (WebKit::WebView::WebView):
     36        (WebKit::WebView::onSetCursor):
     37        (WebKit::WebView::setCursor):
     38        * UIProcess/win/WebView.h:
     39        Implement changing the cursor.
     40
     41        * WebProcess/WebCoreSupport/WebChromeClient.cpp:
     42        (WebKit::WebChromeClient::setCursor):
     43        (WebKit::WebChromeClient::setLastSetCursorToCurrentCursor):
     44        * WebProcess/WebCoreSupport/WebChromeClient.h:
     45        Encode the cursor when setCursor is called.
     46
    1472010-07-13  Anders Carlsson  <andersca@apple.com>
    248

  • trunk/WebKit2/Shared/CoreIPCSupport/WebPageProxyMessageKinds.h

    r62996 r63339  
    6464    DidStartProvisionalLoadForFrame,
    6565    DidUpdateHistoryTitle,
     66    SetCursor,
    6667    SetToolTip,
    6768    TakeFocus,

  • trunk/WebKit2/Shared/WebCoreArgumentCoders.h

    r61725 r63339  
    3131#include "ArgumentEncoder.h"
    3232#include "Arguments.h"
     33#include <WebCore/Cursor.h>
    3334#include <WebCore/FloatRect.h>
    3435#include <WebCore/IntRect.h>
    … …  
    111112};
    112113
     114template<> struct ArgumentCoder<WebCore::Cursor> {
     115    static void encode(ArgumentEncoder* encoder, const WebCore::Cursor& cursor)
     116    {
     117        // FIXME: Support custom cursors.
     118        if (cursor.type() == WebCore::Cursor::Custom)
     119            encoder->encode(static_cast<uint32_t>(WebCore::Cursor::Pointer));
     120        else
     121            encoder->encode(static_cast<uint32_t>(cursor.type()));
     122    }
     123   
     124    static bool decode(ArgumentDecoder* decoder, WebCore::Cursor& cursor)
     125    {
     126        uint32_t typeInt;
     127        if (!decoder->decode(typeInt))
     128            return false;
     129
     130        WebCore::Cursor::Type type = static_cast<WebCore::Cursor::Type>(typeInt);
     131        ASSERT(type != WebCore::Cursor::Custom);
     132
     133        cursor = WebCore::Cursor::fromType(type);
     134        return true;
     135    }
     136};
     137
    113138} // namespace CoreIPC
    114139

  • trunk/WebKit2/UIProcess/API/mac/PageClientImpl.h

    r61228 r63339  
    4747    virtual void takeFocus(bool direction);
    4848    virtual void toolTipChanged(const WebCore::String& oldToolTip, const WebCore::String& newToolTip);
    49    
     49    virtual void setCursor(const WebCore::Cursor&);
     50
    5051    WKView* m_wkView;
    5152};

  • trunk/WebKit2/UIProcess/API/mac/PageClientImpl.mm

    r61228 r63339  
    2929#import "WKStringCF.h"
    3030#import "WKViewInternal.h"
     31#import <WebCore/Cursor.h>
    3132#import <WebCore/FoundationExtras.h>
    3233#import <WebCore/PlatformString.h>
    … …  
    7071}
    7172
     73void PageClientImpl::setCursor(const WebCore::Cursor& cursor)
     74{
     75    [m_wkView _setCursor:cursor.platformCursor()];
     76}
     77
    7278} // namespace WebKit

  • trunk/WebKit2/UIProcess/API/mac/WKView.mm

    r63157 r63339  
    320320}
    321321
     322- (void)_setCursor:(NSCursor *)cursor
     323{
     324    if ([NSCursor currentCursor] == cursor)
     325        return;
     326    [cursor set];
     327}
    322328
    323329// Any non-zero value will do, but using something recognizable might help us debug some day.

  • trunk/WebKit2/UIProcess/API/mac/WKViewInternal.h

    r62320 r63339  
    3131- (void)_takeFocus:(BOOL)direction;
    3232- (void)_toolTipChangedFrom:(NSString *)oldToolTip to:(NSString *)newToolTip;
     33- (void)_setCursor:(NSCursor *)cursor;
    3334
    3435#if USE(ACCELERATED_COMPOSITING)

  • trunk/WebKit2/UIProcess/PageClient.h

    r58714 r63339  
    2929namespace WebCore {
    3030    class String;
     31    class Cursor;
    3132}
    3233
    … …  
    4243    virtual void takeFocus(bool direction) = 0;
    4344    virtual void toolTipChanged(const WebCore::String&, const WebCore::String&) = 0;
     45
     46    virtual void setCursor(const WebCore::Cursor&) = 0;
    4447};
    4548

  • trunk/WebKit2/UIProcess/WebPageProxy.cpp

    r63049 r63339  
    532532            break;
    533533        }
     534        case WebPageProxyMessage::SetCursor: {
     535            Cursor cursor;
     536            if (!arguments.decode(cursor))
     537                return;
     538            setCursor(cursor);
     539            break;
     540        }
    534541        case WebPageProxyMessage::ShowPage: {
    535542            showPage();
    … …  
    844851}
    845852
     853void WebPageProxy::setCursor(const WebCore::Cursor& cursor)
     854{
     855    m_pageClient->setCursor(cursor);
     856}
     857
    846858void WebPageProxy::didReceiveEvent(WebEvent::Type type)
    847859{

  • trunk/WebKit2/UIProcess/WebPageProxy.h

    r63049 r63339  
    5353namespace WebCore {
    5454    class IntSize;
     55    class Cursor;
    5556}
    5657
    … …  
    191192    void takeFocus(bool direction);
    192193    void setToolTip(const WebCore::String&);
     194    void setCursor(const WebCore::Cursor&);
    193195
    194196    void didReceiveEvent(WebEvent::Type);
    195197    void didRunJavaScriptInMainFrame(const WebCore::String&, uint64_t);
    196198    void didGetRenderTreeExternalRepresentation(const WebCore::String&, uint64_t);
     199
    197200
    198201#if PLATFORM(WIN)

  • trunk/WebKit2/UIProcess/win/WebView.cpp

    r61589 r63339  
    130130            lResult = onShowWindowEvent(hWnd, message, wParam, lParam, handled);
    131131            break;
     132        case WM_SETCURSOR:
     133            lResult = onSetCursor(hWnd, message, wParam, lParam, handled);
     134            break;
    132135        default:
    133136            handled = false;
    … …  
    171174    , m_topLevelParentWindow(0)
    172175    , m_toolTipWindow(0)
     176    , m_lastCursorSet(0)
    173177    , m_trackingMouseLeave(false)
    174178    , m_isBeingDestroyed(false)
    … …  
    409413}
    410414
     415LRESULT WebView::onSetCursor(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, bool& handled)
     416{
     417    handled = ::SetCursor(m_lastCursorSet);
     418    return 0;
     419}
     420
    411421bool WebView::isActive()
    412422{
    … …  
    534544}
    535545
     546void WebView::setCursor(const WebCore::Cursor& cursor)
     547{
     548    HCURSOR platformCursor = cursor.platformCursor()->nativeCursor();
     549    if (!platformCursor)
     550        return;
     551
     552    m_lastCursorSet = platformCursor;
     553    ::SetCursor(platformCursor);
     554}
     555
    536556// WebCore::WindowMessageListener
    537557

  • trunk/WebKit2/UIProcess/win/WebView.h

    r60691 r63339  
    7777    LRESULT onTimerEvent(HWND hWnd, UINT message, WPARAM, LPARAM, bool& handled);
    7878    LRESULT onShowWindowEvent(HWND hWnd, UINT message, WPARAM, LPARAM, bool& handled);
     79    LRESULT onSetCursor(HWND hWnd, UINT message, WPARAM, LPARAM, bool& handled);
    7980
    8081    bool isActive();
    … …  
    9495    virtual void takeFocus(bool direction);
    9596    virtual void toolTipChanged(const WebCore::String&, const WebCore::String&);
     97    virtual void setCursor(const WebCore::Cursor&);
    9698
    9799    // WebCore::WindowMessageListener
    … …  
    104106    HWND m_toolTipWindow;
    105107
     108    HCURSOR m_lastCursorSet;
     109
    106110    bool m_trackingMouseLeave;
    107111    bool m_isBeingDestroyed;

  • trunk/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.cpp

    r62866 r63339  
    417417}
    418418
    419 bool WebChromeClient::setCursor(PlatformCursorHandle)
    420 {
    421     notImplemented();
    422     return false;
     419void WebChromeClient::setCursor(const Cursor& cursor)
     420{
     421    WebProcess::shared().connection()->send(WebPageProxyMessage::SetCursor, m_page->pageID(), CoreIPC::In(cursor));
    423422}
    424423
    … …  
    478477#endif
    479478
     479#if PLATFORM(WIN)
     480void WebChromeClient::setLastSetCursorToCurrentCursor()
     481{
     482}
     483#endif
     484
     485
    480486} // namespace WebKit

  • trunk/WebKit2/WebProcess/WebCoreSupport/WebChromeClient.h

    r62428 r63339  
    152152    virtual void chooseIconForFiles(const Vector<WebCore::String>&, WebCore::FileChooser*);
    153153
    154     virtual bool setCursor(WebCore::PlatformCursorHandle);
     154    virtual void setCursor(const WebCore::Cursor&);
    155155   
    156156    // Notification that the given form element has changed. This function
    … …  
    176176    virtual void needTouchEvents(bool);
    177177#endif
    178    
     178
     179#if PLATFORM(WIN)
     180    virtual void setLastSetCursorToCurrentCursor();
     181#endif
     182
    179183    WebCore::String m_cachedToolTip;
    180184    WebPage* m_page;
Note: See TracChangeset for help on using the changeset viewer.