| 1 |
// Copyright 2006 The Closure Library Authors. All Rights Reserved. |
| 2 |
// |
| 3 |
// Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 |
// you may not use this file except in compliance with the License. |
| 5 |
// You may obtain a copy of the License at |
| 6 |
// |
| 7 |
// http://www.apache.org/licenses/LICENSE-2.0 |
| 8 |
// |
| 9 |
// Unless required by applicable law or agreed to in writing, software |
| 10 |
// distributed under the License is distributed on an "AS-IS" BASIS, |
| 11 |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 |
// See the License for the specific language governing permissions and |
| 13 |
// limitations under the License. |
| 14 |
|
| 15 |
/** |
| 16 |
* @fileoverview Functions to style text. |
| 17 |
* |
| 18 |
* @author [email protected] (Nick Santos) |
| 19 |
*/ |
| 20 |
|
| 21 |
goog.provide('goog.editor.plugins.BasicTextFormatter'); |
| 22 |
goog.provide('goog.editor.plugins.BasicTextFormatter.COMMAND'); |
| 23 |
|
| 24 |
goog.require('goog.array'); |
| 25 |
goog.require('goog.dom'); |
| 26 |
goog.require('goog.dom.NodeType'); |
| 27 |
goog.require('goog.dom.Range'); |
| 28 |
goog.require('goog.dom.TagName'); |
| 29 |
goog.require('goog.editor.BrowserFeature'); |
| 30 |
goog.require('goog.editor.Command'); |
| 31 |
goog.require('goog.editor.Link'); |
| 32 |
goog.require('goog.editor.Plugin'); |
| 33 |
goog.require('goog.editor.node'); |
| 34 |
goog.require('goog.editor.range'); |
| 35 |
goog.require('goog.editor.style'); |
| 36 |
goog.require('goog.iter'); |
| 37 |
goog.require('goog.iter.StopIteration'); |
| 38 |
goog.require('goog.log'); |
| 39 |
goog.require('goog.object'); |
| 40 |
goog.require('goog.string'); |
| 41 |
goog.require('goog.string.Unicode'); |
| 42 |
goog.require('goog.style'); |
| 43 |
goog.require('goog.ui.editor.messages'); |
| 44 |
goog.require('goog.userAgent'); |
| 45 |
|
| 46 |
|
| 47 |
|
| 48 |
/** |
| 49 |
* Functions to style text (e.g. underline, make bold, etc.) |
| 50 |
* @constructor |
| 51 |
* @extends {goog.editor.Plugin} |
| 52 |
*/ |
| 53 |
goog.editor.plugins.BasicTextFormatter = function() { |
| 54 |
goog.editor.Plugin.call(this); |
| 55 |
}; |
| 56 |
goog.inherits(goog.editor.plugins.BasicTextFormatter, goog.editor.Plugin); |
| 57 |
|
| 58 |
|
| 59 |
/** @override */ |
| 60 |
goog.editor.plugins.BasicTextFormatter.prototype.getTrogClassId = function() { |
| 61 |
return 'BTF'; |
| 62 |
}; |
| 63 |
|
| 64 |
|
| 65 |
/** |
| 66 |
* Logging object. |
| 67 |
* @type {goog.log.Logger} |
| 68 |
* @protected |
| 69 |
* @override |
| 70 |
*/ |
| 71 |
goog.editor.plugins.BasicTextFormatter.prototype.logger = |
| 72 |
goog.log.getLogger('goog.editor.plugins.BasicTextFormatter'); |
| 73 |
|
| 74 |
|
| 75 |
/** |
| 76 |
* Commands implemented by this plugin. |
| 77 |
* @enum {string} |
| 78 |
*/ |
| 79 |
goog.editor.plugins.BasicTextFormatter.COMMAND = { |
| 80 |
LINK: '+link', |
| 81 |
CREATE_LINK: '+createLink', |
| 82 |
FORMAT_BLOCK: '+formatBlock', |
| 83 |
INDENT: '+indent', |
| 84 |
OUTDENT: '+outdent', |
| 85 |
STRIKE_THROUGH: '+strikeThrough', |
| 86 |
HORIZONTAL_RULE: '+insertHorizontalRule', |
| 87 |
SUBSCRIPT: '+subscript', |
| 88 |
SUPERSCRIPT: '+superscript', |
| 89 |
UNDERLINE: '+underline', |
| 90 |
BOLD: '+bold', |
| 91 |
ITALIC: '+italic', |
| 92 |
FONT_SIZE: '+fontSize', |
| 93 |
FONT_FACE: '+fontName', |
| 94 |
FONT_COLOR: '+foreColor', |
| 95 |
BACKGROUND_COLOR: '+backColor', |
| 96 |
ORDERED_LIST: '+insertOrderedList', |
| 97 |
UNORDERED_LIST: '+insertUnorderedList', |
| 98 |
JUSTIFY_CENTER: '+justifyCenter', |
| 99 |
JUSTIFY_FULL: '+justifyFull', |
| 100 |
JUSTIFY_RIGHT: '+justifyRight', |
| 101 |
JUSTIFY_LEFT: '+justifyLeft' |
| 102 |
}; |
| 103 |
|
| 104 |
|
| 105 |
/** |
| 106 |
* Inverse map of execCommand strings to |
| 107 |
* {@link goog.editor.plugins.BasicTextFormatter.COMMAND} constants. Used to |
| 108 |
* determine whether a string corresponds to a command this plugin |
| 109 |
* handles in O(1) time. |
| 110 |
* @type {Object} |
| 111 |
* @private |
| 112 |
*/ |
| 113 |
goog.editor.plugins.BasicTextFormatter.SUPPORTED_COMMANDS_ = |
| 114 |
goog.object.transpose(goog.editor.plugins.BasicTextFormatter.COMMAND); |
| 115 |
|
| 116 |
|
| 117 |
/** |
| 118 |
* Whether the string corresponds to a command this plugin handles. |
| 119 |
* @param {string} command Command string to check. |
| 120 |
* @return {boolean} Whether the string corresponds to a command |
| 121 |
* this plugin handles. |
| 122 |
* @override |
| 123 |
*/ |
| 124 |
goog.editor.plugins.BasicTextFormatter.prototype.isSupportedCommand = function( |
| 125 |
command) { |
| 126 |
// TODO(user): restore this to simple check once table editing |
| 127 |
// is moved out into its own plugin |
| 128 |
return command in goog.editor.plugins.BasicTextFormatter.SUPPORTED_COMMANDS_; |
| 129 |
}; |
| 130 |
|
| 131 |
|
| 132 |
/** |
| 133 |
* Array of execCommand strings which should be silent. |
| 134 |
* @type {!Array<goog.editor.plugins.BasicTextFormatter.COMMAND>} |
| 135 |
* @private |
| 136 |
*/ |
| 137 |
goog.editor.plugins.BasicTextFormatter.SILENT_COMMANDS_ = |
| 138 |
[goog.editor.plugins.BasicTextFormatter.COMMAND.CREATE_LINK]; |
| 139 |
|
| 140 |
|
| 141 |
/** |
| 142 |
* Whether the string corresponds to a command that should be silent. |
| 143 |
* @override |
| 144 |
*/ |
| 145 |
goog.editor.plugins.BasicTextFormatter.prototype.isSilentCommand = function( |
| 146 |
command) { |
| 147 |
return goog.array.contains( |
| 148 |
goog.editor.plugins.BasicTextFormatter.SILENT_COMMANDS_, command); |
| 149 |
}; |
| 150 |
|
| 151 |
|
| 152 |
/** |
| 153 |
* @return {goog.dom.AbstractRange} The closure range object that wraps the |
| 154 |
* current user selection. |
| 155 |
* @private |
| 156 |
*/ |
| 157 |
goog.editor.plugins.BasicTextFormatter.prototype.getRange_ = function() { |
| 158 |
return this.getFieldObject().getRange(); |
| 159 |
}; |
| 160 |
|
| 161 |
|
| 162 |
/** |
| 163 |
* @return {!Document} The document object associated with the currently active |
| 164 |
* field. |
| 165 |
* @private |
| 166 |
*/ |
| 167 |
goog.editor.plugins.BasicTextFormatter.prototype.getDocument_ = function() { |
| 168 |
return this.getFieldDomHelper().getDocument(); |
| 169 |
}; |
| 170 |
|
| 171 |
|
| 172 |
/** |
| 173 |
* Execute a user-initiated command. |
| 174 |
* @param {string} command Command to execute. |
| 175 |
* @param {...*} var_args For color commands, this |
| 176 |
* should be the hex color (with the #). For FORMAT_BLOCK, this should be |
| 177 |
* the goog.editor.plugins.BasicTextFormatter.BLOCK_COMMAND. |
| 178 |
* It will be unused for other commands. |
| 179 |
* @return {Object|undefined} The result of the command. |
| 180 |
* @override |
| 181 |
*/ |
| 182 |
goog.editor.plugins.BasicTextFormatter.prototype.execCommandInternal = function( |
| 183 |
command, var_args) { |
| 184 |
var preserveDir, styleWithCss, needsFormatBlockDiv, hasDummySelection; |
| 185 |
var result; |
| 186 |
var opt_arg = arguments[1]; |
| 187 |
|
| 188 |
switch (command) { |
| 189 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.BACKGROUND_COLOR: |
| 190 |
// Don't bother for no color selected, color picker is resetting itself. |
| 191 |
if (!goog.isNull(opt_arg)) { |
| 192 |
if (goog.editor.BrowserFeature.EATS_EMPTY_BACKGROUND_COLOR) { |
| 193 |
this.applyBgColorManually_(opt_arg); |
| 194 |
} else if (goog.userAgent.OPERA) { |
| 195 |
// backColor will color the block level element instead of |
| 196 |
// the selected span of text in Opera. |
| 197 |
this.execCommandHelper_('hiliteColor', opt_arg); |
| 198 |
} else { |
| 199 |
this.execCommandHelper_(command, opt_arg); |
| 200 |
} |
| 201 |
} |
| 202 |
break; |
| 203 |
|
| 204 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.CREATE_LINK: |
| 205 |
result = this.createLink_(arguments[1], arguments[2], arguments[3]); |
| 206 |
break; |
| 207 |
|
| 208 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.LINK: |
| 209 |
result = this.toggleLink_(opt_arg); |
| 210 |
break; |
| 211 |
|
| 212 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_CENTER: |
| 213 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_FULL: |
| 214 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_RIGHT: |
| 215 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_LEFT: |
| 216 |
this.justify_(command); |
| 217 |
break; |
| 218 |
|
| 219 |
default: |
| 220 |
if (goog.userAgent.IE && |
| 221 |
command == |
| 222 |
goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK && |
| 223 |
opt_arg) { |
| 224 |
// IE requires that the argument be in the form of an opening |
| 225 |
// tag, like <h1>, including angle brackets. WebKit will accept |
| 226 |
// the arguemnt with or without brackets, and Firefox pre-3 supports |
| 227 |
// only a fixed subset of tags with brackets, and prefers without. |
| 228 |
// So we only add them IE only. |
| 229 |
opt_arg = '<' + opt_arg + '>'; |
| 230 |
} |
| 231 |
|
| 232 |
if (command == |
| 233 |
goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR && |
| 234 |
goog.isNull(opt_arg)) { |
| 235 |
// If we don't have a color, then FONT_COLOR is a no-op. |
| 236 |
break; |
| 237 |
} |
| 238 |
|
| 239 |
switch (command) { |
| 240 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.INDENT: |
| 241 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT: |
| 242 |
if (goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) { |
| 243 |
if (goog.userAgent.GECKO) { |
| 244 |
styleWithCss = true; |
| 245 |
} |
| 246 |
if (goog.userAgent.OPERA) { |
| 247 |
if (command == |
| 248 |
goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT) { |
| 249 |
// styleWithCSS actually sets negative margins on <blockquote> |
| 250 |
// to outdent them. If the command is enabled without |
| 251 |
// styleWithCSS flipped on, then the caret is in a blockquote so |
| 252 |
// styleWithCSS must not be used. But if the command is not |
| 253 |
// enabled, styleWithCSS should be used so that elements such as |
| 254 |
// a <div> with a margin-left style can still be outdented. |
| 255 |
// (Opera bug: CORE-21118) |
| 256 |
styleWithCss = |
| 257 |
!this.getDocument_().queryCommandEnabled('outdent'); |
| 258 |
} else { |
| 259 |
// Always use styleWithCSS for indenting. Otherwise, Opera will |
| 260 |
// make separate <blockquote>s around *each* indented line, |
| 261 |
// which adds big default <blockquote> margins between each |
| 262 |
// indented line. |
| 263 |
styleWithCss = true; |
| 264 |
} |
| 265 |
} |
| 266 |
} |
| 267 |
// Fall through. |
| 268 |
|
| 269 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.ORDERED_LIST: |
| 270 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.UNORDERED_LIST: |
| 271 |
if (goog.editor.BrowserFeature.LEAVES_P_WHEN_REMOVING_LISTS && |
| 272 |
this.queryCommandStateInternal_(this.getDocument_(), command)) { |
| 273 |
// IE leaves behind P tags when unapplying lists. |
| 274 |
// If we're not in P-mode, then we want divs |
| 275 |
// So, unlistify, then convert the Ps into divs. |
| 276 |
needsFormatBlockDiv = |
| 277 |
this.getFieldObject().queryCommandValue( |
| 278 |
goog.editor.Command.DEFAULT_TAG) != goog.dom.TagName.P; |
| 279 |
} else if (!goog.editor.BrowserFeature.CAN_LISTIFY_BR) { |
| 280 |
// IE doesn't convert BRed line breaks into separate list items. |
| 281 |
// So convert the BRs to divs, then do the listify. |
| 282 |
this.convertBreaksToDivs_(); |
| 283 |
} |
| 284 |
|
| 285 |
// This fix only works in Gecko. |
| 286 |
if (goog.userAgent.GECKO && |
| 287 |
goog.editor.BrowserFeature.FORGETS_FORMATTING_WHEN_LISTIFYING && |
| 288 |
!this.queryCommandValue(command)) { |
| 289 |
hasDummySelection |= this.beforeInsertListGecko_(); |
| 290 |
} |
| 291 |
// Fall through to preserveDir block |
| 292 |
|
| 293 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK: |
| 294 |
// Both FF & IE may lose directionality info. Save/restore it. |
| 295 |
// TODO(user): Does Safari also need this? |
| 296 |
// TODO (gmark, jparent): This isn't ideal because it uses a string |
| 297 |
// literal, so if the plugin name changes, it would break. We need a |
| 298 |
// better solution. See also other places in code that use |
| 299 |
// this.getPluginByClassId('Bidi'). |
| 300 |
preserveDir = !!this.getFieldObject().getPluginByClassId('Bidi'); |
| 301 |
break; |
| 302 |
|
| 303 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT: |
| 304 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT: |
| 305 |
if (goog.editor.BrowserFeature.NESTS_SUBSCRIPT_SUPERSCRIPT) { |
| 306 |
// This browser nests subscript and superscript when both are |
| 307 |
// applied, instead of canceling out the first when applying the |
| 308 |
// second. |
| 309 |
this.applySubscriptSuperscriptWorkarounds_(command); |
| 310 |
} |
| 311 |
break; |
| 312 |
|
| 313 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE: |
| 314 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD: |
| 315 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC: |
| 316 |
// If we are applying the formatting, then we want to have |
| 317 |
// styleWithCSS false so that we generate html tags (like <b>). If we |
| 318 |
// are unformatting something, we want to have styleWithCSS true so |
| 319 |
// that we can unformat both html tags and inline styling. |
| 320 |
// TODO(user): What about WebKit and Opera? |
| 321 |
styleWithCss = goog.userAgent.GECKO && |
| 322 |
goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && |
| 323 |
this.queryCommandValue(command); |
| 324 |
break; |
| 325 |
|
| 326 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR: |
| 327 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_FACE: |
| 328 |
// It is very expensive in FF (order of magnitude difference) to use |
| 329 |
// font tags instead of styled spans. Whenever possible, |
| 330 |
// force FF to use spans. |
| 331 |
// Font size is very expensive too, but FF always uses font tags, |
| 332 |
// regardless of which styleWithCSS value you use. |
| 333 |
styleWithCss = goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && |
| 334 |
goog.userAgent.GECKO; |
| 335 |
} |
| 336 |
|
| 337 |
/** |
| 338 |
* Cases where we just use the default execCommand (in addition |
| 339 |
* to the above fall-throughs) |
| 340 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.STRIKE_THROUGH: |
| 341 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.HORIZONTAL_RULE: |
| 342 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT: |
| 343 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT: |
| 344 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE: |
| 345 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD: |
| 346 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC: |
| 347 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_SIZE: |
| 348 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_FACE: |
| 349 |
*/ |
| 350 |
this.execCommandHelper_(command, opt_arg, preserveDir, !!styleWithCss); |
| 351 |
|
| 352 |
if (hasDummySelection) { |
| 353 |
this.getDocument_().execCommand('Delete', false, true); |
| 354 |
} |
| 355 |
|
| 356 |
if (needsFormatBlockDiv) { |
| 357 |
this.getDocument_().execCommand('FormatBlock', false, '<div>'); |
| 358 |
} |
| 359 |
} |
| 360 |
// FF loses focus, so we have to set the focus back to the document or the |
| 361 |
// user can't type after selecting from menu. In IE, focus is set correctly |
| 362 |
// and resetting it here messes it up. |
| 363 |
if (goog.userAgent.GECKO && !this.getFieldObject().inModalMode()) { |
| 364 |
this.focusField_(); |
| 365 |
} |
| 366 |
return result; |
| 367 |
}; |
| 368 |
|
| 369 |
|
| 370 |
/** |
| 371 |
* Focuses on the field. |
| 372 |
* @private |
| 373 |
*/ |
| 374 |
goog.editor.plugins.BasicTextFormatter.prototype.focusField_ = function() { |
| 375 |
this.getFieldDomHelper().getWindow().focus(); |
| 376 |
}; |
| 377 |
|
| 378 |
|
| 379 |
/** |
| 380 |
* Gets the command value. |
| 381 |
* @param {string} command The command value to get. |
| 382 |
* @return {string|boolean|null} The current value of the command in the given |
| 383 |
* selection. NOTE: This return type list is not documented in MSDN or MDC |
| 384 |
* and has been constructed from experience. Please update it |
| 385 |
* if necessary. |
| 386 |
* @override |
| 387 |
*/ |
| 388 |
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandValue = function( |
| 389 |
command) { |
| 390 |
var styleWithCss; |
| 391 |
switch (command) { |
| 392 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.LINK: |
| 393 |
return this.isNodeInState_(goog.dom.TagName.A); |
| 394 |
|
| 395 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_CENTER: |
| 396 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_FULL: |
| 397 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_RIGHT: |
| 398 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.JUSTIFY_LEFT: |
| 399 |
return this.isJustification_(command); |
| 400 |
|
| 401 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FORMAT_BLOCK: |
| 402 |
// TODO(nicksantos): See if we can use queryCommandValue here. |
| 403 |
return goog.editor.plugins.BasicTextFormatter.getSelectionBlockState_( |
| 404 |
this.getFieldObject().getRange()); |
| 405 |
|
| 406 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.INDENT: |
| 407 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.OUTDENT: |
| 408 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.HORIZONTAL_RULE: |
| 409 |
// TODO: See if there are reasonable results to return for |
| 410 |
// these commands. |
| 411 |
return false; |
| 412 |
|
| 413 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_SIZE: |
| 414 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_FACE: |
| 415 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.FONT_COLOR: |
| 416 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.BACKGROUND_COLOR: |
| 417 |
// We use queryCommandValue here since we don't just want to know if a |
| 418 |
// color/fontface/fontsize is applied, we want to know WHICH one it is. |
| 419 |
return this.queryCommandValueInternal_( |
| 420 |
this.getDocument_(), command, |
| 421 |
goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && |
| 422 |
goog.userAgent.GECKO); |
| 423 |
|
| 424 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE: |
| 425 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD: |
| 426 |
case goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC: |
| 427 |
styleWithCss = |
| 428 |
goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && goog.userAgent.GECKO; |
| 429 |
|
| 430 |
default: |
| 431 |
/** |
| 432 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.STRIKE_THROUGH |
| 433 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT |
| 434 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT |
| 435 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE |
| 436 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD |
| 437 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC |
| 438 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.ORDERED_LIST |
| 439 |
* goog.editor.plugins.BasicTextFormatter.COMMAND.UNORDERED_LIST |
| 440 |
*/ |
| 441 |
// This only works for commands that use the default execCommand |
| 442 |
return this.queryCommandStateInternal_( |
| 443 |
this.getDocument_(), command, styleWithCss); |
| 444 |
} |
| 445 |
}; |
| 446 |
|
| 447 |
|
| 448 |
/** |
| 449 |
* @override |
| 450 |
*/ |
| 451 |
goog.editor.plugins.BasicTextFormatter.prototype.prepareContentsHtml = function( |
| 452 |
html) { |
| 453 |
// If the browser collapses empty nodes and the field has only a script |
| 454 |
// tag in it, then it will collapse this node. Which will mean the user |
| 455 |
// can't click into it to edit it. |
| 456 |
if (goog.editor.BrowserFeature.COLLAPSES_EMPTY_NODES && |
| 457 |
html.match(/^\s*<script/i)) { |
| 458 |
html = ' ' + html; |
| 459 |
} |
| 460 |
|
| 461 |
if (goog.editor.BrowserFeature.CONVERT_TO_B_AND_I_TAGS) { |
| 462 |
// Some browsers (FF) can't undo strong/em in some cases, but can undo b/i! |
| 463 |
html = html.replace(/<(\/?)strong([^\w])/gi, '<$1b$2'); |
| 464 |
html = html.replace(/<(\/?)em([^\w])/gi, '<$1i$2'); |
| 465 |
} |
| 466 |
|
| 467 |
return html; |
| 468 |
}; |
| 469 |
|
| 470 |
|
| 471 |
/** |
| 472 |
* @override |
| 473 |
*/ |
| 474 |
goog.editor.plugins.BasicTextFormatter.prototype.cleanContentsDom = function( |
| 475 |
fieldCopy) { |
| 476 |
var images = goog.dom.getElementsByTagName(goog.dom.TagName.IMG, fieldCopy); |
| 477 |
for (var i = 0, image; image = images[i]; i++) { |
| 478 |
if (goog.editor.BrowserFeature.SHOWS_CUSTOM_ATTRS_IN_INNER_HTML) { |
| 479 |
// Only need to remove these attributes in IE because |
| 480 |
// Firefox and Safari don't show custom attributes in the innerHTML. |
| 481 |
image.removeAttribute('tabIndex'); |
| 482 |
image.removeAttribute('tabIndexSet'); |
| 483 |
goog.removeUid(image); |
| 484 |
|
| 485 |
// Declare oldTypeIndex for the compiler. The associated plugin may not be |
| 486 |
// included in the compiled bundle. |
| 487 |
/** @type {number} */ image.oldTabIndex; |
| 488 |
|
| 489 |
// oldTabIndex will only be set if |
| 490 |
// goog.editor.BrowserFeature.TABS_THROUGH_IMAGES is true and we're in |
| 491 |
// P-on-enter mode. |
| 492 |
if (image.oldTabIndex) { |
| 493 |
image.tabIndex = image.oldTabIndex; |
| 494 |
} |
| 495 |
} |
| 496 |
} |
| 497 |
}; |
| 498 |
|
| 499 |
|
| 500 |
/** |
| 501 |
* @override |
| 502 |
*/ |
| 503 |
goog.editor.plugins.BasicTextFormatter.prototype.cleanContentsHtml = function( |
| 504 |
html) { |
| 505 |
if (goog.editor.BrowserFeature.MOVES_STYLE_TO_HEAD) { |
| 506 |
// Safari creates a new <head> element for <style> tags, so prepend their |
| 507 |
// contents to the output. |
| 508 |
var heads = this.getFieldObject() |
| 509 |
.getEditableDomHelper() |
| 510 |
.getElementsByTagNameAndClass(goog.dom.TagName.HEAD); |
| 511 |
var stylesHtmlArr = []; |
| 512 |
|
| 513 |
// i starts at 1 so we don't copy in the original, legitimate <head>. |
| 514 |
var numHeads = heads.length; |
| 515 |
for (var i = 1; i < numHeads; ++i) { |
| 516 |
var styles = |
| 517 |
goog.dom.getElementsByTagName(goog.dom.TagName.STYLE, heads[i]); |
| 518 |
var numStyles = styles.length; |
| 519 |
for (var j = 0; j < numStyles; ++j) { |
| 520 |
stylesHtmlArr.push(styles[j].outerHTML); |
| 521 |
} |
| 522 |
} |
| 523 |
return stylesHtmlArr.join('') + html; |
| 524 |
} |
| 525 |
|
| 526 |
return html; |
| 527 |
}; |
| 528 |
|
| 529 |
|
| 530 |
/** |
| 531 |
* @override |
| 532 |
*/ |
| 533 |
goog.editor.plugins.BasicTextFormatter.prototype.handleKeyboardShortcut = |
| 534 |
function(e, key, isModifierPressed) { |
| 535 |
if (!isModifierPressed) { |
| 536 |
return false; |
| 537 |
} |
| 538 |
var command; |
| 539 |
switch (key) { |
| 540 |
case 'b': // Ctrl+B |
| 541 |
command = goog.editor.plugins.BasicTextFormatter.COMMAND.BOLD; |
| 542 |
break; |
| 543 |
case 'i': // Ctrl+I |
| 544 |
command = goog.editor.plugins.BasicTextFormatter.COMMAND.ITALIC; |
| 545 |
break; |
| 546 |
case 'u': // Ctrl+U |
| 547 |
command = goog.editor.plugins.BasicTextFormatter.COMMAND.UNDERLINE; |
| 548 |
break; |
| 549 |
case 's': // Ctrl+S |
| 550 |
// TODO(user): This doesn't belong in here. Clients should handle |
| 551 |
// this themselves. |
| 552 |
// Catching control + s prevents the annoying browser save dialog |
| 553 |
// from appearing. |
| 554 |
return true; |
| 555 |
} |
| 556 |
|
| 557 |
if (command) { |
| 558 |
this.getFieldObject().execCommand(command); |
| 559 |
return true; |
| 560 |
} |
| 561 |
|
| 562 |
return false; |
| 563 |
}; |
| 564 |
|
| 565 |
|
| 566 |
// Helpers for execCommand |
| 567 |
|
| 568 |
|
| 569 |
/** |
| 570 |
* Regular expression to match BRs in HTML. Saves the BRs' attributes in $1 for |
| 571 |
* use with replace(). In non-IE browsers, does not match BRs adjacent to an |
| 572 |
* opening or closing DIV or P tag, since nonrendered BR elements can occur at |
| 573 |
* the end of block level containers in those browsers' editors. |
| 574 |
* @type {RegExp} |
| 575 |
* @private |
| 576 |
*/ |
| 577 |
goog.editor.plugins.BasicTextFormatter.BR_REGEXP_ = goog.userAgent.IE ? |
| 578 |
/<br([^\/>]*)\/?>/gi : |
| 579 |
/<br([^\/>]*)\/?>(?!<\/(div|p)>)/gi; |
| 580 |
|
| 581 |
|
| 582 |
/** |
| 583 |
* Convert BRs in the selection to divs. |
| 584 |
* This is only intended to be used in IE and Opera. |
| 585 |
* @return {boolean} Whether any BR's were converted. |
| 586 |
* @private |
| 587 |
*/ |
| 588 |
goog.editor.plugins.BasicTextFormatter.prototype.convertBreaksToDivs_ = |
| 589 |
function() { |
| 590 |
if (!goog.userAgent.IE && !goog.userAgent.OPERA) { |
| 591 |
// This function is only supported on IE and Opera. |
| 592 |
return false; |
| 593 |
} |
| 594 |
var range = this.getRange_(); |
| 595 |
var parent = range.getContainerElement(); |
| 596 |
var doc = this.getDocument_(); |
| 597 |
var dom = this.getFieldDomHelper(); |
| 598 |
|
| 599 |
goog.editor.plugins.BasicTextFormatter.BR_REGEXP_.lastIndex = 0; |
| 600 |
// Only mess with the HTML/selection if it contains a BR. |
| 601 |
if (goog.editor.plugins.BasicTextFormatter.BR_REGEXP_.test( |
| 602 |
parent.innerHTML)) { |
| 603 |
// Insert temporary markers to remember the selection. |
| 604 |
var savedRange = range.saveUsingCarets(); |
| 605 |
|
| 606 |
if (parent.tagName == goog.dom.TagName.P) { |
| 607 |
// Can't append paragraphs to paragraph tags. Throws an exception in IE. |
| 608 |
goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_( |
| 609 |
parent, true); |
| 610 |
} else { |
| 611 |
// Used to do: |
| 612 |
// IE: <div>foo<br>bar</div> --> <div>foo<p id="temp_br">bar</div> |
| 613 |
// Opera: <div>foo<br>bar</div> --> <div>foo<p class="temp_br">bar</div> |
| 614 |
// To fix bug 1939883, now does for both: |
| 615 |
// <div>foo<br>bar</div> --> <div>foo<p trtempbr="temp_br">bar</div> |
| 616 |
// TODO(user): Confirm if there's any way to skip this |
| 617 |
// intermediate step of converting br's to p's before converting those to |
| 618 |
// div's. The reason may be hidden in CLs 5332866 and 8530601. |
| 619 |
var attribute = 'trtempbr'; |
| 620 |
var value = 'temp_br'; |
| 621 |
var newHtml = parent.innerHTML.replace( |
| 622 |
goog.editor.plugins.BasicTextFormatter.BR_REGEXP_, |
| 623 |
'<p$1 ' + attribute + '="' + value + '">'); |
| 624 |
goog.editor.node.replaceInnerHtml(parent, newHtml); |
| 625 |
|
| 626 |
var paragraphs = goog.array.toArray( |
| 627 |
goog.dom.getElementsByTagName(goog.dom.TagName.P, parent)); |
| 628 |
goog.iter.forEach(paragraphs, function(paragraph) { |
| 629 |
if (paragraph.getAttribute(attribute) == value) { |
| 630 |
paragraph.removeAttribute(attribute); |
| 631 |
if (goog.string.isBreakingWhitespace( |
| 632 |
goog.dom.getTextContent(paragraph))) { |
| 633 |
// Prevent the empty blocks from collapsing. |
| 634 |
// A <BR> is preferable because it doesn't result in any text being |
| 635 |
// added to the "blank" line. In IE, however, it is possible to |
| 636 |
// place the caret after the <br>, which effectively creates a |
| 637 |
// visible line break. Because of this, we have to resort to using a |
| 638 |
// in IE. |
| 639 |
var child = goog.userAgent.IE ? |
| 640 |
doc.createTextNode(goog.string.Unicode.NBSP) : |
| 641 |
dom.createElement(goog.dom.TagName.BR); |
| 642 |
paragraph.appendChild(child); |
| 643 |
} |
| 644 |
goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_( |
| 645 |
paragraph); |
| 646 |
} |
| 647 |
}); |
| 648 |
} |
| 649 |
|
| 650 |
// Select the previously selected text so we only listify |
| 651 |
// the selected portion and maintain the user's selection. |
| 652 |
savedRange.restore(); |
| 653 |
return true; |
| 654 |
} |
| 655 |
|
| 656 |
return false; |
| 657 |
}; |
| 658 |
|
| 659 |
|
| 660 |
/** |
| 661 |
* Convert the given paragraph to being a div. This clobbers the |
| 662 |
* passed-in node! |
| 663 |
* This is only intended to be used in IE and Opera. |
| 664 |
* @param {Node} paragraph Paragragh to convert to a div. |
| 665 |
* @param {boolean=} opt_convertBrs If true, also convert BRs to divs. |
| 666 |
* @private |
| 667 |
*/ |
| 668 |
goog.editor.plugins.BasicTextFormatter.convertParagraphToDiv_ = function( |
| 669 |
paragraph, opt_convertBrs) { |
| 670 |
if (!goog.userAgent.IE && !goog.userAgent.OPERA) { |
| 671 |
// This function is only supported on IE and Opera. |
| 672 |
return; |
| 673 |
} |
| 674 |
var outerHTML = paragraph.outerHTML.replace(/<(\/?)p/gi, '<$1div'); |
| 675 |
if (opt_convertBrs) { |
| 676 |
// IE fills in the closing div tag if it's missing! |
| 677 |
outerHTML = outerHTML.replace( |
| 678 |
goog.editor.plugins.BasicTextFormatter.BR_REGEXP_, '</div><div$1>'); |
| 679 |
} |
| 680 |
if (goog.userAgent.OPERA && !/<\/div>$/i.test(outerHTML)) { |
| 681 |
// Opera doesn't automatically add the closing tag, so add it if needed. |
| 682 |
outerHTML += '</div>'; |
| 683 |
} |
| 684 |
paragraph.outerHTML = outerHTML; |
| 685 |
}; |
| 686 |
|
| 687 |
|
| 688 |
/** |
| 689 |
* If this is a goog.editor.plugins.BasicTextFormatter.COMMAND, |
| 690 |
* convert it to something that we can pass into execCommand, |
| 691 |
* queryCommandState, etc. |
| 692 |
* |
| 693 |
* TODO(user): Consider doing away with the + and converter completely. |
| 694 |
* |
| 695 |
* @param {goog.editor.plugins.BasicTextFormatter.COMMAND|string} |
| 696 |
* command A command key. |
| 697 |
* @return {string} The equivalent execCommand command. |
| 698 |
* @private |
| 699 |
*/ |
| 700 |
goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_ = function( |
| 701 |
command) { |
| 702 |
return command.indexOf('+') == 0 ? command.substring(1) : command; |
| 703 |
}; |
| 704 |
|
| 705 |
|
| 706 |
/** |
| 707 |
* Justify the text in the selection. |
| 708 |
* @param {string} command The type of justification to perform. |
| 709 |
* @private |
| 710 |
*/ |
| 711 |
goog.editor.plugins.BasicTextFormatter.prototype.justify_ = function(command) { |
| 712 |
this.execCommandHelper_(command, null, false, true); |
| 713 |
// Firefox cannot justify divs. In fact, justifying divs results in removing |
| 714 |
// the divs and replacing them with brs. So "<div>foo</div><div>bar</div>" |
| 715 |
// becomes "foo<br>bar" after alignment is applied. However, if you justify |
| 716 |
// again, then you get "<div style='text-align: right'>foo<br>bar</div>", |
| 717 |
// which at least looks visually correct. Since justification is (normally) |
| 718 |
// idempotent, it isn't a problem when the selection does not contain divs to |
| 719 |
// apply justifcation again. |
| 720 |
if (goog.userAgent.GECKO) { |
| 721 |
this.execCommandHelper_(command, null, false, true); |
| 722 |
} |
| 723 |
|
| 724 |
// Convert all block elements in the selection to use CSS text-align |
| 725 |
// instead of the align property. This works better because the align |
| 726 |
// property is overridden by the CSS text-align property. |
| 727 |
// |
| 728 |
// Only for browsers that can't handle this by the styleWithCSS execCommand, |
| 729 |
// which allows us to specify if we should insert align or text-align. |
| 730 |
// TODO(user): What about WebKit or Opera? |
| 731 |
if (!(goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS && |
| 732 |
goog.userAgent.GECKO)) { |
| 733 |
goog.iter.forEach( |
| 734 |
this.getFieldObject().getRange(), |
| 735 |
goog.editor.plugins.BasicTextFormatter.convertContainerToTextAlign_); |
| 736 |
} |
| 737 |
}; |
| 738 |
|
| 739 |
|
| 740 |
/** |
| 741 |
* Converts the block element containing the given node to use CSS text-align |
| 742 |
* instead of the align property. |
| 743 |
* @param {Node} node The node to convert the container of. |
| 744 |
* @private |
| 745 |
*/ |
| 746 |
goog.editor.plugins.BasicTextFormatter.convertContainerToTextAlign_ = function( |
| 747 |
node) { |
| 748 |
var container = goog.editor.style.getContainer(node); |
| 749 |
|
| 750 |
// TODO(user): Fix this so that it doesn't screw up tables. |
| 751 |
if (container.align) { |
| 752 |
container.style.textAlign = container.align; |
| 753 |
container.removeAttribute('align'); |
| 754 |
} |
| 755 |
}; |
| 756 |
|
| 757 |
|
| 758 |
/** |
| 759 |
* Perform an execCommand on the active document. |
| 760 |
* @param {string} command The command to execute. |
| 761 |
* @param {string|number|boolean|null=} opt_value Optional value. |
| 762 |
* @param {boolean=} opt_preserveDir Set true to make sure that command does not |
| 763 |
* change directionality of the selected text (works only if all selected |
| 764 |
* text has the same directionality, otherwise ignored). Should not be true |
| 765 |
* if bidi plugin is not loaded. |
| 766 |
* @param {boolean=} opt_styleWithCss Set to true to ask the browser to use CSS |
| 767 |
* to perform the execCommand. |
| 768 |
* @private |
| 769 |
*/ |
| 770 |
goog.editor.plugins.BasicTextFormatter.prototype.execCommandHelper_ = function( |
| 771 |
command, opt_value, opt_preserveDir, opt_styleWithCss) { |
| 772 |
// There is a bug in FF: some commands do not preserve attributes of the |
| 773 |
// block-level elements they replace. |
| 774 |
// This (among the rest) leads to loss of directionality information. |
| 775 |
// For now we use a hack (when opt_preserveDir==true) to avoid this |
| 776 |
// directionality problem in the simplest cases. |
| 777 |
// Known affected commands: formatBlock, insertOrderedList, |
| 778 |
// insertUnorderedList, indent, outdent. |
| 779 |
// A similar problem occurs in IE when insertOrderedList or |
| 780 |
// insertUnorderedList remove existing list. |
| 781 |
var dir = null; |
| 782 |
if (opt_preserveDir) { |
| 783 |
dir = this.getFieldObject().queryCommandValue(goog.editor.Command.DIR_RTL) ? |
| 784 |
'rtl' : |
| 785 |
this.getFieldObject().queryCommandValue(goog.editor.Command.DIR_LTR) ? |
| 786 |
'ltr' : |
| 787 |
null; |
| 788 |
} |
| 789 |
|
| 790 |
command = |
| 791 |
goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_(command); |
| 792 |
|
| 793 |
var endDiv, nbsp; |
| 794 |
if (goog.userAgent.IE) { |
| 795 |
var ret = this.applyExecCommandIEFixes_(command); |
| 796 |
endDiv = ret[0]; |
| 797 |
nbsp = ret[1]; |
| 798 |
} |
| 799 |
|
| 800 |
if (goog.userAgent.WEBKIT) { |
| 801 |
endDiv = this.applyExecCommandSafariFixes_(command); |
| 802 |
} |
| 803 |
|
| 804 |
if (goog.userAgent.GECKO) { |
| 805 |
this.applyExecCommandGeckoFixes_(command); |
| 806 |
} |
| 807 |
|
| 808 |
if (goog.editor.BrowserFeature.DOESNT_OVERRIDE_FONT_SIZE_IN_STYLE_ATTR && |
| 809 |
command.toLowerCase() == 'fontsize') { |
| 810 |
this.removeFontSizeFromStyleAttrs_(); |
| 811 |
} |
| 812 |
|
| 813 |
var doc = this.getDocument_(); |
| 814 |
if (opt_styleWithCss && goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) { |
| 815 |
doc.execCommand('styleWithCSS', false, true); |
| 816 |
if (goog.userAgent.OPERA) { |
| 817 |
this.invalidateInlineCss_(); |
| 818 |
} |
| 819 |
} |
| 820 |
|
| 821 |
doc.execCommand(command, false, opt_value); |
| 822 |
if (opt_styleWithCss && goog.editor.BrowserFeature.HAS_STYLE_WITH_CSS) { |
| 823 |
// If we enabled styleWithCSS, turn it back off. |
| 824 |
doc.execCommand('styleWithCSS', false, false); |
| 825 |
} |
| 826 |
|
| 827 |
if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher('526') && |
| 828 |
command.toLowerCase() == 'formatblock' && opt_value && |
| 829 |
/^[<]?h\d[>]?$/i.test(opt_value)) { |
| 830 |
this.cleanUpSafariHeadings_(); |
| 831 |
} |
| 832 |
|
| 833 |
if (/insert(un)?orderedlist/i.test(command)) { |
| 834 |
// NOTE(user): This doesn't check queryCommandState because it seems to |
| 835 |
// lie. Also, this runs for insertunorderedlist so that the the list |
| 836 |
// isn't made up of an <ul> for each <li> - even though it looks the same, |
| 837 |
// the markup is disgusting. |
| 838 |
if (goog.userAgent.WEBKIT && !goog.userAgent.isVersionOrHigher(534)) { |
| 839 |
this.fixSafariLists_(); |
| 840 |
} |
| 841 |
if (goog.userAgent.IE) { |
| 842 |
this.fixIELists_(); |
| 843 |
|
| 844 |
if (nbsp) { |
| 845 |
// Remove the text node, if applicable. Do not try to instead clobber |
| 846 |
// the contents of the text node if it was added, or the same invalid |
| 847 |
// node thing as above will happen. The error won't happen here, it |
| 848 |
// will happen after you hit enter and then do anything that loops |
| 849 |
// through the dom and tries to read that node. |
| 850 |
goog.dom.removeNode(nbsp); |
| 851 |
} |
| 852 |
} |
| 853 |
} |
| 854 |
|
| 855 |
if (endDiv) { |
| 856 |
// Remove the dummy div. |
| 857 |
goog.dom.removeNode(endDiv); |
| 858 |
} |
| 859 |
|
| 860 |
// Restore directionality if required and only when unambigous (dir!=null). |
| 861 |
if (dir) { |
| 862 |
this.getFieldObject().execCommand(dir); |
| 863 |
} |
| 864 |
}; |
| 865 |
|
| 866 |
|
| 867 |
/** |
| 868 |
* Applies a background color to a selection when the browser can't do the job. |
| 869 |
* |
| 870 |
* NOTE(nicksantos): If you think this is hacky, you should try applying |
| 871 |
* background color in Opera. It made me cry. |
| 872 |
* |
| 873 |
* @param {string} bgColor backgroundColor from .formatText to .execCommand. |
| 874 |
* @private |
| 875 |
*/ |
| 876 |
goog.editor.plugins.BasicTextFormatter.prototype.applyBgColorManually_ = |
| 877 |
function(bgColor) { |
| 878 |
var needsSpaceInTextNode = goog.userAgent.GECKO; |
| 879 |
var range = this.getFieldObject().getRange(); |
| 880 |
var textNode; |
| 881 |
var parentTag; |
| 882 |
if (range && range.isCollapsed()) { |
| 883 |
// Hack to handle Firefox bug: |
| 884 |
// https://bugzilla.mozilla.org/show_bug.cgi?id=279330 |
| 885 |
// execCommand hiliteColor in Firefox on collapsed selection creates |
| 886 |
// a font tag onkeypress |
| 887 |
textNode = this.getFieldDomHelper().createTextNode( |
| 888 |
needsSpaceInTextNode ? ' ' : ''); |
| 889 |
|
| 890 |
var containerNode = range.getStartNode(); |
| 891 |
// Check if we're inside a tag that contains the cursor and nothing else; |
| 892 |
// if we are, don't create a dummySpan. Just use this containing tag to |
| 893 |
// hide the 1-space selection. |
| 894 |
// If the user sets a background color on a collapsed selection, then sets |
| 895 |
// another one immediately, we get a span tag with a single empty TextNode. |
| 896 |
// If the user sets a background color, types, then backspaces, we get a |
| 897 |
// span tag with nothing inside it (container is the span). |
| 898 |
parentTag = containerNode.nodeType == goog.dom.NodeType.ELEMENT ? |
| 899 |
containerNode : |
| 900 |
containerNode.parentNode; |
| 901 |
|
| 902 |
if (parentTag.innerHTML == '') { |
| 903 |
// There's an Element to work with |
| 904 |
// make the space character invisible using a CSS indent hack |
| 905 |
parentTag.style.textIndent = '-10000px'; |
| 906 |
parentTag.appendChild(textNode); |
| 907 |
} else { |
| 908 |
// No Element to work with; make one |
| 909 |
// create a span with a space character inside |
| 910 |
// make the space character invisible using a CSS indent hack |
| 911 |
parentTag = this.getFieldDomHelper().createDom( |
| 912 |
goog.dom.TagName.SPAN, {'style': 'text-indent:-10000px'}, textNode); |
| 913 |
range.replaceContentsWithNode(parentTag); |
| 914 |
} |
| 915 |
goog.dom.Range.createFromNodeContents(textNode).select(); |
| 916 |
} |
| 917 |
|
| 918 |
this.execCommandHelper_('hiliteColor', bgColor, false, true); |
| 919 |
|
| 920 |
if (textNode) { |
| 921 |
// eliminate the space if necessary. |
| 922 |
if (needsSpaceInTextNode) { |
| 923 |
textNode.data = ''; |
| 924 |
} |
| 925 |
|
| 926 |
// eliminate the hack. |
| 927 |
parentTag.style.textIndent = ''; |
| 928 |
// execCommand modified our span so we leave it in place. |
| 929 |
} |
| 930 |
}; |
| 931 |
|
| 932 |
|
| 933 |
/** |
| 934 |
* Toggle link for the current selection: |
| 935 |
* If selection contains a link, unlink it, return null. |
| 936 |
* Otherwise, make selection into a link, return the link. |
| 937 |
* @param {string=} opt_target Target for the link. |
| 938 |
* @return {goog.editor.Link?} The resulting link, or null if a link was |
| 939 |
* removed. |
| 940 |
* @private |
| 941 |
*/ |
| 942 |
goog.editor.plugins.BasicTextFormatter.prototype.toggleLink_ = function( |
| 943 |
opt_target) { |
| 944 |
if (!this.getFieldObject().isSelectionEditable()) { |
| 945 |
this.focusField_(); |
| 946 |
} |
| 947 |
|
| 948 |
var range = this.getRange_(); |
| 949 |
// Since we wrap images in links, its possible that the user selected an |
| 950 |
// image and clicked link, in which case we want to actually use the |
| 951 |
// image as the selection. |
| 952 |
var parent = range && range.getContainerElement(); |
| 953 |
var link = /** @type {Element} */ ( |
| 954 |
goog.dom.getAncestorByTagNameAndClass(parent, goog.dom.TagName.A)); |
| 955 |
if (link && goog.editor.node.isEditable(link)) { |
| 956 |
goog.dom.flattenElement(link); |
| 957 |
} else { |
| 958 |
var editableLink = this.createLink_(range, '/', opt_target); |
| 959 |
if (editableLink) { |
| 960 |
if (!this.getFieldObject().execCommand( |
| 961 |
goog.editor.Command.MODAL_LINK_EDITOR, editableLink)) { |
| 962 |
var url = this.getFieldObject().getAppWindow().prompt( |
| 963 |
goog.ui.editor.messages.MSG_LINK_TO, 'http://'); |
| 964 |
if (url) { |
| 965 |
editableLink.setTextAndUrl(editableLink.getCurrentText() || url, url); |
| 966 |
editableLink.placeCursorRightOf(); |
| 967 |
} else { |
| 968 |
var savedRange = goog.editor.range.saveUsingNormalizedCarets( |
| 969 |
goog.dom.Range.createFromNodeContents(editableLink.getAnchor())); |
| 970 |
editableLink.removeLink(); |
| 971 |
savedRange.restore().select(); |
| 972 |
return null; |
| 973 |
} |
| 974 |
} |
| 975 |
return editableLink; |
| 976 |
} |
| 977 |
} |
| 978 |
return null; |
| 979 |
}; |
| 980 |
|
| 981 |
|
| 982 |
/** |
| 983 |
* Create a link out of the current selection. If nothing is selected, insert |
| 984 |
* a new link. Otherwise, enclose the selection in a link. |
| 985 |
* @param {goog.dom.AbstractRange} range The closure range object for the |
| 986 |
* current selection. |
| 987 |
* @param {string} url The url to link to. |
| 988 |
* @param {string=} opt_target Target for the link. |
| 989 |
* @return {goog.editor.Link?} The newly created link, or null if the link |
| 990 |
* couldn't be created. |
| 991 |
* @private |
| 992 |
*/ |
| 993 |
goog.editor.plugins.BasicTextFormatter.prototype.createLink_ = function( |
| 994 |
range, url, opt_target) { |
| 995 |
var anchor = null; |
| 996 |
var anchors = []; |
| 997 |
var parent = range && range.getContainerElement(); |
| 998 |
// We do not yet support creating links around images. Instead of throwing |
| 999 |
// lots of js errors, just fail silently. |
| 1000 |
// TODO(user): Add support for linking images. |
| 1001 |
if (parent && parent.tagName == goog.dom.TagName.IMG) { |
| 1002 |
return null; |
| 1003 |
} |
| 1004 |
// If range is not present, the editable field doesn't have focus, abort |
| 1005 |
// creating a link. |
| 1006 |
if (!range) { |
| 1007 |
return null; |
| 1008 |
} |
| 1009 |
|
| 1010 |
if (range.isCollapsed()) { |
| 1011 |
var textRange = range.getTextRange(0).getBrowserRangeObject(); |
| 1012 |
if (goog.editor.BrowserFeature.HAS_W3C_RANGES) { |
| 1013 |
anchor = this.getFieldDomHelper().createElement(goog.dom.TagName.A); |
| 1014 |
textRange.insertNode(anchor); |
| 1015 |
} else if (goog.editor.BrowserFeature.HAS_IE_RANGES) { |
| 1016 |
// TODO: Use goog.dom.AbstractRange's surroundContents |
| 1017 |
textRange.pasteHTML("<a id='newLink'></a>"); |
| 1018 |
anchor = this.getFieldDomHelper().getElement('newLink'); |
| 1019 |
anchor.removeAttribute('id'); |
| 1020 |
} |
| 1021 |
} else { |
| 1022 |
// Create a unique identifier for the link so we can retrieve it later. |
| 1023 |
// execCommand doesn't return the link to us, and we need a way to find |
| 1024 |
// the newly created link in the dom, and the url is the only property |
| 1025 |
// we have control over, so we set that to be unique and then find it. |
| 1026 |
var uniqueId = goog.string.createUniqueString(); |
| 1027 |
this.execCommandHelper_('CreateLink', uniqueId); |
| 1028 |
var setHrefAndLink = function(element, index, arr) { |
| 1029 |
// We can't do straight comparison since the href can contain the |
| 1030 |
// absolute url. |
| 1031 |
if (goog.string.endsWith(element.href, uniqueId)) { |
| 1032 |
anchors.push(element); |
| 1033 |
} |
| 1034 |
}; |
| 1035 |
|
| 1036 |
goog.array.forEach( |
| 1037 |
goog.dom.getElementsByTagName( |
| 1038 |
goog.dom.TagName.A, |
| 1039 |
/** @type {!Element} */ (this.getFieldObject().getElement())), |
| 1040 |
setHrefAndLink); |
| 1041 |
if (anchors.length) { |
| 1042 |
anchor = anchors.pop(); |
| 1043 |
} |
| 1044 |
var isLikelyUrl = function(a, i, anchors) { |
| 1045 |
return goog.editor.Link.isLikelyUrl(goog.dom.getRawTextContent(a)); |
| 1046 |
}; |
| 1047 |
if (anchors.length && goog.array.every(anchors, isLikelyUrl)) { |
| 1048 |
for (var i = 0, a; a = anchors[i]; i++) { |
| 1049 |
goog.editor.Link.createNewLinkFromText(a, opt_target); |
| 1050 |
} |
| 1051 |
anchors = null; |
| 1052 |
} |
| 1053 |
} |
| 1054 |
|
| 1055 |
return goog.editor.Link.createNewLink( |
| 1056 |
/** @type {HTMLAnchorElement} */ (anchor), url, opt_target, anchors); |
| 1057 |
}; |
| 1058 |
|
| 1059 |
|
| 1060 |
//--------------------------------------------------------------------- |
| 1061 |
// browser fixes |
| 1062 |
|
| 1063 |
|
| 1064 |
/** |
| 1065 |
* The following execCommands are "broken" in some way - in IE they allow |
| 1066 |
* the nodes outside the contentEditable region to get modified (see |
| 1067 |
* execCommand below for more details). |
| 1068 |
* @const |
| 1069 |
* @private |
| 1070 |
*/ |
| 1071 |
goog.editor.plugins.BasicTextFormatter.brokenExecCommandsIE_ = { |
| 1072 |
'indent': 1, |
| 1073 |
'outdent': 1, |
| 1074 |
'insertOrderedList': 1, |
| 1075 |
'insertUnorderedList': 1, |
| 1076 |
'justifyCenter': 1, |
| 1077 |
'justifyFull': 1, |
| 1078 |
'justifyRight': 1, |
| 1079 |
'justifyLeft': 1, |
| 1080 |
'ltr': 1, |
| 1081 |
'rtl': 1 |
| 1082 |
}; |
| 1083 |
|
| 1084 |
|
| 1085 |
/** |
| 1086 |
* When the following commands are executed while the selection is |
| 1087 |
* inside a blockquote, they hose the blockquote tag in weird and |
| 1088 |
* unintuitive ways. |
| 1089 |
* @const |
| 1090 |
* @private |
| 1091 |
*/ |
| 1092 |
goog.editor.plugins.BasicTextFormatter.blockquoteHatingCommandsIE_ = { |
| 1093 |
'insertOrderedList': 1, |
| 1094 |
'insertUnorderedList': 1 |
| 1095 |
}; |
| 1096 |
|
| 1097 |
|
| 1098 |
/** |
| 1099 |
* Makes sure that superscript is removed before applying subscript, and vice |
| 1100 |
* versa. Fixes {@link http://buganizer/issue?id=1173491} . |
| 1101 |
* @param {goog.editor.plugins.BasicTextFormatter.COMMAND} command The command |
| 1102 |
* being applied, either SUBSCRIPT or SUPERSCRIPT. |
| 1103 |
* @private |
| 1104 |
*/ |
| 1105 |
goog.editor.plugins.BasicTextFormatter.prototype |
| 1106 |
.applySubscriptSuperscriptWorkarounds_ = function(command) { |
| 1107 |
if (!this.queryCommandValue(command)) { |
| 1108 |
// The current selection doesn't currently have the requested |
| 1109 |
// command, so we are applying it as opposed to removing it. |
| 1110 |
// (Note that queryCommandValue() will only return true if the |
| 1111 |
// command is applied to the whole selection, not just part of it. |
| 1112 |
// In this case it is fine because only if the whole selection has |
| 1113 |
// the command applied will we be removing it and thus skipping the |
| 1114 |
// removal of the opposite command.) |
| 1115 |
var oppositeCommand = |
| 1116 |
(command == goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT ? |
| 1117 |
goog.editor.plugins.BasicTextFormatter.COMMAND.SUPERSCRIPT : |
| 1118 |
goog.editor.plugins.BasicTextFormatter.COMMAND.SUBSCRIPT); |
| 1119 |
var oppositeExecCommand = |
| 1120 |
goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_( |
| 1121 |
oppositeCommand); |
| 1122 |
// Executing the opposite command on a selection that already has it |
| 1123 |
// applied will cancel it out. But if the selection only has the |
| 1124 |
// opposite command applied to a part of it, the browser will |
| 1125 |
// normalize the selection to have the opposite command applied on |
| 1126 |
// the whole of it. |
| 1127 |
if (!this.queryCommandValue(oppositeCommand)) { |
| 1128 |
// The selection doesn't have the opposite command applied to the |
| 1129 |
// whole of it, so let's exec the opposite command to normalize |
| 1130 |
// the selection. |
| 1131 |
// Note: since we know both subscript and superscript commands |
| 1132 |
// will boil down to a simple call to the browser's execCommand(), |
| 1133 |
// for performance reasons we can do that directly instead of |
| 1134 |
// calling execCommandHelper_(). However this is a potential for |
| 1135 |
// bugs if the implementation of execCommandHelper_() is changed |
| 1136 |
// to do something more int eh case of subscript and superscript. |
| 1137 |
this.getDocument_().execCommand(oppositeExecCommand, false, null); |
| 1138 |
} |
| 1139 |
// Now that we know the whole selection has the opposite command |
| 1140 |
// applied, we exec it a second time to properly remove it. |
| 1141 |
this.getDocument_().execCommand(oppositeExecCommand, false, null); |
| 1142 |
} |
| 1143 |
}; |
| 1144 |
|
| 1145 |
|
| 1146 |
/** |
| 1147 |
* Removes inline font-size styles from elements fully contained in the |
| 1148 |
* selection, so the font tags produced by execCommand work properly. |
| 1149 |
* See {@bug 1286408}. |
| 1150 |
* @private |
| 1151 |
*/ |
| 1152 |
goog.editor.plugins.BasicTextFormatter.prototype.removeFontSizeFromStyleAttrs_ = |
| 1153 |
function() { |
| 1154 |
// Expand the range so that we consider surrounding tags. E.g. if only the |
| 1155 |
// text node inside a span is selected, the browser could wrap a font tag |
| 1156 |
// around the span and leave the selection such that only the text node is |
| 1157 |
// found when looking inside the range, not the span. |
| 1158 |
var range = goog.editor.range.expand( |
| 1159 |
this.getFieldObject().getRange(), this.getFieldObject().getElement()); |
| 1160 |
goog.iter.forEach(goog.iter.filter(range, function(tag, dummy, iter) { |
| 1161 |
return iter.isStartTag() && range.containsNode(tag); |
| 1162 |
}), function(node) { |
| 1163 |
goog.style.setStyle(node, 'font-size', ''); |
| 1164 |
// Gecko doesn't remove empty style tags. |
| 1165 |
if (goog.userAgent.GECKO && node.style.length == 0 && |
| 1166 |
node.getAttribute('style') != null) { |
| 1167 |
node.removeAttribute('style'); |
| 1168 |
} |
| 1169 |
}); |
| 1170 |
}; |
| 1171 |
|
| 1172 |
|
| 1173 |
/** |
| 1174 |
* Apply pre-execCommand fixes for IE. |
| 1175 |
* @param {string} command The command to execute. |
| 1176 |
* @return {!Array<Node>} Array of nodes to be removed after the execCommand. |
| 1177 |
* Will never be longer than 2 elements. |
| 1178 |
* @private |
| 1179 |
*/ |
| 1180 |
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandIEFixes_ = |
| 1181 |
function(command) { |
| 1182 |
// IE has a crazy bug where executing list commands |
| 1183 |
// around blockquotes cause the blockquotes to get transformed |
| 1184 |
// into "<OL><OL>" or "<UL><UL>" tags. |
| 1185 |
var toRemove = []; |
| 1186 |
var endDiv = null; |
| 1187 |
var range = this.getRange_(); |
| 1188 |
var dh = this.getFieldDomHelper(); |
| 1189 |
if (command in |
| 1190 |
goog.editor.plugins.BasicTextFormatter.blockquoteHatingCommandsIE_) { |
| 1191 |
var parent = range && range.getContainerElement(); |
| 1192 |
if (parent) { |
| 1193 |
var blockquotes = goog.dom.getElementsByTagNameAndClass( |
| 1194 |
goog.dom.TagName.BLOCKQUOTE, null, parent); |
| 1195 |
|
| 1196 |
// If a blockquote contains the selection, the fix is easy: |
| 1197 |
// add a dummy div to the blockquote that isn't in the current selection. |
| 1198 |
// |
| 1199 |
// if the selection contains a blockquote, |
| 1200 |
// there appears to be no easy way to protect it from getting mangled. |
| 1201 |
// For now, we're just going to punt on this and try to |
| 1202 |
// adjust the selection so that IE does something reasonable. |
| 1203 |
// |
| 1204 |
// TODO(nicksantos): Find a better fix for this. |
| 1205 |
var bq; |
| 1206 |
for (var i = 0; i < blockquotes.length; i++) { |
| 1207 |
if (range.containsNode(blockquotes[i])) { |
| 1208 |
bq = blockquotes[i]; |
| 1209 |
break; |
| 1210 |
} |
| 1211 |
} |
| 1212 |
|
| 1213 |
var bqThatNeedsDummyDiv = bq || |
| 1214 |
goog.dom.getAncestorByTagNameAndClass( |
| 1215 |
parent, goog.dom.TagName.BLOCKQUOTE); |
| 1216 |
if (bqThatNeedsDummyDiv) { |
| 1217 |
endDiv = dh.createDom(goog.dom.TagName.DIV, {style: 'height:0'}); |
| 1218 |
goog.dom.appendChild(bqThatNeedsDummyDiv, endDiv); |
| 1219 |
toRemove.push(endDiv); |
| 1220 |
|
| 1221 |
if (bq) { |
| 1222 |
range = goog.dom.Range.createFromNodes(bq, 0, endDiv, 0); |
| 1223 |
} else if (range.containsNode(endDiv)) { |
| 1224 |
// the selection might be the entire blockquote, and |
| 1225 |
// it's important that endDiv not be in the selection. |
| 1226 |
range = goog.dom.Range.createFromNodes( |
| 1227 |
range.getStartNode(), range.getStartOffset(), endDiv, 0); |
| 1228 |
} |
| 1229 |
range.select(); |
| 1230 |
} |
| 1231 |
} |
| 1232 |
} |
| 1233 |
|
| 1234 |
// IE has a crazy bug where certain block execCommands cause it to mess with |
| 1235 |
// the DOM nodes above the contentEditable element if the selection contains |
| 1236 |
// or partially contains the last block element in the contentEditable |
| 1237 |
// element. |
| 1238 |
// Known commands: Indent, outdent, insertorderedlist, insertunorderedlist, |
| 1239 |
// Justify (all of them) |
| 1240 |
|
| 1241 |
// Both of the above are "solved" by appending a dummy div to the field |
| 1242 |
// before the execCommand and removing it after, but we don't need to do this |
| 1243 |
// if we've alread added a dummy div somewhere else. |
| 1244 |
var fieldObject = this.getFieldObject(); |
| 1245 |
if (!fieldObject.usesIframe() && !endDiv) { |
| 1246 |
if (command in |
| 1247 |
goog.editor.plugins.BasicTextFormatter.brokenExecCommandsIE_) { |
| 1248 |
var field = fieldObject.getElement(); |
| 1249 |
|
| 1250 |
// If the field is totally empty, or if the field contains only text nodes |
| 1251 |
// and the cursor is at the end of the field, then IE stills walks outside |
| 1252 |
// the contentEditable region and destroys things AND justify will not |
| 1253 |
// work. This is "solved" by adding a text node into the end of the |
| 1254 |
// field and moving the cursor before it. |
| 1255 |
if (range && range.isCollapsed() && |
| 1256 |
!goog.dom.getFirstElementChild(field)) { |
| 1257 |
// The problem only occurs if the selection is at the end of the field. |
| 1258 |
var selection = range.getTextRange(0).getBrowserRangeObject(); |
| 1259 |
var testRange = selection.duplicate(); |
| 1260 |
testRange.moveToElementText(field); |
| 1261 |
testRange.collapse(false); |
| 1262 |
|
| 1263 |
if (testRange.isEqual(selection)) { |
| 1264 |
// For reasons I really don't understand, if you use a breaking space |
| 1265 |
// here, either " " or String.fromCharCode(32), this textNode becomes |
| 1266 |
// corrupted, only after you hit ENTER to split it. It exists in the |
| 1267 |
// dom in that its parent has it as childNode and the parent's |
| 1268 |
// innerText is correct, but the node itself throws invalid argument |
| 1269 |
// errors when you try to access its data, parentNode, nextSibling, |
| 1270 |
// previousSibling or most other properties. WTF. |
| 1271 |
var nbsp = dh.createTextNode(goog.string.Unicode.NBSP); |
| 1272 |
field.appendChild(nbsp); |
| 1273 |
selection.move('character', 1); |
| 1274 |
selection.move('character', -1); |
| 1275 |
selection.select(); |
| 1276 |
toRemove.push(nbsp); |
| 1277 |
} |
| 1278 |
} |
| 1279 |
|
| 1280 |
endDiv = dh.createDom(goog.dom.TagName.DIV, {style: 'height:0'}); |
| 1281 |
goog.dom.appendChild(field, endDiv); |
| 1282 |
toRemove.push(endDiv); |
| 1283 |
} |
| 1284 |
} |
| 1285 |
|
| 1286 |
return toRemove; |
| 1287 |
}; |
| 1288 |
|
| 1289 |
|
| 1290 |
/** |
| 1291 |
* Fix a ridiculous Safari bug: the first letters of new headings |
| 1292 |
* somehow retain their original font size and weight if multiple lines are |
| 1293 |
* selected during the execCommand that turns them into headings. |
| 1294 |
* The solution is to strip these styles which are normally stripped when |
| 1295 |
* making things headings anyway. |
| 1296 |
* @private |
| 1297 |
*/ |
| 1298 |
goog.editor.plugins.BasicTextFormatter.prototype.cleanUpSafariHeadings_ = |
| 1299 |
function() { |
| 1300 |
goog.iter.forEach(this.getRange_(), function(node) { |
| 1301 |
if (node.className == 'Apple-style-span') { |
| 1302 |
// These shouldn't persist after creating headings via |
| 1303 |
// a FormatBlock execCommand. |
| 1304 |
node.style.fontSize = ''; |
| 1305 |
node.style.fontWeight = ''; |
| 1306 |
} |
| 1307 |
}); |
| 1308 |
}; |
| 1309 |
|
| 1310 |
|
| 1311 |
/** |
| 1312 |
* Prevent Safari from making each list item be "1" when converting from |
| 1313 |
* unordered to ordered lists. |
| 1314 |
* (see https://bugs.webkit.org/show_bug.cgi?id=19539, fixed by 2010-04-21) |
| 1315 |
* @private |
| 1316 |
*/ |
| 1317 |
goog.editor.plugins.BasicTextFormatter.prototype.fixSafariLists_ = function() { |
| 1318 |
var previousList = false; |
| 1319 |
goog.iter.forEach(this.getRange_(), function(node) { |
| 1320 |
var tagName = node.tagName; |
| 1321 |
if (tagName == goog.dom.TagName.UL || tagName == goog.dom.TagName.OL) { |
| 1322 |
// Don't disturb lists outside of the selection. If this is the first <ul> |
| 1323 |
// or <ol> in the range, we don't really want to merge the previous list |
| 1324 |
// into it, since that list isn't in the range. |
| 1325 |
if (!previousList) { |
| 1326 |
previousList = true; |
| 1327 |
return; |
| 1328 |
} |
| 1329 |
// The lists must be siblings to be merged; otherwise, indented sublists |
| 1330 |
// could be broken. |
| 1331 |
var previousElementSibling = goog.dom.getPreviousElementSibling(node); |
| 1332 |
if (!previousElementSibling) { |
| 1333 |
return; |
| 1334 |
} |
| 1335 |
// Make sure there isn't text between the two lists before they are merged |
| 1336 |
var range = node.ownerDocument.createRange(); |
| 1337 |
range.setStartAfter(previousElementSibling); |
| 1338 |
range.setEndBefore(node); |
| 1339 |
if (!goog.string.isEmptyOrWhitespace(range.toString())) { |
| 1340 |
return; |
| 1341 |
} |
| 1342 |
// Make sure both are lists of the same type (ordered or unordered) |
| 1343 |
if (previousElementSibling.nodeName == node.nodeName) { |
| 1344 |
// We must merge the previous list into this one. Moving around |
| 1345 |
// the current node will break the iterator, so we can't merge |
| 1346 |
// this list into the previous one. |
| 1347 |
while (previousElementSibling.lastChild) { |
| 1348 |
node.insertBefore(previousElementSibling.lastChild, node.firstChild); |
| 1349 |
} |
| 1350 |
previousElementSibling.parentNode.removeChild(previousElementSibling); |
| 1351 |
} |
| 1352 |
} |
| 1353 |
}); |
| 1354 |
}; |
| 1355 |
|
| 1356 |
|
| 1357 |
/** |
| 1358 |
* Sane "type" attribute values for OL elements |
| 1359 |
* @private |
| 1360 |
*/ |
| 1361 |
goog.editor.plugins.BasicTextFormatter.orderedListTypes_ = { |
| 1362 |
'1': 1, |
| 1363 |
'a': 1, |
| 1364 |
'A': 1, |
| 1365 |
'i': 1, |
| 1366 |
'I': 1 |
| 1367 |
}; |
| 1368 |
|
| 1369 |
|
| 1370 |
/** |
| 1371 |
* Sane "type" attribute values for UL elements |
| 1372 |
* @private |
| 1373 |
*/ |
| 1374 |
goog.editor.plugins.BasicTextFormatter.unorderedListTypes_ = { |
| 1375 |
'disc': 1, |
| 1376 |
'circle': 1, |
| 1377 |
'square': 1 |
| 1378 |
}; |
| 1379 |
|
| 1380 |
|
| 1381 |
/** |
| 1382 |
* Changing an OL to a UL (or the other way around) will fail if the list |
| 1383 |
* has a type attribute (such as "UL type=disc" becoming "OL type=disc", which |
| 1384 |
* is visually identical). Most browsers will remove the type attribute |
| 1385 |
* automatically, but IE doesn't. This does it manually. |
| 1386 |
* @private |
| 1387 |
*/ |
| 1388 |
goog.editor.plugins.BasicTextFormatter.prototype.fixIELists_ = function() { |
| 1389 |
// Find the lowest-level <ul> or <ol> that contains the entire range. |
| 1390 |
var range = this.getRange_(); |
| 1391 |
var container = range && range.getContainer(); |
| 1392 |
while (container && |
| 1393 |
/** @type {!Element} */ (container).tagName != goog.dom.TagName.UL && |
| 1394 |
/** @type {!Element} */ (container).tagName != goog.dom.TagName.OL) { |
| 1395 |
container = container.parentNode; |
| 1396 |
} |
| 1397 |
if (container) { |
| 1398 |
// We want the parent node of the list so that we can grab it using |
| 1399 |
// getElementsByTagName |
| 1400 |
container = container.parentNode; |
| 1401 |
} |
| 1402 |
if (!container) return; |
| 1403 |
var lists = goog.array.toArray(goog.dom.getElementsByTagName( |
| 1404 |
goog.dom.TagName.UL, /** @type {!Element} */ (container))); |
| 1405 |
goog.array.extend( |
| 1406 |
lists, goog.array.toArray(goog.dom.getElementsByTagName( |
| 1407 |
goog.dom.TagName.OL, /** @type {!Element} */ (container)))); |
| 1408 |
// Fix the lists |
| 1409 |
goog.array.forEach(lists, function(node) { |
| 1410 |
var type = node.type; |
| 1411 |
if (type) { |
| 1412 |
var saneTypes = |
| 1413 |
(node.tagName == goog.dom.TagName.UL ? |
| 1414 |
goog.editor.plugins.BasicTextFormatter.unorderedListTypes_ : |
| 1415 |
goog.editor.plugins.BasicTextFormatter.orderedListTypes_); |
| 1416 |
if (!saneTypes[type]) { |
| 1417 |
node.type = ''; |
| 1418 |
} |
| 1419 |
} |
| 1420 |
}); |
| 1421 |
}; |
| 1422 |
|
| 1423 |
|
| 1424 |
/** |
| 1425 |
* In WebKit, the following commands will modify the node with |
| 1426 |
* contentEditable=true if there are no block-level elements. |
| 1427 |
* @private |
| 1428 |
*/ |
| 1429 |
goog.editor.plugins.BasicTextFormatter.brokenExecCommandsSafari_ = { |
| 1430 |
'justifyCenter': 1, |
| 1431 |
'justifyFull': 1, |
| 1432 |
'justifyRight': 1, |
| 1433 |
'justifyLeft': 1, |
| 1434 |
'formatBlock': 1 |
| 1435 |
}; |
| 1436 |
|
| 1437 |
|
| 1438 |
/** |
| 1439 |
* In WebKit, the following commands can hang the browser if the selection |
| 1440 |
* touches the beginning of the field. |
| 1441 |
* https://bugs.webkit.org/show_bug.cgi?id=19735 |
| 1442 |
* @private |
| 1443 |
*/ |
| 1444 |
goog.editor.plugins.BasicTextFormatter.hangingExecCommandWebkit_ = { |
| 1445 |
'insertOrderedList': 1, |
| 1446 |
'insertUnorderedList': 1 |
| 1447 |
}; |
| 1448 |
|
| 1449 |
|
| 1450 |
/** |
| 1451 |
* Apply pre-execCommand fixes for Safari. |
| 1452 |
* @param {string} command The command to execute. |
| 1453 |
* @return {!Element|undefined} The div added to the field. |
| 1454 |
* @private |
| 1455 |
*/ |
| 1456 |
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandSafariFixes_ = |
| 1457 |
function(command) { |
| 1458 |
// See the comment on brokenExecCommandsSafari_ |
| 1459 |
var div; |
| 1460 |
if (goog.editor.plugins.BasicTextFormatter |
| 1461 |
.brokenExecCommandsSafari_[command]) { |
| 1462 |
// Add a new div at the end of the field. |
| 1463 |
// Safari knows that it would be wrong to apply text-align to the |
| 1464 |
// contentEditable element if there are non-empty block nodes in the field, |
| 1465 |
// because then it would align them too. So in this case, it will |
| 1466 |
// enclose the current selection in a block node. |
| 1467 |
div = this.getFieldDomHelper().createDom( |
| 1468 |
goog.dom.TagName.DIV, {'style': 'height: 0'}, 'x'); |
| 1469 |
goog.dom.appendChild(this.getFieldObject().getElement(), div); |
| 1470 |
} |
| 1471 |
|
| 1472 |
if (!goog.userAgent.isVersionOrHigher(534) && |
| 1473 |
goog.editor.plugins.BasicTextFormatter |
| 1474 |
.hangingExecCommandWebkit_[command]) { |
| 1475 |
// Add a new div at the beginning of the field. |
| 1476 |
var field = this.getFieldObject().getElement(); |
| 1477 |
div = this.getFieldDomHelper().createDom( |
| 1478 |
goog.dom.TagName.DIV, {'style': 'height: 0'}, 'x'); |
| 1479 |
field.insertBefore(div, field.firstChild); |
| 1480 |
} |
| 1481 |
|
| 1482 |
return div; |
| 1483 |
}; |
| 1484 |
|
| 1485 |
|
| 1486 |
/** |
| 1487 |
* Apply pre-execCommand fixes for Gecko. |
| 1488 |
* @param {string} command The command to execute. |
| 1489 |
* @private |
| 1490 |
*/ |
| 1491 |
goog.editor.plugins.BasicTextFormatter.prototype.applyExecCommandGeckoFixes_ = |
| 1492 |
function(command) { |
| 1493 |
if (goog.userAgent.isVersionOrHigher('1.9') && |
| 1494 |
command.toLowerCase() == 'formatblock') { |
| 1495 |
// Firefox 3 and above throw a JS error for formatblock if the range is |
| 1496 |
// a child of the body node. Changing the selection to the BR fixes the |
| 1497 |
// problem. |
| 1498 |
// See https://bugzilla.mozilla.org/show_bug.cgi?id=481696 |
| 1499 |
var range = this.getRange_(); |
| 1500 |
var startNode = range.getStartNode(); |
| 1501 |
if (range.isCollapsed() && startNode && |
| 1502 |
/** @type {!Element} */ (startNode).tagName == goog.dom.TagName.BODY) { |
| 1503 |
var startOffset = range.getStartOffset(); |
| 1504 |
var childNode = startNode.childNodes[startOffset]; |
| 1505 |
if (childNode && childNode.tagName == goog.dom.TagName.BR) { |
| 1506 |
// Change the range using getBrowserRange() because goog.dom.TextRange |
| 1507 |
// will avoid setting <br>s directly. |
| 1508 |
// @see goog.dom.TextRange#createFromNodes |
| 1509 |
var browserRange = range.getBrowserRangeObject(); |
| 1510 |
browserRange.setStart(childNode, 0); |
| 1511 |
browserRange.setEnd(childNode, 0); |
| 1512 |
} |
| 1513 |
} |
| 1514 |
} |
| 1515 |
}; |
| 1516 |
|
| 1517 |
|
| 1518 |
/** |
| 1519 |
* Workaround for Opera bug CORE-23903. Opera sometimes fails to invalidate |
| 1520 |
* serialized CSS or innerHTML for the DOM after certain execCommands when |
| 1521 |
* styleWithCSS is on. Toggling an inline style on the elements fixes it. |
| 1522 |
* @private |
| 1523 |
*/ |
| 1524 |
goog.editor.plugins.BasicTextFormatter.prototype.invalidateInlineCss_ = |
| 1525 |
function() { |
| 1526 |
var ancestors = []; |
| 1527 |
var ancestor = this.getFieldObject().getRange().getContainerElement(); |
| 1528 |
do { |
| 1529 |
ancestors.push(ancestor); |
| 1530 |
} while (ancestor = ancestor.parentNode); |
| 1531 |
var nodesInSelection = goog.iter.chain( |
| 1532 |
goog.iter.toIterator(this.getFieldObject().getRange()), |
| 1533 |
goog.iter.toIterator(ancestors)); |
| 1534 |
var containersInSelection = |
| 1535 |
goog.iter.filter(nodesInSelection, goog.editor.style.isContainer); |
| 1536 |
goog.iter.forEach(containersInSelection, function(element) { |
| 1537 |
var oldOutline = element.style.outline; |
| 1538 |
element.style.outline = '0px solid red'; |
| 1539 |
element.style.outline = oldOutline; |
| 1540 |
}); |
| 1541 |
}; |
| 1542 |
|
| 1543 |
|
| 1544 |
/** |
| 1545 |
* Work around a Gecko bug that causes inserted lists to forget the current |
| 1546 |
* font. This affects WebKit in the same way and Opera in a slightly different |
| 1547 |
* way, but this workaround only works in Gecko. |
| 1548 |
* WebKit bug: https://bugs.webkit.org/show_bug.cgi?id=19653 |
| 1549 |
* Mozilla bug: https://bugzilla.mozilla.org/show_bug.cgi?id=439966 |
| 1550 |
* Opera bug: https://bugs.opera.com/show_bug.cgi?id=340392 |
| 1551 |
* TODO: work around this issue in WebKit and Opera as well. |
| 1552 |
* @return {boolean} Whether the workaround was applied. |
| 1553 |
* @private |
| 1554 |
*/ |
| 1555 |
goog.editor.plugins.BasicTextFormatter.prototype.beforeInsertListGecko_ = |
| 1556 |
function() { |
| 1557 |
var tag = |
| 1558 |
this.getFieldObject().queryCommandValue(goog.editor.Command.DEFAULT_TAG); |
| 1559 |
if (tag == goog.dom.TagName.P || tag == goog.dom.TagName.DIV) { |
| 1560 |
return false; |
| 1561 |
} |
| 1562 |
|
| 1563 |
// Prevent Firefox from forgetting current formatting |
| 1564 |
// when creating a list. |
| 1565 |
// The bug happens with a collapsed selection, but it won't |
| 1566 |
// happen when text with the desired formatting is selected. |
| 1567 |
// So, we insert some dummy text, insert the list, |
| 1568 |
// then remove the dummy text (while preserving its formatting). |
| 1569 |
// (This formatting bug also affects WebKit, but this fix |
| 1570 |
// only seems to work in Firefox) |
| 1571 |
var range = this.getRange_(); |
| 1572 |
if (range.isCollapsed() && |
| 1573 |
(range.getContainer().nodeType != goog.dom.NodeType.TEXT)) { |
| 1574 |
var tempTextNode = |
| 1575 |
this.getFieldDomHelper().createTextNode(goog.string.Unicode.NBSP); |
| 1576 |
range.insertNode(tempTextNode, false); |
| 1577 |
goog.dom.Range.createFromNodeContents(tempTextNode).select(); |
| 1578 |
return true; |
| 1579 |
} |
| 1580 |
return false; |
| 1581 |
}; |
| 1582 |
|
| 1583 |
|
| 1584 |
// Helpers for queryCommandState |
| 1585 |
|
| 1586 |
|
| 1587 |
/** |
| 1588 |
* Get the toolbar state for the block-level elements in the given range. |
| 1589 |
* @param {goog.dom.AbstractRange} range The range to get toolbar state for. |
| 1590 |
* @return {string?} The selection block state. |
| 1591 |
* @private |
| 1592 |
*/ |
| 1593 |
goog.editor.plugins.BasicTextFormatter.getSelectionBlockState_ = function( |
| 1594 |
range) { |
| 1595 |
var tagName = null; |
| 1596 |
goog.iter.forEach(range, function(node, ignore, it) { |
| 1597 |
if (!it.isEndTag()) { |
| 1598 |
// Iterate over all containers in the range, checking if they all have the |
| 1599 |
// same tagName. |
| 1600 |
var container = goog.editor.style.getContainer(node); |
| 1601 |
var thisTagName = container.tagName; |
| 1602 |
tagName = tagName || thisTagName; |
| 1603 |
|
| 1604 |
if (tagName != thisTagName) { |
| 1605 |
// If we find a container tag that doesn't match, exit right away. |
| 1606 |
tagName = null; |
| 1607 |
throw goog.iter.StopIteration; |
| 1608 |
} |
| 1609 |
|
| 1610 |
// Skip the tag. |
| 1611 |
it.skipTag(); |
| 1612 |
} |
| 1613 |
}); |
| 1614 |
|
| 1615 |
return tagName; |
| 1616 |
}; |
| 1617 |
|
| 1618 |
|
| 1619 |
/** |
| 1620 |
* Hash of suppoted justifications. |
| 1621 |
* @type {Object} |
| 1622 |
* @private |
| 1623 |
*/ |
| 1624 |
goog.editor.plugins.BasicTextFormatter.SUPPORTED_JUSTIFICATIONS_ = { |
| 1625 |
'center': 1, |
| 1626 |
'justify': 1, |
| 1627 |
'right': 1, |
| 1628 |
'left': 1 |
| 1629 |
}; |
| 1630 |
|
| 1631 |
|
| 1632 |
/** |
| 1633 |
* Returns true if the current justification matches the justification |
| 1634 |
* command for the entire selection. |
| 1635 |
* @param {string} command The justification command to check for. |
| 1636 |
* @return {boolean} Whether the current justification matches the justification |
| 1637 |
* command for the entire selection. |
| 1638 |
* @private |
| 1639 |
*/ |
| 1640 |
goog.editor.plugins.BasicTextFormatter.prototype.isJustification_ = function( |
| 1641 |
command) { |
| 1642 |
var alignment = command.replace('+justify', '').toLowerCase(); |
| 1643 |
if (alignment == 'full') { |
| 1644 |
alignment = 'justify'; |
| 1645 |
} |
| 1646 |
var bidiPlugin = this.getFieldObject().getPluginByClassId('Bidi'); |
| 1647 |
if (bidiPlugin) { |
| 1648 |
// BiDi aware version |
| 1649 |
|
| 1650 |
// TODO: Since getComputedStyle is not used here, this version may be even |
| 1651 |
// faster. If profiling confirms that it would be good to use this approach |
| 1652 |
// in both cases. Otherwise the bidi part should be moved into an |
| 1653 |
// execCommand so this bidi plugin dependence isn't needed here. |
| 1654 |
/** @type {Function} */ |
| 1655 |
bidiPlugin.getSelectionAlignment; |
| 1656 |
return alignment == bidiPlugin.getSelectionAlignment(); |
| 1657 |
} else { |
| 1658 |
// BiDi unaware version |
| 1659 |
var range = this.getRange_(); |
| 1660 |
if (!range) { |
| 1661 |
// When nothing is in the selection then no justification |
| 1662 |
// command matches. |
| 1663 |
return false; |
| 1664 |
} |
| 1665 |
|
| 1666 |
var parent = range.getContainerElement(); |
| 1667 |
var nodes = goog.array.filter(parent.childNodes, function(node) { |
| 1668 |
return goog.editor.node.isImportant(node) && |
| 1669 |
range.containsNode(node, true); |
| 1670 |
}); |
| 1671 |
nodes = nodes.length ? nodes : [parent]; |
| 1672 |
|
| 1673 |
for (var i = 0; i < nodes.length; i++) { |
| 1674 |
var current = nodes[i]; |
| 1675 |
|
| 1676 |
// If any node in the selection is not aligned the way we are checking, |
| 1677 |
// then the justification command does not match. |
| 1678 |
var container = goog.editor.style.getContainer( |
| 1679 |
/** @type {Node} */ (current)); |
| 1680 |
if (alignment != |
| 1681 |
goog.editor.plugins.BasicTextFormatter.getNodeJustification_( |
| 1682 |
container)) { |
| 1683 |
return false; |
| 1684 |
} |
| 1685 |
} |
| 1686 |
|
| 1687 |
// If all nodes in the selection are aligned the way we are checking, |
| 1688 |
// the justification command does match. |
| 1689 |
return true; |
| 1690 |
} |
| 1691 |
}; |
| 1692 |
|
| 1693 |
|
| 1694 |
/** |
| 1695 |
* Determines the justification for a given block-level element. |
| 1696 |
* @param {Element} element The node to get justification for. |
| 1697 |
* @return {string} The justification for a given block-level node. |
| 1698 |
* @private |
| 1699 |
*/ |
| 1700 |
goog.editor.plugins.BasicTextFormatter.getNodeJustification_ = function( |
| 1701 |
element) { |
| 1702 |
var value = goog.style.getComputedTextAlign(element); |
| 1703 |
// Strip preceding -moz- or -webkit- (@bug 2472589). |
| 1704 |
value = value.replace(/^-(moz|webkit)-/, ''); |
| 1705 |
|
| 1706 |
// If there is no alignment, try the inline property, |
| 1707 |
// otherwise assume left aligned. |
| 1708 |
// TODO: for rtl languages we probably need to assume right. |
| 1709 |
if (!goog.editor.plugins.BasicTextFormatter |
| 1710 |
.SUPPORTED_JUSTIFICATIONS_[value]) { |
| 1711 |
value = element.align || 'left'; |
| 1712 |
} |
| 1713 |
return /** @type {string} */ (value); |
| 1714 |
}; |
| 1715 |
|
| 1716 |
|
| 1717 |
/** |
| 1718 |
* Returns true if a selection contained in the node should set the appropriate |
| 1719 |
* toolbar state for the given nodeName, e.g. if the node is contained in a |
| 1720 |
* strong element and nodeName is "strong", then it will return true. |
| 1721 |
* @param {!goog.dom.TagName} nodeName The type of node to check for. |
| 1722 |
* @return {boolean} Whether the user's selection is in the given state. |
| 1723 |
* @private |
| 1724 |
*/ |
| 1725 |
goog.editor.plugins.BasicTextFormatter.prototype.isNodeInState_ = function( |
| 1726 |
nodeName) { |
| 1727 |
var range = this.getRange_(); |
| 1728 |
var node = range && range.getContainerElement(); |
| 1729 |
var ancestor = goog.dom.getAncestorByTagNameAndClass(node, nodeName); |
| 1730 |
return !!ancestor && goog.editor.node.isEditable(ancestor); |
| 1731 |
}; |
| 1732 |
|
| 1733 |
|
| 1734 |
/** |
| 1735 |
* Wrapper for browser's queryCommandState. |
| 1736 |
* @param {Document|TextRange|Range} queryObject The object to query. |
| 1737 |
* @param {string} command The command to check. |
| 1738 |
* @param {boolean=} opt_styleWithCss Set to true to enable styleWithCSS before |
| 1739 |
* performing the queryCommandState. |
| 1740 |
* @return {boolean} The command state. |
| 1741 |
* @private |
| 1742 |
*/ |
| 1743 |
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandStateInternal_ = |
| 1744 |
function(queryObject, command, opt_styleWithCss) { |
| 1745 |
return /** @type {boolean} */ ( |
| 1746 |
this.queryCommandHelper_(true, queryObject, command, opt_styleWithCss)); |
| 1747 |
}; |
| 1748 |
|
| 1749 |
|
| 1750 |
/** |
| 1751 |
* Wrapper for browser's queryCommandValue. |
| 1752 |
* @param {Document|TextRange|Range} queryObject The object to query. |
| 1753 |
* @param {string} command The command to check. |
| 1754 |
* @param {boolean=} opt_styleWithCss Set to true to enable styleWithCSS before |
| 1755 |
* performing the queryCommandValue. |
| 1756 |
* @return {string|boolean|null} The command value. |
| 1757 |
* @private |
| 1758 |
*/ |
| 1759 |
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandValueInternal_ = |
| 1760 |
function(queryObject, command, opt_styleWithCss) { |
| 1761 |
return this.queryCommandHelper_( |
| 1762 |
false, queryObject, command, opt_styleWithCss); |
| 1763 |
}; |
| 1764 |
|
| 1765 |
|
| 1766 |
/** |
| 1767 |
* Helper function to perform queryCommand(Value|State). |
| 1768 |
* @param {boolean} isGetQueryCommandState True to use queryCommandState, false |
| 1769 |
* to use queryCommandValue. |
| 1770 |
* @param {Document|TextRange|Range} queryObject The object to query. |
| 1771 |
* @param {string} command The command to check. |
| 1772 |
* @param {boolean=} opt_styleWithCss Set to true to enable styleWithCSS before |
| 1773 |
* performing the queryCommand(Value|State). |
| 1774 |
* @return {string|boolean|null} The command value. |
| 1775 |
* @private |
| 1776 |
*/ |
| 1777 |
goog.editor.plugins.BasicTextFormatter.prototype.queryCommandHelper_ = function( |
| 1778 |
isGetQueryCommandState, queryObject, command, opt_styleWithCss) { |
| 1779 |
command = |
| 1780 |
goog.editor.plugins.BasicTextFormatter.convertToRealExecCommand_(command); |
| 1781 |
if (opt_styleWithCss) { |
| 1782 |
var doc = this.getDocument_(); |
| 1783 |
// Don't use this.execCommandHelper_ here, as it is more heavyweight |
| 1784 |
// and inserts a dummy div to protect against comamnds that could step |
| 1785 |
// outside the editable region, which would cause change event on |
| 1786 |
// every toolbar update. |
| 1787 |
doc.execCommand('styleWithCSS', false, true); |
| 1788 |
} |
| 1789 |
var ret = isGetQueryCommandState ? queryObject.queryCommandState(command) : |
| 1790 |
queryObject.queryCommandValue(command); |
| 1791 |
if (opt_styleWithCss) { |
| 1792 |
doc.execCommand('styleWithCSS', false, false); |
| 1793 |
} |
| 1794 |
return ret; |
| 1795 |
}; |