← Back to branch summary

~ubuntu-branches/ubuntu/karmic/webkit/karmic-proposed

« back to all changes in this revision

Viewing changes to WebCore/editing/ApplyStyleCommand.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Gustavo Noronha Silva
  • Date: 2009-05-15 18:30:58 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20090515183058-50q5exjo9b1kxy9s
Tags: 1.1.7-1
http://bugs.debian.org/526683
* New upstream release
* debian/libwebkit-1.0-2.symbols:
- updated with the new symbols in 1.1.7
* debian/libwebkit-dev.install, debian/libwebkit-dev.links,
  debian/rules:
- Build, and ship gtk-doc documentation (Closes: #526683)
* debian/copyright:
- updated.

Show diffs side-by-side

added added

removed removed

Lines of Context:
WebCore/editing/ApplyStyleCommand.cpp
27
27
#include "ApplyStyleCommand.h"
28
28
 
29
29
#include "CSSComputedStyleDeclaration.h"
 
30
#include "CSSMutableStyleDeclaration.h"
30
31
#include "CSSParser.h"
31
32
#include "CSSProperty.h"
32
33
#include "CSSPropertyNames.h"
228
229
{
229
230
    ASSERT(pos.isNotNull());
230
231
    RefPtr<CSSComputedStyleDeclaration> style = pos.computedStyle();
231
 
    RefPtr<CSSValue> value = style->getPropertyCSSValue(property->id(), DoNotUpdateLayout);
 
232
    RefPtr<CSSValue> value;
 
233
    if (property->id() == CSSPropertyFontSize)
 
234
        value = style->getFontSizeCSSValuePreferringKeyword();
 
235
    else
 
236
        value = style->getPropertyCSSValue(property->id(), DoNotUpdateLayout);
232
237
    if (!value)
233
238
        return false;
234
239
    return equalIgnoringCase(value->cssText(), property->value()->cssText());
520
525
    
521
526
    start = start.upstream(); // Move upstream to ensure we do not add redundant spans.
522
527
    Node *startNode = start.node();
523
 
    if (startNode->isTextNode() && start.m_offset >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
 
528
    if (startNode->isTextNode() && start.deprecatedEditingOffset() >= caretMaxOffset(startNode)) // Move out of text node if range does not include its characters.
524
529
        startNode = startNode->traverseNextNode();
525
530
 
526
531
    // Store away font size before making any changes to the document.
868
873
 
869
874
    bool rangeIsEmpty = false;
870
875
 
871
 
    if (start.m_offset >= caretMaxOffset(start.node())) {
 
876
    if (start.deprecatedEditingOffset() >= caretMaxOffset(start.node())) {
872
877
        node = node->traverseNextNode();
873
878
        Position newStart = Position(node, 0);
874
879
        if (!node || Range::compareBoundaryPoints(end, newStart) < 0)
878
883
    if (!rangeIsEmpty) {
879
884
        // pastEndNode is the node after the last fully selected node.
880
885
        Node* pastEndNode = end.node();
881
 
        if (end.m_offset >= caretMaxOffset(end.node()))
 
886
        if (end.deprecatedEditingOffset() >= caretMaxOffset(end.node()))
882
887
            pastEndNode = end.node()->traverseNextSibling();
883
888
        // FIXME: Callers should perform this operation on a Range that includes the br
884
889
        // if they want style applied to the empty line.
896
901
                // This is a plaintext-only region. Only proceed if it's fully selected.
897
902
                // pastEndNode is the node after the last fully selected node, so if it's inside node then
898
903
                // node isn't fully selected.
899
 
                if (pastEndNode->isDescendantOf(node))
 
904
                if (pastEndNode && pastEndNode->isDescendantOf(node))
900
905
                    break;
901
906
                // Add to this element's inline style and skip over its contents.
902
907
                HTMLElement* element = static_cast<HTMLElement*>(node);
1239
1244
                if (s.node() == elem) {
1240
1245
                    // Since elem must have been fully selected, and it is at the start
1241
1246
                    // of the selection, it is clear we can set the new s offset to 0.
1242
 
                    ASSERT(s.m_offset <= caretMinOffset(s.node()));
 
1247
                    ASSERT(s.deprecatedEditingOffset() <= caretMinOffset(s.node()));
1243
1248
                    s = Position(next, 0);
1244
1249
                }
1245
1250
                if (e.node() == elem) {
1246
1251
                    // Since elem must have been fully selected, and it is at the end
1247
1252
                    // of the selection, it is clear we can set the new e offset to
1248
1253
                    // the max range offset of prev.
1249
 
                    ASSERT(e.m_offset >= maxRangeOffset(e.node()));
 
1254
                    ASSERT(e.deprecatedEditingOffset() >= maxRangeOffset(e.node()));
1250
1255
                    e = Position(prev, maxRangeOffset(prev));
1251
1256
                }
1252
1257
            }
1267
1272
    ASSERT(node->isElementNode());
1268
1273
 
1269
1274
    Position pos = Position(node, node->childNodeCount()).upstream();
1270
 
    return Range::compareBoundaryPoints(node, 0, start.node(), start.m_offset) >= 0 &&
 
1275
    return Range::compareBoundaryPoints(node, 0, start.node(), start.deprecatedEditingOffset()) >= 0 &&
1271
1276
        Range::compareBoundaryPoints(pos, end) <= 0;
1272
1277
}
1273
1278
 
1278
1283
 
1279
1284
    Position pos = Position(node, node->childNodeCount()).upstream();
1280
1285
    bool isFullyBeforeStart = Range::compareBoundaryPoints(pos, start) < 0;
1281
 
    bool isFullyAfterEnd = Range::compareBoundaryPoints(node, 0, end.node(), end.m_offset) > 0;
 
1286
    bool isFullyAfterEnd = Range::compareBoundaryPoints(node, 0, end.node(), end.deprecatedEditingOffset()) > 0;
1282
1287
 
1283
1288
    return isFullyBeforeStart || isFullyAfterEnd;
1284
1289
}
1286
1291
 
1287
1292
bool ApplyStyleCommand::splitTextAtStartIfNeeded(const Position &start, const Position &end)
1288
1293
{
1289
 
    if (start.node()->isTextNode() && start.m_offset > caretMinOffset(start.node()) && start.m_offset < caretMaxOffset(start.node())) {
1290
 
        int endOffsetAdjustment = start.node() == end.node() ? start.m_offset : 0;
 
1294
    if (start.node()->isTextNode() && start.deprecatedEditingOffset() > caretMinOffset(start.node()) && start.deprecatedEditingOffset() < caretMaxOffset(start.node())) {
 
1295
        int endOffsetAdjustment = start.node() == end.node() ? start.deprecatedEditingOffset() : 0;
1291
1296
        Text *text = static_cast<Text *>(start.node());
1292
 
        splitTextNode(text, start.m_offset);
1293
 
        updateStartEnd(Position(start.node(), 0), Position(end.node(), end.m_offset - endOffsetAdjustment));
 
1297
        splitTextNode(text, start.deprecatedEditingOffset());
 
1298
        updateStartEnd(Position(start.node(), 0), Position(end.node(), end.deprecatedEditingOffset() - endOffsetAdjustment));
1294
1299
        return true;
1295
1300
    }
1296
1301
    return false;
1298
1303
 
1299
1304
bool ApplyStyleCommand::splitTextAtEndIfNeeded(const Position &start, const Position &end)
1300
1305
{
1301
 
    if (end.node()->isTextNode() && end.m_offset > caretMinOffset(end.node()) && end.m_offset < caretMaxOffset(end.node())) {
 
1306
    if (end.node()->isTextNode() && end.deprecatedEditingOffset() > caretMinOffset(end.node()) && end.deprecatedEditingOffset() < caretMaxOffset(end.node())) {
1302
1307
        Text *text = static_cast<Text *>(end.node());
1303
 
        splitTextNode(text, end.m_offset);
 
1308
        splitTextNode(text, end.deprecatedEditingOffset());
1304
1309
        
1305
1310
        Node *prevNode = text->previousSibling();
1306
1311
        ASSERT(prevNode);
1307
1312
        Node *startNode = start.node() == end.node() ? prevNode : start.node();
1308
1313
        ASSERT(startNode);
1309
 
        updateStartEnd(Position(startNode, start.m_offset), Position(prevNode, caretMaxOffset(prevNode)));
 
1314
        updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(prevNode, caretMaxOffset(prevNode)));
1310
1315
        return true;
1311
1316
    }
1312
1317
    return false;
1314
1319
 
1315
1320
bool ApplyStyleCommand::splitTextElementAtStartIfNeeded(const Position &start, const Position &end)
1316
1321
{
1317
 
    if (start.node()->isTextNode() && start.m_offset > caretMinOffset(start.node()) && start.m_offset < caretMaxOffset(start.node())) {
1318
 
        int endOffsetAdjustment = start.node() == end.node() ? start.m_offset : 0;
 
1322
    if (start.node()->isTextNode() && start.deprecatedEditingOffset() > caretMinOffset(start.node()) && start.deprecatedEditingOffset() < caretMaxOffset(start.node())) {
 
1323
        int endOffsetAdjustment = start.node() == end.node() ? start.deprecatedEditingOffset() : 0;
1319
1324
        Text *text = static_cast<Text *>(start.node());
1320
 
        splitTextNodeContainingElement(text, start.m_offset);
 
1325
        splitTextNodeContainingElement(text, start.deprecatedEditingOffset());
1321
1326
 
1322
 
        updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex()), Position(end.node(), end.m_offset - endOffsetAdjustment));
 
1327
        updateStartEnd(Position(start.node()->parentNode(), start.node()->nodeIndex()), Position(end.node(), end.deprecatedEditingOffset() - endOffsetAdjustment));
1323
1328
        return true;
1324
1329
    }
1325
1330
    return false;
1327
1332
 
1328
1333
bool ApplyStyleCommand::splitTextElementAtEndIfNeeded(const Position &start, const Position &end)
1329
1334
{
1330
 
    if (end.node()->isTextNode() && end.m_offset > caretMinOffset(end.node()) && end.m_offset < caretMaxOffset(end.node())) {
 
1335
    if (end.node()->isTextNode() && end.deprecatedEditingOffset() > caretMinOffset(end.node()) && end.deprecatedEditingOffset() < caretMaxOffset(end.node())) {
1331
1336
        Text *text = static_cast<Text *>(end.node());
1332
 
        splitTextNodeContainingElement(text, end.m_offset);
 
1337
        splitTextNodeContainingElement(text, end.deprecatedEditingOffset());
1333
1338
 
1334
1339
        Node *prevNode = text->parent()->previousSibling()->lastChild();
1335
1340
        ASSERT(prevNode);
1336
1341
        Node *startNode = start.node() == end.node() ? prevNode : start.node();
1337
1342
        ASSERT(startNode);
1338
 
        updateStartEnd(Position(startNode, start.m_offset), Position(prevNode->parent(), prevNode->nodeIndex() + 1));
 
1343
        updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(prevNode->parent(), prevNode->nodeIndex() + 1));
1339
1344
        return true;
1340
1345
    }
1341
1346
    return false;
1379
1384
bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position &start, const Position &end)
1380
1385
{
1381
1386
    Node *startNode = start.node();
1382
 
    int startOffset = start.m_offset;
 
1387
    int startOffset = start.deprecatedEditingOffset();
1383
1388
 
1384
1389
    if (isAtomicNode(start.node())) {
1385
 
        if (start.m_offset != 0)
 
1390
        if (start.deprecatedEditingOffset() != 0)
1386
1391
            return false;
1387
1392
 
1388
1393
        // note: prior siblings could be unrendered elements. it's silly to miss the
1411
1416
 
1412
1417
        int startOffsetAdjustment = startChild->nodeIndex();
1413
1418
        int endOffsetAdjustment = startNode == end.node() ? startOffsetAdjustment : 0;
1414
 
        updateStartEnd(Position(startNode, startOffsetAdjustment), Position(end.node(), end.m_offset + endOffsetAdjustment)); 
 
1419
        updateStartEnd(Position(startNode, startOffsetAdjustment), Position(end.node(), end.deprecatedEditingOffset() + endOffsetAdjustment)); 
1415
1420
        return true;
1416
1421
    }
1417
1422
 
1421
1426
bool ApplyStyleCommand::mergeEndWithNextIfIdentical(const Position &start, const Position &end)
1422
1427
{
1423
1428
    Node *endNode = end.node();
1424
 
    int endOffset = end.m_offset;
 
1429
    int endOffset = end.deprecatedEditingOffset();
1425
1430
 
1426
1431
    if (isAtomicNode(endNode)) {
1427
1432
        if (endOffset < caretMaxOffset(endNode))
1451
1456
        ASSERT(startNode);
1452
1457
 
1453
1458
        int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
1454
 
        updateStartEnd(Position(startNode, start.m_offset), Position(nextElement, endOffset));
 
1459
        updateStartEnd(Position(startNode, start.deprecatedEditingOffset()), Position(nextElement, endOffset));
1455
1460
        return true;
1456
1461
    }
1457
1462
 
1607
1612
            Text *childText = static_cast<Text *>(child);
1608
1613
            Text *nextText = static_cast<Text *>(next);
1609
1614
            if (next == start.node())
1610
 
                newStart = Position(childText, childText->length() + start.m_offset);
 
1615
                newStart = Position(childText, childText->length() + start.deprecatedEditingOffset());
1611
1616
            if (next == end.node())
1612
 
                newEnd = Position(childText, childText->length() + end.m_offset);
 
1617
                newEnd = Position(childText, childText->length() + end.deprecatedEditingOffset());
1613
1618
            String textToMove = nextText->data();
1614
1619
            insertTextIntoNode(childText, childText->length(), textToMove);
1615
1620
            removeNode(next);