7796f7f7f4fe8331ed1182d40078a1042dbc0101
[WebKit-https.git] / 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