WebCore/khtml/editing/edit_command.cpp

   1 /*
   2  * Copyright (C) 2005 Apple Computer, Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "edit_command.h"
  27 #include "selection.h"
  28 #include "khtml_part.h"
  29
  30 #include "xml/dom_position.h"
  31 #include "xml/dom_docimpl.h"
  32 #include "css/css_valueimpl.h"
  33 #include "css/css_computedstyle.h"
  34
  35 #if APPLE_CHANGES
  36 #include "KWQAssertions.h"
  37 #else
  38 #define ASSERT(assertion) assert(assertion)
  39 #endif
  40
  41 using DOM::DocumentImpl;
  42 using DOM::Position;
  43 using DOM::CSSMutableStyleDeclarationImpl;
  44 using DOM::CSSComputedStyleDeclarationImpl;
  45
  46 #define IF_IMPL_NULL_RETURN_ARG(arg) do { \
  47         if (isNull()) { return arg; } \
  48     } while (0)
  49
  50 #define IF_IMPL_NULL_RETURN do { \
  51         if (isNull()) { return; } \
  52     } while (0)
  53
  54 namespace khtml {
  55
  56 //------------------------------------------------------------------------------------------
  57 // EditCommandPtr
  58
  59 EditCommandPtr::EditCommandPtr()
  60 {
  61 }
  62
  63 EditCommandPtr::EditCommandPtr(EditCommand *impl) : SharedPtr<EditCommand>(impl)
  64 {
  65 }
  66
  67 EditCommandPtr::EditCommandPtr(const EditCommandPtr &o) : SharedPtr<EditCommand>(o)
  68 {
  69 }
  70
  71 EditCommandPtr::~EditCommandPtr()
  72 {
  73 }
  74
  75 EditCommandPtr &EditCommandPtr::operator=(const EditCommandPtr &c)
  76 {
  77     static_cast<SharedPtr<EditCommand> &>(*this) = c;
  78     return *this;
  79 }
  80
  81 bool EditCommandPtr::isCompositeStep() const
  82 {
  83     IF_IMPL_NULL_RETURN_ARG(false);
  84     return get()->isCompositeStep();
  85 }
  86
  87 bool EditCommandPtr::isInsertTextCommand() const
  88 {
  89     IF_IMPL_NULL_RETURN_ARG(false);
  90     return get()->isInsertTextCommand();
  91 }
  92
  93 bool EditCommandPtr::isTypingCommand() const
  94 {
  95     IF_IMPL_NULL_RETURN_ARG(false);
  96     return get()->isTypingCommand();
  97 }
  98
  99 void EditCommandPtr::apply() const
 100 {
 101     IF_IMPL_NULL_RETURN;
 102     get()->apply();
 103 }
 104
 105 void EditCommandPtr::unapply() const
 106 {
 107     IF_IMPL_NULL_RETURN;
 108     get()->unapply();
 109 }
 110
 111 void EditCommandPtr::reapply() const
 112 {
 113     IF_IMPL_NULL_RETURN;
 114     get()->reapply();
 115 }
 116
 117 EditAction EditCommandPtr::editingAction() const
 118 {
 119     IF_IMPL_NULL_RETURN_ARG(EditActionUnspecified);
 120     return get()->editingAction();
 121 }
 122
 123 DocumentImpl * const EditCommandPtr::document() const
 124 {
 125     IF_IMPL_NULL_RETURN_ARG(0);
 126     return get()->document();
 127 }
 128
 129 Selection EditCommandPtr::startingSelection() const
 130 {
 131     IF_IMPL_NULL_RETURN_ARG(Selection());
 132     return get()->startingSelection();
 133 }
 134
 135 Selection EditCommandPtr::endingSelection() const
 136 {
 137     IF_IMPL_NULL_RETURN_ARG(Selection());
 138     return get()->endingSelection();
 139 }
 140
 141 void EditCommandPtr::setStartingSelection(const Selection &s) const
 142 {
 143     IF_IMPL_NULL_RETURN;
 144     get()->setStartingSelection(s);
 145 }
 146
 147 void EditCommandPtr::setStartingSelection(const VisiblePosition &p) const
 148 {
 149     IF_IMPL_NULL_RETURN;
 150     get()->setStartingSelection(p);
 151 }
 152
 153 void EditCommandPtr::setStartingSelection(const Position &p, EAffinity affinity) const
 154 {
 155     IF_IMPL_NULL_RETURN;
 156     Selection s = Selection(p, affinity);
 157     get()->setStartingSelection(s);
 158 }
 159
 160 void EditCommandPtr::setEndingSelection(const Selection &s) const
 161 {
 162     IF_IMPL_NULL_RETURN;
 163     get()->setEndingSelection(s);
 164 }
 165
 166 void EditCommandPtr::setEndingSelection(const VisiblePosition &p) const
 167 {
 168     IF_IMPL_NULL_RETURN;
 169     get()->setEndingSelection(p);
 170 }
 171
 172 void EditCommandPtr::setEndingSelection(const Position &p, EAffinity affinity) const
 173 {
 174     IF_IMPL_NULL_RETURN;
 175     Selection s = Selection(p, affinity);
 176     get()->setEndingSelection(s);
 177 }
 178
 179 CSSMutableStyleDeclarationImpl *EditCommandPtr::typingStyle() const
 180 {
 181     IF_IMPL_NULL_RETURN_ARG(0);
 182     return get()->typingStyle();
 183 }
 184
 185 void EditCommandPtr::setTypingStyle(CSSMutableStyleDeclarationImpl *style) const
 186 {
 187     IF_IMPL_NULL_RETURN;
 188     get()->setTypingStyle(style);
 189 }
 190
 191 EditCommandPtr EditCommandPtr::parent() const
 192 {
 193     IF_IMPL_NULL_RETURN_ARG(0);
 194     return get()->parent();
 195 }
 196
 197 void EditCommandPtr::setParent(const EditCommandPtr &cmd) const
 198 {
 199     IF_IMPL_NULL_RETURN;
 200     get()->setParent(cmd.get());
 201 }
 202
 203 EditCommandPtr &EditCommandPtr::emptyCommand()
 204 {
 205     static EditCommandPtr m_emptyCommand;
 206     return m_emptyCommand;
 207 }
 208
 209 //------------------------------------------------------------------------------------------
 210 // EditCommand
 211
 212 EditCommand::EditCommand(DocumentImpl *document)
 213     : m_document(document), m_state(NotApplied), m_typingStyle(0), m_parent(0)
 214 {
 215     ASSERT(m_document);
 216     ASSERT(m_document->part());
 217     m_document->ref();
 218     m_startingSelection = m_document->part()->selection();
 219     m_endingSelection = m_startingSelection;
 220
 221     m_document->part()->setSelection(Selection(), false, true);
 222 }
 223
 224 EditCommand::~EditCommand()
 225 {
 226     ASSERT(m_document);
 227     m_document->deref();
 228     if (m_typingStyle)
 229         m_typingStyle->deref();
 230 }
 231
 232 void EditCommand::apply()
 233 {
 234     ASSERT(m_document);
 235     ASSERT(m_document->part());
 236     ASSERT(state() == NotApplied);
 237
 238     KHTMLPart *part = m_document->part();
 239
 240     ASSERT(part->selection().isNone());
 241
 242     doApply();
 243
 244     m_state = Applied;
 245
 246     // FIXME: Improve typing style.
 247     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
 248     if (!preservesTypingStyle())
 249         setTypingStyle(0);
 250
 251     if (!isCompositeStep()) {
 252         document()->updateLayout();
 253         EditCommandPtr cmd(this);
 254         part->appliedEditing(cmd);
 255     }
 256 }
 257
 258 void EditCommand::unapply()
 259 {
 260     ASSERT(m_document);
 261     ASSERT(m_document->part());
 262     ASSERT(state() == Applied);
 263
 264     bool topLevel = !isCompositeStep();
 265
 266     KHTMLPart *part = m_document->part();
 267
 268     if (topLevel) {
 269         part->setSelection(Selection(), false, true);
 270     }
 271     ASSERT(part->selection().isNone());
 272
 273     doUnapply();
 274
 275     m_state = NotApplied;
 276
 277     if (topLevel) {
 278         document()->updateLayout();
 279         EditCommandPtr cmd(this);
 280         part->unappliedEditing(cmd);
 281     }
 282 }
 283
 284 void EditCommand::reapply()
 285 {
 286     ASSERT(m_document);
 287     ASSERT(m_document->part());
 288     ASSERT(state() == NotApplied);
 289
 290     bool topLevel = !isCompositeStep();
 291
 292     KHTMLPart *part = m_document->part();
 293
 294     if (topLevel) {
 295         part->setSelection(Selection(), false, true);
 296     }
 297     ASSERT(part->selection().isNone());
 298
 299     doReapply();
 300
 301     m_state = Applied;
 302
 303     if (topLevel) {
 304         document()->updateLayout();
 305         EditCommandPtr cmd(this);
 306         part->reappliedEditing(cmd);
 307     }
 308 }
 309
 310 void EditCommand::doReapply()
 311 {
 312     doApply();
 313 }
 314
 315 EditAction EditCommand::editingAction() const
 316 {
 317     return EditActionUnspecified;
 318 }
 319
 320 void EditCommand::setStartingSelection(const Selection &s)
 321 {
 322     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 323         cmd->m_startingSelection = s;
 324 }
 325
 326 void EditCommand::setStartingSelection(const VisiblePosition &p)
 327 {
 328     Selection s = Selection(p);
 329     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 330         cmd->m_startingSelection = s;
 331 }
 332
 333 void EditCommand::setStartingSelection(const Position &p, EAffinity affinity)
 334 {
 335     Selection s = Selection(p, affinity);
 336     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 337         cmd->m_startingSelection = s;
 338 }
 339
 340 void EditCommand::setEndingSelection(const Selection &s)
 341 {
 342     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 343         cmd->m_endingSelection = s;
 344 }
 345
 346 void EditCommand::setEndingSelection(const VisiblePosition &p)
 347 {
 348     Selection s = Selection(p);
 349     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 350         cmd->m_endingSelection = s;
 351 }
 352
 353 void EditCommand::setEndingSelection(const Position &p, EAffinity affinity)
 354 {
 355     Selection s = Selection(p, affinity);
 356     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 357         cmd->m_endingSelection = s;
 358 }
 359
 360 void EditCommand::assignTypingStyle(CSSMutableStyleDeclarationImpl *style)
 361 {
 362     if (m_typingStyle == style)
 363         return;
 364
 365     CSSMutableStyleDeclarationImpl *old = m_typingStyle;
 366     m_typingStyle = style;
 367     if (m_typingStyle)
 368         m_typingStyle->ref();
 369     if (old)
 370         old->deref();
 371 }
 372
 373 void EditCommand::setTypingStyle(CSSMutableStyleDeclarationImpl *style)
 374 {
 375     // FIXME: Improve typing style.
 376     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
 377     for (EditCommand *cmd = this; cmd; cmd = cmd->m_parent)
 378         cmd->assignTypingStyle(style);
 379 }
 380
 381 bool EditCommand::preservesTypingStyle() const
 382 {
 383     return false;
 384 }
 385
 386 bool EditCommand::isInsertTextCommand() const
 387 {
 388     return false;
 389 }
 390
 391 bool EditCommand::isTypingCommand() const
 392 {
 393     return false;
 394 }
 395
 396 CSSMutableStyleDeclarationImpl *EditCommand::styleAtPosition(const Position &pos)
 397 {
 398     CSSComputedStyleDeclarationImpl *computedStyle = pos.computedStyle();
 399     computedStyle->ref();
 400     CSSMutableStyleDeclarationImpl *style = computedStyle->copyInheritableProperties();
 401     computedStyle->deref();
 402
 403     // FIXME: Improve typing style.
 404     // See this bug: <rdar://problem/3769899> Implementation of typing style needs improvement
 405     CSSMutableStyleDeclarationImpl *typingStyle = document()->part()->typingStyle();
 406     if (typingStyle)
 407         style->merge(typingStyle);
 408
 409     return style;
 410 }
 411
 412 } // namespace khtml