Changeset 238894 in webkit


Ignore:
Timestamp:
Dec 5, 2018 9:51:03 AM (5 years ago)
Author:
Wenson Hsieh
Message:

Turn WritingDirection into an enum class
​https://bugs.webkit.org/show_bug.cgi?id=192401
Work towards <rdar://problem/42075638>

Reviewed by Dan Bernstein.

Change WritingDirection from an enum to an enum class. No change in behavior.

Source/WebCore:

  • editing/ApplyStyleCommand.cpp:

(WebCore::ApplyStyleCommand::splitAncestorsWithUnicodeBidi):
(WebCore::ApplyStyleCommand::applyInlineStyle):

  • editing/EditingStyle.cpp:

(WebCore::EditingStyle::textDirection const):
(WebCore::EditingStyle::textDirectionForSelection):

  • editing/Editor.cpp:

(WebCore::Editor::setBaseWritingDirection):
(WebCore::Editor::baseWritingDirectionForSelectionStart const):

  • editing/EditorCommand.cpp:

(WebCore::stateTextWritingDirectionLeftToRight):
(WebCore::stateTextWritingDirectionNatural):
(WebCore::stateTextWritingDirectionRightToLeft):

  • editing/WritingDirection.h:

Additionally wrap this enum in namespace WebCore, and update the copyright year.

  • editing/ios/EditorIOS.mm:

(WebCore::Editor::setTextAlignmentForChangedBaseWritingDirection):

  • page/ContextMenuController.cpp:

(WebCore::ContextMenuController::contextMenuItemSelected):

  • testing/Internals.cpp:

(WebCore::Internals::setBaseWritingDirection):

Source/WebKit:

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::setTextDirection):

Source/WebKitLegacy/ios:

  • WebCoreSupport/WebFrameIOS.mm:

(-[WebFrame selectionBaseWritingDirection]):
(-[WebFrame setBaseWritingDirection:]):

Source/WebKitLegacy/mac:

  • WebView/WebHTMLView.mm:

(-[WebHTMLView toggleBaseWritingDirection:]):
(-[WebHTMLView changeBaseWritingDirection:]):
(-[WebHTMLView _changeBaseWritingDirectionTo:]):

Source/WebKitLegacy/win:

  • WebFrame.cpp:

(WebFrame::setTextDirection):

Location:
trunk/Source
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r238892 r238894  
     12018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Turn WritingDirection into an enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=192401
     5        Work towards <rdar://problem/42075638>
     6
     7        Reviewed by Dan Bernstein.
     8
     9        Change WritingDirection from an enum to an enum class. No change in behavior.
     10
     11        * editing/ApplyStyleCommand.cpp:
     12        (WebCore::ApplyStyleCommand::splitAncestorsWithUnicodeBidi):
     13        (WebCore::ApplyStyleCommand::applyInlineStyle):
     14        * editing/EditingStyle.cpp:
     15        (WebCore::EditingStyle::textDirection const):
     16        (WebCore::EditingStyle::textDirectionForSelection):
     17        * editing/Editor.cpp:
     18        (WebCore::Editor::setBaseWritingDirection):
     19        (WebCore::Editor::baseWritingDirectionForSelectionStart const):
     20        * editing/EditorCommand.cpp:
     21        (WebCore::stateTextWritingDirectionLeftToRight):
     22        (WebCore::stateTextWritingDirectionNatural):
     23        (WebCore::stateTextWritingDirectionRightToLeft):
     24        * editing/WritingDirection.h:
     25
     26        Additionally wrap this enum in `namespace WebCore`, and update the copyright year.
     27
     28        * editing/ios/EditorIOS.mm:
     29        (WebCore::Editor::setTextAlignmentForChangedBaseWritingDirection):
     30        * page/ContextMenuController.cpp:
     31        (WebCore::ContextMenuController::contextMenuItemSelected):
     32        * testing/Internals.cpp:
     33        (WebCore::Internals::setBaseWritingDirection):
     34
    1352018-12-05  Alicia Boya García  <aboya@igalia.com>
    236

  • trunk/Source/WebCore/editing/ApplyStyleCommand.cpp

    r234116 r238894  
    485485
    486486    WritingDirection highestAncestorDirection;
    487     if (allowedDirection != NaturalWritingDirection
     487    if (allowedDirection != WritingDirection::Natural
    488488        && highestAncestorUnicodeBidi != CSSValueBidiOverride
    489489        && is<HTMLElement>(*highestAncestorWithUnicodeBidi)
    … …  
    615615    // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
    616616    Position removeStart = start.upstream();
    617     WritingDirection textDirection = NaturalWritingDirection;
     617    WritingDirection textDirection = WritingDirection::Natural;
    618618    bool hasTextDirection = style.textDirection(textDirection);
    619619    RefPtr<EditingStyle> styleWithoutEmbedding;

  • trunk/Source/WebCore/editing/EditingStyle.cpp

    r238212 r238894  
    568568            return false;
    569569
    570         writingDirection = downcast<CSSPrimitiveValue>(*direction).valueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
     570        writingDirection = downcast<CSSPrimitiveValue>(*direction).valueID() == CSSValueLtr ? WritingDirection::LeftToRight : WritingDirection::RightToLeft;
    571571
    572572        return true;
    … …  
    574574
    575575    if (unicodeBidiValue == CSSValueNormal) {
    576         writingDirection = NaturalWritingDirection;
     576        writingDirection = WritingDirection::Natural;
    577577        return true;
    578578    }
    … …  
    14691469
    14701470    if (selection.isNone())
    1471         return NaturalWritingDirection;
     1471        return WritingDirection::Natural;
    14721472
    14731473    Position position = selection.start().downstream();
    … …  
    14751475    Node* node = position.deprecatedNode();
    14761476    if (!node)
    1477         return NaturalWritingDirection;
     1477        return WritingDirection::Natural;
    14781478
    14791479    Position end;
    … …  
    14921492            CSSValueID unicodeBidiValue = downcast<CSSPrimitiveValue>(*unicodeBidi).valueID();
    14931493            if (unicodeBidiValue == CSSValueEmbed || unicodeBidiValue == CSSValueBidiOverride)
    1494                 return NaturalWritingDirection;
     1494                return WritingDirection::Natural;
    14951495        }
    14961496    }
    … …  
    15081508    // to decide.
    15091509    Node* block = enclosingBlock(node);
    1510     WritingDirection foundDirection = NaturalWritingDirection;
     1510    auto foundDirection = WritingDirection::Natural;
    15111511
    15121512    for (; node != block; node = node->parentNode()) {
    … …  
    15241524
    15251525        if (unicodeBidiValue == CSSValueBidiOverride)
    1526             return NaturalWritingDirection;
     1526            return WritingDirection::Natural;
    15271527
    15281528        ASSERT(unicodeBidiValue == CSSValueEmbed);
    … …  
    15351535            continue;
    15361536
    1537         if (foundDirection != NaturalWritingDirection)
    1538             return NaturalWritingDirection;
     1537        if (foundDirection != WritingDirection::Natural)
     1538            return WritingDirection::Natural;
    15391539
    15401540        // In the range case, make sure that the embedding element persists until the end of the range.
    15411541        if (selection.isRange() && !end.deprecatedNode()->isDescendantOf(*node))
    1542             return NaturalWritingDirection;
     1542            return WritingDirection::Natural;
    15431543       
    1544         foundDirection = directionValue == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
     1544        foundDirection = directionValue == CSSValueLtr ? WritingDirection::LeftToRight : WritingDirection::RightToLeft;
    15451545    }
    15461546    hasNestedOrMultipleEmbeddings = false;

  • trunk/Source/WebCore/editing/Editor.cpp

    r238771 r238894  
    17811781    Element* focusedElement = document().focusedElement();
    17821782    if (focusedElement && focusedElement->isTextField()) {
    1783         if (direction == NaturalWritingDirection)
     1783        if (direction == WritingDirection::Natural)
    17841784            return;
    17851785
    17861786        auto& focusedFormElement = downcast<HTMLTextFormControlElement>(*focusedElement);
    1787         auto directionValue = direction == LeftToRightWritingDirection ? "ltr" : "rtl";
     1787        auto directionValue = direction == WritingDirection::LeftToRight ? "ltr" : "rtl";
    17881788        auto writingDirectionInputTypeName = inputTypeNameForEditingAction(EditAction::SetWritingDirection);
    17891789        if (!dispatchBeforeInputEvent(focusedFormElement, writingDirectionInputTypeName, directionValue))
    … …  
    17971797
    17981798    RefPtr<MutableStyleProperties> style = MutableStyleProperties::create();
    1799     style->setProperty(CSSPropertyDirection, direction == LeftToRightWritingDirection ? "ltr" : direction == RightToLeftWritingDirection ? "rtl" : "inherit", false);
     1799    style->setProperty(CSSPropertyDirection, direction == WritingDirection::LeftToRight ? "ltr" : direction == WritingDirection::RightToLeft ? "rtl" : "inherit", false);
    18001800    applyParagraphStyleToSelection(style.get(), EditAction::SetWritingDirection);
    18011801}
    … …  
    18031803WritingDirection Editor::baseWritingDirectionForSelectionStart() const
    18041804{
    1805     WritingDirection result = LeftToRightWritingDirection;
     1805    auto result = WritingDirection::LeftToRight;
    18061806
    18071807    Position pos = m_frame.selection().selection().visibleStart().deepEquivalent();
    … …  
    18221822    switch (renderer->style().direction()) {
    18231823    case TextDirection::LTR:
    1824         return LeftToRightWritingDirection;
     1824        return WritingDirection::LeftToRight;
    18251825    case TextDirection::RTL:
    1826         return RightToLeftWritingDirection;
     1826        return WritingDirection::RightToLeft;
    18271827    }
    18281828   

  • trunk/Source/WebCore/editing/EditorCommand.cpp

    r238475 r238894  
    14311431static TriState stateTextWritingDirectionLeftToRight(Frame& frame, Event*)
    14321432{
    1433     return stateTextWritingDirection(frame, LeftToRightWritingDirection);
     1433    return stateTextWritingDirection(frame, WritingDirection::LeftToRight);
    14341434}
    14351435
    14361436static TriState stateTextWritingDirectionNatural(Frame& frame, Event*)
    14371437{
    1438     return stateTextWritingDirection(frame, NaturalWritingDirection);
     1438    return stateTextWritingDirection(frame, WritingDirection::Natural);
    14391439}
    14401440
    14411441static TriState stateTextWritingDirectionRightToLeft(Frame& frame, Event*)
    14421442{
    1443     return stateTextWritingDirection(frame, RightToLeftWritingDirection);
     1443    return stateTextWritingDirection(frame, WritingDirection::RightToLeft);
    14441444}
    14451445

  • trunk/Source/WebCore/editing/WritingDirection.h

    r165676 r238894  
    11/*
    2  * Copyright (C) 2008 Apple Inc. All rights reserved.
     2 * Copyright (C) 2008-2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #ifndef WritingDirection_h
    27 #define WritingDirection_h
     26#pragma once
    2827
    29 enum WritingDirection { NaturalWritingDirection, LeftToRightWritingDirection, RightToLeftWritingDirection };
     28#include <wtf/Forward.h>
    3029
    31 #endif
     30namespace WebCore {
     31
     32enum class WritingDirection : uint8_t {
     33    Natural,
     34    LeftToRight,
     35    RightToLeft
     36};
     37
     38} // namespace WebCore
     39
     40namespace WTF {
     41
     42template<> struct EnumTraits<WebCore::WritingDirection> {
     43    using values = EnumValues<
     44        WebCore::WritingDirection,
     45        WebCore::WritingDirection::Natural,
     46        WebCore::WritingDirection::LeftToRight,
     47        WebCore::WritingDirection::RightToLeft
     48    >;
     49};
     50
     51} // namespace WTF

  • trunk/Source/WebCore/editing/ios/EditorIOS.mm

    r237266 r238894  
    9898    case TextAlignMode::End: {
    9999        switch (direction) {
    100         case NaturalWritingDirection:
     100        case WritingDirection::Natural:
    101101            // no-op
    102102            break;
    103         case LeftToRightWritingDirection:
     103        case WritingDirection::LeftToRight:
    104104            newValue = "left";
    105105            break;
    106         case RightToLeftWritingDirection:
     106        case WritingDirection::RightToLeft:
    107107            newValue = "right";
    108108            break;
    … …  
    132132        && (downcast<HTMLInputElement>(*focusedElement).isTextField()
    133133            || downcast<HTMLInputElement>(*focusedElement).isSearchField())))) {
    134         if (direction == NaturalWritingDirection)
     134        if (direction == WritingDirection::Natural)
    135135            return;
    136136        downcast<HTMLElement>(*focusedElement).setAttributeWithoutSynchronization(alignAttr, newValue);

  • trunk/Source/WebCore/page/ContextMenuController.cpp

    r238771 r238894  
    430430        break;
    431431    case ContextMenuItemTagDefaultDirection:
    432         frame->editor().setBaseWritingDirection(NaturalWritingDirection);
     432        frame->editor().setBaseWritingDirection(WritingDirection::Natural);
    433433        break;
    434434    case ContextMenuItemTagLeftToRight:
    435         frame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
     435        frame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
    436436        break;
    437437    case ContextMenuItemTagRightToLeft:
    438         frame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
     438        frame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
    439439        break;
    440440    case ContextMenuItemTagTextDirectionDefault:

  • trunk/Source/WebCore/testing/Internals.cpp

    r238874 r238894  
    43554355            switch (direction) {
    43564356            case BaseWritingDirection::Ltr:
    4357                 frame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
     4357                frame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
    43584358                break;
    43594359            case BaseWritingDirection::Rtl:
    4360                 frame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
     4360                frame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
    43614361                break;
    43624362            case BaseWritingDirection::Natural:
    4363                 frame->editor().setBaseWritingDirection(NaturalWritingDirection);
     4363                frame->editor().setBaseWritingDirection(WritingDirection::Natural);
    43644364                break;
    43654365            }

  • trunk/Source/WebKit/ChangeLog

    r238891 r238894  
     12018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Turn WritingDirection into an enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=192401
     5        Work towards <rdar://problem/42075638>
     6
     7        Reviewed by Dan Bernstein.
     8
     9        Change WritingDirection from an enum to an enum class. No change in behavior.
     10
     11        * WebProcess/WebPage/WebFrame.cpp:
     12        (WebKit::WebFrame::setTextDirection):
     13
    1142018-12-05  Rob Buis  <rbuis@igalia.com>
    215

  • trunk/Source/WebKit/WebProcess/WebPage/WebFrame.cpp

    r238771 r238894  
    803803
    804804    if (direction == "auto")
    805         m_coreFrame->editor().setBaseWritingDirection(NaturalWritingDirection);
     805        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::Natural);
    806806    else if (direction == "ltr")
    807         m_coreFrame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
     807        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
    808808    else if (direction == "rtl")
    809         m_coreFrame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
     809        m_coreFrame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
    810810}
    811811

  • trunk/Source/WebKitLegacy/ios/ChangeLog

    r238814 r238894  
     12018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Turn WritingDirection into an enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=192401
     5        Work towards <rdar://problem/42075638>
     6
     7        Reviewed by Dan Bernstein.
     8
     9        Change WritingDirection from an enum to an enum class. No change in behavior.
     10
     11        * WebCoreSupport/WebFrameIOS.mm:
     12        (-[WebFrame selectionBaseWritingDirection]):
     13        (-[WebFrame setBaseWritingDirection:]):
     14
    1152018-12-03  Daniel Bates  <dabates@apple.com>
    216

  • trunk/Source/WebKitLegacy/ios/WebCoreSupport/WebFrameIOS.mm

    r237266 r238894  
    534534    Frame *frame = [self coreFrame];
    535535    switch (frame->editor().baseWritingDirectionForSelectionStart()) {
    536     case LeftToRightWritingDirection:
     536    case WritingDirection::LeftToRight:
    537537        return WKWritingDirectionLeftToRight;
    538538
    539     case RightToLeftWritingDirection:
     539    case WritingDirection::RightToLeft:
    540540        return WKWritingDirectionRightToLeft;
    541541
    … …  
    574574        return;
    575575   
    576     WritingDirection wcDirection = LeftToRightWritingDirection;
     576    auto wcDirection = WritingDirection::LeftToRight;
    577577    switch (direction) {
    578578        case WKWritingDirectionNatural:
    579             wcDirection = NaturalWritingDirection;
     579            wcDirection = WritingDirection::Natural;
    580580            break;
    581581        case WKWritingDirectionLeftToRight:
    582             wcDirection = LeftToRightWritingDirection;
     582            wcDirection = WritingDirection::LeftToRight;
    583583            break;
    584584        case WKWritingDirectionRightToLeft:
    585             wcDirection = RightToLeftWritingDirection;
     585            wcDirection = WritingDirection::RightToLeft;
    586586            break;
    587587        default:

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r238819 r238894  
     12018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Turn WritingDirection into an enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=192401
     5        Work towards <rdar://problem/42075638>
     6
     7        Reviewed by Dan Bernstein.
     8
     9        Change WritingDirection from an enum to an enum class. No change in behavior.
     10
     11        * WebView/WebHTMLView.mm:
     12        (-[WebHTMLView toggleBaseWritingDirection:]):
     13        (-[WebHTMLView changeBaseWritingDirection:]):
     14        (-[WebHTMLView _changeBaseWritingDirectionTo:]):
     15
    1162018-12-03  Alex Christensen  <achristensen@webkit.org>
    217

  • trunk/Source/WebKitLegacy/mac/WebView/WebHTMLView.mm

    r238814 r238894  
    55215521        return;
    55225522
    5523     WritingDirection direction = RightToLeftWritingDirection;
     5523    auto direction = WritingDirection::RightToLeft;
    55245524    switch (coreFrame->editor().baseWritingDirectionForSelectionStart()) {
    5525         case LeftToRightWritingDirection:
    5526             break;
    5527         case RightToLeftWritingDirection:
    5528             direction = LeftToRightWritingDirection;
    5529             break;
    5530         // The writingDirectionForSelectionStart method will never return "natural". It
    5531         // will always return a concrete direction. So, keep the compiler happy, and assert not reached.
    5532         case NaturalWritingDirection:
    5533             ASSERT_NOT_REACHED();
    5534             break;
     5525    case WritingDirection::LeftToRight:
     5526        break;
     5527    case WritingDirection::RightToLeft:
     5528        direction = WritingDirection::LeftToRight;
     5529        break;
     5530    // The writingDirectionForSelectionStart method will never return "natural". It
     5531    // will always return a concrete direction. So, keep the compiler happy, and assert not reached.
     5532    case WritingDirection::Natural:
     5533        ASSERT_NOT_REACHED();
     5534        break;
    55355535    }
    55365536
    … …  
    55535553
    55545554    if (Frame* coreFrame = core([self _frame]))
    5555         coreFrame->editor().setBaseWritingDirection(writingDirection == NSWritingDirectionLeftToRight ? LeftToRightWritingDirection : RightToLeftWritingDirection);
     5555        coreFrame->editor().setBaseWritingDirection(writingDirection == NSWritingDirectionLeftToRight ? WritingDirection::LeftToRight : WritingDirection::RightToLeft);
    55565556}
    55575557
    … …  
    55745574
    55755575    if (Frame* coreFrame = core([self _frame]))
    5576         coreFrame->editor().setBaseWritingDirection(direction == NSWritingDirectionLeftToRight ? LeftToRightWritingDirection : RightToLeftWritingDirection);
     5576        coreFrame->editor().setBaseWritingDirection(direction == NSWritingDirectionLeftToRight ? WritingDirection::LeftToRight : WritingDirection::RightToLeft);
    55775577}
    55785578

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r238802 r238894  
     12018-12-05  Wenson Hsieh  <wenson_hsieh@apple.com>
     2
     3        Turn WritingDirection into an enum class
     4        https://bugs.webkit.org/show_bug.cgi?id=192401
     5        Work towards <rdar://problem/42075638>
     6
     7        Reviewed by Dan Bernstein.
     8
     9        Change WritingDirection from an enum to an enum class. No change in behavior.
     10
     11        * WebFrame.cpp:
     12        (WebFrame::setTextDirection):
     13
    1142018-12-03  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
    215

  • trunk/Source/WebKitLegacy/win/WebFrame.cpp

    r238212 r238894  
    980980    String directionString(direction, SysStringLen(direction));
    981981    if (directionString == "auto")
    982         coreFrame->editor().setBaseWritingDirection(NaturalWritingDirection);
     982        coreFrame->editor().setBaseWritingDirection(WritingDirection::Natural);
    983983    else if (directionString == "ltr")
    984         coreFrame->editor().setBaseWritingDirection(LeftToRightWritingDirection);
     984        coreFrame->editor().setBaseWritingDirection(WritingDirection::LeftToRight);
    985985    else if (directionString == "rtl")
    986         coreFrame->editor().setBaseWritingDirection(RightToLeftWritingDirection);
     986        coreFrame->editor().setBaseWritingDirection(WritingDirection::RightToLeft);
    987987    return S_OK;
    988988}
Note: See TracChangeset for help on using the changeset viewer.