xp-dev.com Git - namibia/blob - public/scripts/ckeditor/_source/plugins/link/dialogs/link.js

   1 /*
   2 Copyright (c) 2003-2011, CKSource - Frederico Knabben. All rights reserved.
   3 For licensing, see LICENSE.html or http://ckeditor.com/license
   4 */
   5
   6 CKEDITOR.dialog.add( 'link', function( editor )
   7 {
   8         var plugin = CKEDITOR.plugins.link;
   9         // Handles the event when the "Target" selection box is changed.
  10         var targetChanged = function()
  11         {
  12                 var dialog = this.getDialog(),
  13                         popupFeatures = dialog.getContentElement( 'target', 'popupFeatures' ),
  14                         targetName = dialog.getContentElement( 'target', 'linkTargetName' ),
  15                         value = this.getValue();
  16
  17                 if ( !popupFeatures || !targetName )
  18                         return;
  19
  20                 popupFeatures = popupFeatures.getElement();
  21                 popupFeatures.hide();
  22                 targetName.setValue( '' );
  23
  24                 switch ( value )
  25                 {
  26                         case 'frame' :
  27                                 targetName.setLabel( editor.lang.link.targetFrameName );
  28                                 targetName.getElement().show();
  29                                 break;
  30                         case 'popup' :
  31                                 popupFeatures.show();
  32                                 targetName.setLabel( editor.lang.link.targetPopupName );
  33                                 targetName.getElement().show();
  34                                 break;
  35                         default :
  36                                 targetName.setValue( value );
  37                                 targetName.getElement().hide();
  38                                 break;
  39                 }
  40
  41         };
  42
  43         // Handles the event when the "Type" selection box is changed.
  44         var linkTypeChanged = function()
  45         {
  46                 var dialog = this.getDialog(),
  47                         partIds = [ 'urlOptions', 'anchorOptions', 'emailOptions' ],
  48                         typeValue = this.getValue(),
  49                         uploadTab = dialog.definition.getContents( 'upload' ),
  50                         uploadInitiallyHidden = uploadTab && uploadTab.hidden;
  51
  52                 if ( typeValue == 'url' )
  53                 {
  54                         if ( editor.config.linkShowTargetTab )
  55                                 dialog.showPage( 'target' );
  56                         if ( !uploadInitiallyHidden )
  57                                 dialog.showPage( 'upload' );
  58                 }
  59                 else
  60                 {
  61                         dialog.hidePage( 'target' );
  62                         if ( !uploadInitiallyHidden )
  63                                 dialog.hidePage( 'upload' );
  64                 }
  65
  66                 for ( var i = 0 ; i < partIds.length ; i++ )
  67                 {
  68                         var element = dialog.getContentElement( 'info', partIds[i] );
  69                         if ( !element )
  70                                 continue;
  71
  72                         element = element.getElement().getParent().getParent();
  73                         if ( partIds[i] == typeValue + 'Options' )
  74                                 element.show();
  75                         else
  76                                 element.hide();
  77                 }
  78
  79                 dialog.layout();
  80         };
  81
  82         // Loads the parameters in a selected link to the link dialog fields.
  83         var javascriptProtocolRegex = /^javascript:/,
  84                 emailRegex = /^mailto:([^?]+)(?:\?(.+))?$/,
  85                 emailSubjectRegex = /subject=([^;?:@&=$,\/]*)/,
  86                 emailBodyRegex = /body=([^;?:@&=$,\/]*)/,
  87                 anchorRegex = /^#(.*)$/,
  88                 urlRegex = /^((?:http|https|ftp|news):\/\/)?(.*)$/,
  89                 selectableTargets = /^(_(?:self|top|parent|blank))$/,
  90                 encodedEmailLinkRegex = /^javascript:void\(location\.href='mailto:'\+String\.fromCharCode\(([^)]+)\)(?:\+'(.*)')?\)$/,
  91                 functionCallProtectedEmailLinkRegex = /^javascript:([^(]+)\(([^)]+)\)$/;
  92
  93         var popupRegex =
  94                 /\s*window.open\(\s*this\.href\s*,\s*(?:'([^']*)'|null)\s*,\s*'([^']*)'\s*\)\s*;\s*return\s*false;*\s*/;
  95         var popupFeaturesRegex = /(?:^|,)([^=]+)=(\d+|yes|no)/gi;
  96
  97         var parseLink = function( editor, element )
  98         {
  99                 var href = ( element  && ( element.data( 'cke-saved-href' ) || element.getAttribute( 'href' ) ) ) || '',
 100                         javascriptMatch,
 101                         emailMatch,
 102                         anchorMatch,
 103                         urlMatch,
 104                         retval = {};
 105
 106                 if ( ( javascriptMatch = href.match( javascriptProtocolRegex ) ) )
 107                 {
 108                         if ( emailProtection == 'encode' )
 109                         {
 110                                 href = href.replace( encodedEmailLinkRegex,
 111                                                 function ( match, protectedAddress, rest )
 112                                                 {
 113                                                         return 'mailto:' +
 114                                                                String.fromCharCode.apply( String, protectedAddress.split( ',' ) ) +
 115                                                                ( rest && unescapeSingleQuote( rest ) );
 116                                                 });
 117                         }
 118                         // Protected email link as function call.
 119                         else if ( emailProtection )
 120                         {
 121                                 href.replace( functionCallProtectedEmailLinkRegex, function( match, funcName, funcArgs )
 122                                 {
 123                                         if ( funcName == compiledProtectionFunction.name )
 124                                         {
 125                                                 retval.type = 'email';
 126                                                 var email = retval.email = {};
 127
 128                                                 var paramRegex = /[^,\s]+/g,
 129                                                         paramQuoteRegex = /(^')|('$)/g,
 130                                                         paramsMatch = funcArgs.match( paramRegex ),
 131                                                         paramsMatchLength = paramsMatch.length,
 132                                                         paramName,
 133                                                         paramVal;
 134
 135                                                 for ( var i = 0; i < paramsMatchLength; i++ )
 136                                                 {
 137                                                         paramVal = decodeURIComponent( unescapeSingleQuote( paramsMatch[ i ].replace( paramQuoteRegex, '' ) ) );
 138                                                         paramName = compiledProtectionFunction.params[ i ].toLowerCase();
 139                                                         email[ paramName ] = paramVal;
 140                                                 }
 141                                                 email.address = [ email.name, email.domain ].join( '@' );
 142                                         }
 143                                 } );
 144                         }
 145                 }
 146
 147                 if ( !retval.type )
 148                 {
 149                         if ( ( anchorMatch = href.match( anchorRegex ) ) )
 150                         {
 151                                 retval.type = 'anchor';
 152                                 retval.anchor = {};
 153                                 retval.anchor.name = retval.anchor.id = anchorMatch[1];
 154                         }
 155                         // Protected email link as encoded string.
 156                         else if ( ( emailMatch = href.match( emailRegex ) ) )
 157                         {
 158                                 var subjectMatch = href.match( emailSubjectRegex ),
 159                                         bodyMatch = href.match( emailBodyRegex );
 160
 161                                 retval.type = 'email';
 162                                 var email = ( retval.email = {} );
 163                                 email.address = emailMatch[ 1 ];
 164                                 subjectMatch && ( email.subject = decodeURIComponent( subjectMatch[ 1 ] ) );
 165                                 bodyMatch && ( email.body = decodeURIComponent( bodyMatch[ 1 ] ) );
 166                         }
 167                         // urlRegex matches empty strings, so need to check for href as well.
 168                         else if (  href && ( urlMatch = href.match( urlRegex ) ) )
 169                         {
 170                                 retval.type = 'url';
 171                                 retval.url = {};
 172                                 retval.url.protocol = urlMatch[1];
 173                                 retval.url.url = urlMatch[2];
 174                         }
 175                         else
 176                                 retval.type = 'url';
 177                 }
 178
 179                 // Load target and popup settings.
 180                 if ( element )
 181                 {
 182                         var target = element.getAttribute( 'target' );
 183                         retval.target = {};
 184                         retval.adv = {};
 185
 186                         // IE BUG: target attribute is an empty string instead of null in IE if it's not set.
 187                         if ( !target )
 188                         {
 189                                 var onclick = element.data( 'cke-pa-onclick' ) || element.getAttribute( 'onclick' ),
 190                                         onclickMatch = onclick && onclick.match( popupRegex );
 191                                 if ( onclickMatch )
 192                                 {
 193                                         retval.target.type = 'popup';
 194                                         retval.target.name = onclickMatch[1];
 195
 196                                         var featureMatch;
 197                                         while ( ( featureMatch = popupFeaturesRegex.exec( onclickMatch[2] ) ) )
 198                                         {
 199                                                 // Some values should remain numbers (#7300)
 200                                                 if ( ( featureMatch[2] == 'yes' || featureMatch[2] == '1' ) && !( featureMatch[1] in { height:1, width:1, top:1, left:1 } ) )
 201                                                         retval.target[ featureMatch[1] ] = true;
 202                                                 else if ( isFinite( featureMatch[2] ) )
 203                                                         retval.target[ featureMatch[1] ] = featureMatch[2];
 204                                         }
 205                                 }
 206                         }
 207                         else
 208                         {
 209                                 var targetMatch = target.match( selectableTargets );
 210                                 if ( targetMatch )
 211                                         retval.target.type = retval.target.name = target;
 212                                 else
 213                                 {
 214                                         retval.target.type = 'frame';
 215                                         retval.target.name = target;
 216                                 }
 217                         }
 218
 219                         var me = this;
 220                         var advAttr = function( inputName, attrName )
 221                         {
 222                                 var value = element.getAttribute( attrName );
 223                                 if ( value !== null )
 224                                         retval.adv[ inputName ] = value || '';
 225                         };
 226                         advAttr( 'advId', 'id' );
 227                         advAttr( 'advLangDir', 'dir' );
 228                         advAttr( 'advAccessKey', 'accessKey' );
 229
 230                         retval.adv.advName =
 231                                 element.data( 'cke-saved-name' )
 232                                 || element.getAttribute( 'name' )
 233                                 || '';
 234                         advAttr( 'advLangCode', 'lang' );
 235                         advAttr( 'advTabIndex', 'tabindex' );
 236                         advAttr( 'advTitle', 'title' );
 237                         advAttr( 'advContentType', 'type' );
 238                         CKEDITOR.plugins.link.synAnchorSelector ?
 239                                 retval.adv.advCSSClasses = getLinkClass( element )
 240                                 : advAttr( 'advCSSClasses', 'class' );
 241                         advAttr( 'advCharset', 'charset' );
 242                         advAttr( 'advStyles', 'style' );
 243                         advAttr( 'advRel', 'rel' );
 244                 }
 245
 246                 // Find out whether we have any anchors in the editor.
 247                 var anchors = retval.anchors = [],
 248                         item;
 249
 250                 // For some browsers we set contenteditable="false" on anchors, making document.anchors not to include them, so we must traverse the links manually (#7893).
 251                 if ( CKEDITOR.plugins.link.emptyAnchorFix )
 252                 {
 253                         var links = editor.document.getElementsByTag( 'a' );
 254                         for ( i = 0, count = links.count(); i < count; i++ )
 255                         {
 256                                 item = links.getItem( i );
 257                                 if ( item.data( 'cke-saved-name' ) || item.hasAttribute( 'name' ) )
 258                                         anchors.push( { name : item.data( 'cke-saved-name' ) || item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) } );
 259                         }
 260                 }
 261                 else
 262                 {
 263                         var anchorList = new CKEDITOR.dom.nodeList( editor.document.$.anchors );
 264                         for ( var i = 0, count = anchorList.count(); i < count; i++ )
 265                         {
 266                                 item = anchorList.getItem( i );
 267                                 anchors[ i ] = { name : item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) };
 268                         }
 269                 }
 270
 271                 if ( CKEDITOR.plugins.link.fakeAnchor )
 272                 {
 273                         var imgs = editor.document.getElementsByTag( 'img' );
 274                         for ( i = 0, count = imgs.count(); i < count; i++ )
 275                         {
 276                                 if ( ( item = CKEDITOR.plugins.link.tryRestoreFakeAnchor( editor, imgs.getItem( i ) ) ) )
 277                                         anchors.push( { name : item.getAttribute( 'name' ), id : item.getAttribute( 'id' ) } );
 278                         }
 279                 }
 280
 281                 // Record down the selected element in the dialog.
 282                 this._.selectedElement = element;
 283                 return retval;
 284         };
 285
 286         var setupParams = function( page, data )
 287         {
 288                 if ( data[page] )
 289                         this.setValue( data[page][this.id] || '' );
 290         };
 291
 292         var setupPopupParams = function( data )
 293         {
 294                 return setupParams.call( this, 'target', data );
 295         };
 296
 297         var setupAdvParams = function( data )
 298         {
 299                 return setupParams.call( this, 'adv', data );
 300         };
 301
 302         var commitParams = function( page, data )
 303         {
 304                 if ( !data[page] )
 305                         data[page] = {};
 306
 307                 data[page][this.id] = this.getValue() || '';
 308         };
 309
 310         var commitPopupParams = function( data )
 311         {
 312                 return commitParams.call( this, 'target', data );
 313         };
 314
 315         var commitAdvParams = function( data )
 316         {
 317                 return commitParams.call( this, 'adv', data );
 318         };
 319
 320         function unescapeSingleQuote( str )
 321         {
 322                 return str.replace( /\\'/g, '\'' );
 323         }
 324
 325         function escapeSingleQuote( str )
 326         {
 327                 return str.replace( /'/g, '\\$&' );
 328         }
 329
 330         var emailProtection = editor.config.emailProtection || '';
 331
 332         // Compile the protection function pattern.
 333         if ( emailProtection && emailProtection != 'encode' )
 334         {
 335                 var compiledProtectionFunction = {};
 336
 337                 emailProtection.replace( /^([^(]+)\(([^)]+)\)$/, function( match, funcName, params )
 338                 {
 339                         compiledProtectionFunction.name = funcName;
 340                         compiledProtectionFunction.params = [];
 341                         params.replace( /[^,\s]+/g, function( param )
 342                         {
 343                                 compiledProtectionFunction.params.push( param );
 344                         } );
 345                 } );
 346         }
 347
 348         function protectEmailLinkAsFunction( email )
 349         {
 350                 var retval,
 351                         name = compiledProtectionFunction.name,
 352                         params = compiledProtectionFunction.params,
 353                         paramName,
 354                         paramValue;
 355
 356                 retval = [ name, '(' ];
 357                 for ( var i = 0; i < params.length; i++ )
 358                 {
 359                         paramName = params[ i ].toLowerCase();
 360                         paramValue = email[ paramName ];
 361
 362                         i > 0 && retval.push( ',' );
 363                         retval.push( '\'',
 364                                                  paramValue ?
 365                                                  escapeSingleQuote( encodeURIComponent( email[ paramName ] ) )
 366                                                  : '',
 367                                                  '\'');
 368                 }
 369                 retval.push( ')' );
 370                 return retval.join( '' );
 371         }
 372
 373         function protectEmailAddressAsEncodedString( address )
 374         {
 375                 var charCode,
 376                         length = address.length,
 377                         encodedChars = [];
 378                 for ( var i = 0; i < length; i++ )
 379                 {
 380                         charCode = address.charCodeAt( i );
 381                         encodedChars.push( charCode );
 382                 }
 383                 return 'String.fromCharCode(' + encodedChars.join( ',' ) + ')';
 384         }
 385
 386         function getLinkClass( ele )
 387         {
 388                 var className = ele.getAttribute( 'class' );
 389                 return className ? className.replace( /\s*(?:cke_anchor_empty|cke_anchor)(?:\s*$)?/g, '' ) : '';
 390         }
 391
 392         var commonLang = editor.lang.common,
 393                 linkLang = editor.lang.link;
 394
 395         return {
 396                 title : linkLang.title,
 397                 minWidth : 350,
 398                 minHeight : 230,
 399                 contents : [
 400                         {
 401                                 id : 'info',
 402                                 label : linkLang.info,
 403                                 title : linkLang.info,
 404                                 elements :
 405                                 [
 406                                         {
 407                                                 id : 'linkType',
 408                                                 type : 'select',
 409                                                 label : linkLang.type,
 410                                                 'default' : 'url',
 411                                                 items :
 412                                                 [
 413                                                         [ linkLang.toUrl, 'url' ],
 414                                                         [ linkLang.toAnchor, 'anchor' ],
 415                                                         [ linkLang.toEmail, 'email' ]
 416                                                 ],
 417                                                 onChange : linkTypeChanged,
 418                                                 setup : function( data )
 419                                                 {
 420                                                         if ( data.type )
 421                                                                 this.setValue( data.type );
 422                                                 },
 423                                                 commit : function( data )
 424                                                 {
 425                                                         data.type = this.getValue();
 426                                                 }
 427                                         },
 428                                         {
 429                                                 type : 'vbox',
 430                                                 id : 'urlOptions',
 431                                                 children :
 432                                                 [
 433                                                         {
 434                                                                 type : 'hbox',
 435                                                                 widths : [ '25%', '75%' ],
 436                                                                 children :
 437                                                                 [
 438                                                                         {
 439                                                                                 id : 'protocol',
 440                                                                                 type : 'select',
 441                                                                                 label : commonLang.protocol,
 442                                                                                 'default' : 'http://',
 443                                                                                 items :
 444                                                                                 [
 445                                                                                         // Force 'ltr' for protocol names in BIDI. (#5433)
 446                                                                                         [ 'http://\u200E', 'http://' ],
 447                                                                                         [ 'https://\u200E', 'https://' ],
 448                                                                                         [ 'ftp://\u200E', 'ftp://' ],
 449                                                                                         [ 'news://\u200E', 'news://' ],
 450                                                                                         [ linkLang.other , '' ]
 451                                                                                 ],
 452                                                                                 setup : function( data )
 453                                                                                 {
 454                                                                                         if ( data.url )
 455                                                                                                 this.setValue( data.url.protocol || '' );
 456                                                                                 },
 457                                                                                 commit : function( data )
 458                                                                                 {
 459                                                                                         if ( !data.url )
 460                                                                                                 data.url = {};
 461
 462                                                                                         data.url.protocol = this.getValue();
 463                                                                                 }
 464                                                                         },
 465                                                                         {
 466                                                                                 type : 'text',
 467                                                                                 id : 'url',
 468                                                                                 label : commonLang.url,
 469                                                                                 required: true,
 470                                                                                 onLoad : function ()
 471                                                                                 {
 472                                                                                         this.allowOnChange = true;
 473                                                                                 },
 474                                                                                 onKeyUp : function()
 475                                                                                 {
 476                                                                                         this.allowOnChange = false;
 477                                                                                         var     protocolCmb = this.getDialog().getContentElement( 'info', 'protocol' ),
 478                                                                                                 url = this.getValue(),
 479                                                                                                 urlOnChangeProtocol = /^(http|https|ftp|news):\/\/(?=.)/i,
 480                                                                                                 urlOnChangeTestOther = /^((javascript:)|[#\/\.\?])/i;
 481
 482                                                                                         var protocol = urlOnChangeProtocol.exec( url );
 483                                                                                         if ( protocol )
 484                                                                                         {
 485                                                                                                 this.setValue( url.substr( protocol[ 0 ].length ) );
 486                                                                                                 protocolCmb.setValue( protocol[ 0 ].toLowerCase() );
 487                                                                                         }
 488                                                                                         else if ( urlOnChangeTestOther.test( url ) )
 489                                                                                                 protocolCmb.setValue( '' );
 490
 491                                                                                         this.allowOnChange = true;
 492                                                                                 },
 493                                                                                 onChange : function()
 494                                                                                 {
 495                                                                                         if ( this.allowOnChange )               // Dont't call on dialog load.
 496                                                                                                 this.onKeyUp();
 497                                                                                 },
 498                                                                                 validate : function()
 499                                                                                 {
 500                                                                                         var dialog = this.getDialog();
 501
 502                                                                                         if ( dialog.getContentElement( 'info', 'linkType' ) &&
 503                                                                                                         dialog.getValueOf( 'info', 'linkType' ) != 'url' )
 504                                                                                                 return true;
 505
 506                                                                                         if ( this.getDialog().fakeObj ) // Edit Anchor.
 507                                                                                                 return true;
 508
 509                                                                                         var func = CKEDITOR.dialog.validate.notEmpty( linkLang.noUrl );
 510                                                                                         return func.apply( this );
 511                                                                                 },
 512                                                                                 setup : function( data )
 513                                                                                 {
 514                                                                                         this.allowOnChange = false;
 515                                                                                         if ( data.url )
 516                                                                                                 this.setValue( data.url.url );
 517                                                                                         this.allowOnChange = true;
 518
 519                                                                                 },
 520                                                                                 commit : function( data )
 521                                                                                 {
 522                                                                                         // IE will not trigger the onChange event if the mouse has been used
 523                                                                                         // to carry all the operations #4724
 524                                                                                         this.onChange();
 525
 526                                                                                         if ( !data.url )
 527                                                                                                 data.url = {};
 528
 529                                                                                         data.url.url = this.getValue();
 530                                                                                         this.allowOnChange = false;
 531                                                                                 }
 532                                                                         }
 533                                                                 ],
 534                                                                 setup : function( data )
 535                                                                 {
 536                                                                         if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
 537                                                                                 this.getElement().show();
 538                                                                 }
 539                                                         },
 540                                                         {
 541                                                                 type : 'button',
 542                                                                 id : 'browse',
 543                                                                 hidden : 'true',
 544                                                                 filebrowser : 'info:url',
 545                                                                 label : commonLang.browseServer
 546                                                         }
 547                                                 ]
 548                                         },
 549                                         {
 550                                                 type : 'vbox',
 551                                                 id : 'anchorOptions',
 552                                                 width : 260,
 553                                                 align : 'center',
 554                                                 padding : 0,
 555                                                 children :
 556                                                 [
 557                                                         {
 558                                                                 type : 'fieldset',
 559                                                                 id : 'selectAnchorText',
 560                                                                 label : linkLang.selectAnchor,
 561                                                                 setup : function( data )
 562                                                                 {
 563                                                                         if ( data.anchors.length > 0 )
 564                                                                                 this.getElement().show();
 565                                                                         else
 566                                                                                 this.getElement().hide();
 567                                                                 },
 568                                                                 children :
 569                                                                 [
 570                                                                         {
 571                                                                                 type : 'hbox',
 572                                                                                 id : 'selectAnchor',
 573                                                                                 children :
 574                                                                                 [
 575                                                                                         {
 576                                                                                                 type : 'select',
 577                                                                                                 id : 'anchorName',
 578                                                                                                 'default' : '',
 579                                                                                                 label : linkLang.anchorName,
 580                                                                                                 style : 'width: 100%;',
 581                                                                                                 items :
 582                                                                                                 [
 583                                                                                                         [ '' ]
 584                                                                                                 ],
 585                                                                                                 setup : function( data )
 586                                                                                                 {
 587                                                                                                         this.clear();
 588                                                                                                         this.add( '' );
 589                                                                                                         for ( var i = 0 ; i < data.anchors.length ; i++ )
 590                                                                                                         {
 591                                                                                                                 if ( data.anchors[i].name )
 592                                                                                                                         this.add( data.anchors[i].name );
 593                                                                                                         }
 594
 595                                                                                                         if ( data.anchor )
 596                                                                                                                 this.setValue( data.anchor.name );
 597
 598                                                                                                         var linkType = this.getDialog().getContentElement( 'info', 'linkType' );
 599                                                                                                         if ( linkType && linkType.getValue() == 'email' )
 600                                                                                                                 this.focus();
 601                                                                                                 },
 602                                                                                                 commit : function( data )
 603                                                                                                 {
 604                                                                                                         if ( !data.anchor )
 605                                                                                                                 data.anchor = {};
 606
 607                                                                                                         data.anchor.name = this.getValue();
 608                                                                                                 }
 609                                                                                         },
 610                                                                                         {
 611                                                                                                 type : 'select',
 612                                                                                                 id : 'anchorId',
 613                                                                                                 'default' : '',
 614                                                                                                 label : linkLang.anchorId,
 615                                                                                                 style : 'width: 100%;',
 616                                                                                                 items :
 617                                                                                                 [
 618                                                                                                         [ '' ]
 619                                                                                                 ],
 620                                                                                                 setup : function( data )
 621                                                                                                 {
 622                                                                                                         this.clear();
 623                                                                                                         this.add( '' );
 624                                                                                                         for ( var i = 0 ; i < data.anchors.length ; i++ )
 625                                                                                                         {
 626                                                                                                                 if ( data.anchors[i].id )
 627                                                                                                                         this.add( data.anchors[i].id );
 628                                                                                                         }
 629
 630                                                                                                         if ( data.anchor )
 631                                                                                                                 this.setValue( data.anchor.id );
 632                                                                                                 },
 633                                                                                                 commit : function( data )
 634                                                                                                 {
 635                                                                                                         if ( !data.anchor )
 636                                                                                                                 data.anchor = {};
 637
 638                                                                                                         data.anchor.id = this.getValue();
 639                                                                                                 }
 640                                                                                         }
 641                                                                                 ],
 642                                                                                 setup : function( data )
 643                                                                                 {
 644                                                                                         if ( data.anchors.length > 0 )
 645                                                                                                 this.getElement().show();
 646                                                                                         else
 647                                                                                                 this.getElement().hide();
 648                                                                                 }
 649                                                                         }
 650                                                                 ]
 651                                                         },
 652                                                         {
 653                                                                 type : 'html',
 654                                                                 id : 'noAnchors',
 655                                                                 style : 'text-align: center;',
 656                                                                 html : '<div role="label" tabIndex="-1">' + CKEDITOR.tools.htmlEncode( linkLang.noAnchors ) + '</div>',
 657                                                                 // Focus the first element defined in above html.
 658                                                                 focus : true,
 659                                                                 setup : function( data )
 660                                                                 {
 661                                                                         if ( data.anchors.length < 1 )
 662                                                                                 this.getElement().show();
 663                                                                         else
 664                                                                                 this.getElement().hide();
 665                                                                 }
 666                                                         }
 667                                                 ],
 668                                                 setup : function( data )
 669                                                 {
 670                                                         if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
 671                                                                 this.getElement().hide();
 672                                                 }
 673                                         },
 674                                         {
 675                                                 type :  'vbox',
 676                                                 id : 'emailOptions',
 677                                                 padding : 1,
 678                                                 children :
 679                                                 [
 680                                                         {
 681                                                                 type : 'text',
 682                                                                 id : 'emailAddress',
 683                                                                 label : linkLang.emailAddress,
 684                                                                 required : true,
 685                                                                 validate : function()
 686                                                                 {
 687                                                                         var dialog = this.getDialog();
 688
 689                                                                         if ( !dialog.getContentElement( 'info', 'linkType' ) ||
 690                                                                                         dialog.getValueOf( 'info', 'linkType' ) != 'email' )
 691                                                                                 return true;
 692
 693                                                                         var func = CKEDITOR.dialog.validate.notEmpty( linkLang.noEmail );
 694                                                                         return func.apply( this );
 695                                                                 },
 696                                                                 setup : function( data )
 697                                                                 {
 698                                                                         if ( data.email )
 699                                                                                 this.setValue( data.email.address );
 700
 701                                                                         var linkType = this.getDialog().getContentElement( 'info', 'linkType' );
 702                                                                         if ( linkType && linkType.getValue() == 'email' )
 703                                                                                 this.select();
 704                                                                 },
 705                                                                 commit : function( data )
 706                                                                 {
 707                                                                         if ( !data.email )
 708                                                                                 data.email = {};
 709
 710                                                                         data.email.address = this.getValue();
 711                                                                 }
 712                                                         },
 713                                                         {
 714                                                                 type : 'text',
 715                                                                 id : 'emailSubject',
 716                                                                 label : linkLang.emailSubject,
 717                                                                 setup : function( data )
 718                                                                 {
 719                                                                         if ( data.email )
 720                                                                                 this.setValue( data.email.subject );
 721                                                                 },
 722                                                                 commit : function( data )
 723                                                                 {
 724                                                                         if ( !data.email )
 725                                                                                 data.email = {};
 726
 727                                                                         data.email.subject = this.getValue();
 728                                                                 }
 729                                                         },
 730                                                         {
 731                                                                 type : 'textarea',
 732                                                                 id : 'emailBody',
 733                                                                 label : linkLang.emailBody,
 734                                                                 rows : 3,
 735                                                                 'default' : '',
 736                                                                 setup : function( data )
 737                                                                 {
 738                                                                         if ( data.email )
 739                                                                                 this.setValue( data.email.body );
 740                                                                 },
 741                                                                 commit : function( data )
 742                                                                 {
 743                                                                         if ( !data.email )
 744                                                                                 data.email = {};
 745
 746                                                                         data.email.body = this.getValue();
 747                                                                 }
 748                                                         }
 749                                                 ],
 750                                                 setup : function( data )
 751                                                 {
 752                                                         if ( !this.getDialog().getContentElement( 'info', 'linkType' ) )
 753                                                                 this.getElement().hide();
 754                                                 }
 755                                         }
 756                                 ]
 757                         },
 758                         {
 759                                 id : 'target',
 760                                 label : linkLang.target,
 761                                 title : linkLang.target,
 762                                 elements :
 763                                 [
 764                                         {
 765                                                 type : 'hbox',
 766                                                 widths : [ '50%', '50%' ],
 767                                                 children :
 768                                                 [
 769                                                         {
 770                                                                 type : 'select',
 771                                                                 id : 'linkTargetType',
 772                                                                 label : commonLang.target,
 773                                                                 'default' : 'notSet',
 774                                                                 style : 'width : 100%;',
 775                                                                 'items' :
 776                                                                 [
 777                                                                         [ commonLang.notSet, 'notSet' ],
 778                                                                         [ linkLang.targetFrame, 'frame' ],
 779                                                                         [ linkLang.targetPopup, 'popup' ],
 780                                                                         [ commonLang.targetNew, '_blank' ],
 781                                                                         [ commonLang.targetTop, '_top' ],
 782                                                                         [ commonLang.targetSelf, '_self' ],
 783                                                                         [ commonLang.targetParent, '_parent' ]
 784                                                                 ],
 785                                                                 onChange : targetChanged,
 786                                                                 setup : function( data )
 787                                                                 {
 788                                                                         if ( data.target )
 789                                                                                 this.setValue( data.target.type || 'notSet' );
 790                                                                         targetChanged.call( this );
 791                                                                 },
 792                                                                 commit : function( data )
 793                                                                 {
 794                                                                         if ( !data.target )
 795                                                                                 data.target = {};
 796
 797                                                                         data.target.type = this.getValue();
 798                                                                 }
 799                                                         },
 800                                                         {
 801                                                                 type : 'text',
 802                                                                 id : 'linkTargetName',
 803                                                                 label : linkLang.targetFrameName,
 804                                                                 'default' : '',
 805                                                                 setup : function( data )
 806                                                                 {
 807                                                                         if ( data.target )
 808                                                                                 this.setValue( data.target.name );
 809                                                                 },
 810                                                                 commit : function( data )
 811                                                                 {
 812                                                                         if ( !data.target )
 813                                                                                 data.target = {};
 814
 815                                                                         data.target.name = this.getValue().replace(/\W/gi, '');
 816                                                                 }
 817                                                         }
 818                                                 ]
 819                                         },
 820                                         {
 821                                                 type : 'vbox',
 822                                                 width : '100%',
 823                                                 align : 'center',
 824                                                 padding : 2,
 825                                                 id : 'popupFeatures',
 826                                                 children :
 827                                                 [
 828                                                         {
 829                                                                 type : 'fieldset',
 830                                                                 label : linkLang.popupFeatures,
 831                                                                 children :
 832                                                                 [
 833                                                                         {
 834                                                                                 type : 'hbox',
 835                                                                                 children :
 836                                                                                 [
 837                                                                                         {
 838                                                                                                 type : 'checkbox',
 839                                                                                                 id : 'resizable',
 840                                                                                                 label : linkLang.popupResizable,
 841                                                                                                 setup : setupPopupParams,
 842                                                                                                 commit : commitPopupParams
 843                                                                                         },
 844                                                                                         {
 845                                                                                                 type : 'checkbox',
 846                                                                                                 id : 'status',
 847                                                                                                 label : linkLang.popupStatusBar,
 848                                                                                                 setup : setupPopupParams,
 849                                                                                                 commit : commitPopupParams
 850
 851                                                                                         }
 852                                                                                 ]
 853                                                                         },
 854                                                                         {
 855                                                                                 type : 'hbox',
 856                                                                                 children :
 857                                                                                 [
 858                                                                                         {
 859                                                                                                 type : 'checkbox',
 860                                                                                                 id : 'location',
 861                                                                                                 label : linkLang.popupLocationBar,
 862                                                                                                 setup : setupPopupParams,
 863                                                                                                 commit : commitPopupParams
 864
 865                                                                                         },
 866                                                                                         {
 867                                                                                                 type : 'checkbox',
 868                                                                                                 id : 'toolbar',
 869                                                                                                 label : linkLang.popupToolbar,
 870                                                                                                 setup : setupPopupParams,
 871                                                                                                 commit : commitPopupParams
 872
 873                                                                                         }
 874                                                                                 ]
 875                                                                         },
 876                                                                         {
 877                                                                                 type : 'hbox',
 878                                                                                 children :
 879                                                                                 [
 880                                                                                         {
 881                                                                                                 type : 'checkbox',
 882                                                                                                 id : 'menubar',
 883                                                                                                 label : linkLang.popupMenuBar,
 884                                                                                                 setup : setupPopupParams,
 885                                                                                                 commit : commitPopupParams
 886
 887                                                                                         },
 888                                                                                         {
 889                                                                                                 type : 'checkbox',
 890                                                                                                 id : 'fullscreen',
 891                                                                                                 label : linkLang.popupFullScreen,
 892                                                                                                 setup : setupPopupParams,
 893                                                                                                 commit : commitPopupParams
 894
 895                                                                                         }
 896                                                                                 ]
 897                                                                         },
 898                                                                         {
 899                                                                                 type : 'hbox',
 900                                                                                 children :
 901                                                                                 [
 902                                                                                         {
 903                                                                                                 type : 'checkbox',
 904                                                                                                 id : 'scrollbars',
 905                                                                                                 label : linkLang.popupScrollBars,
 906                                                                                                 setup : setupPopupParams,
 907                                                                                                 commit : commitPopupParams
 908
 909                                                                                         },
 910                                                                                         {
 911                                                                                                 type : 'checkbox',
 912                                                                                                 id : 'dependent',
 913                                                                                                 label : linkLang.popupDependent,
 914                                                                                                 setup : setupPopupParams,
 915                                                                                                 commit : commitPopupParams
 916
 917                                                                                         }
 918                                                                                 ]
 919                                                                         },
 920                                                                         {
 921                                                                                 type : 'hbox',
 922                                                                                 children :
 923                                                                                 [
 924                                                                                         {
 925                                                                                                 type :  'text',
 926                                                                                                 widths : [ '50%', '50%' ],
 927                                                                                                 labelLayout : 'horizontal',
 928                                                                                                 label : commonLang.width,
 929                                                                                                 id : 'width',
 930                                                                                                 setup : setupPopupParams,
 931                                                                                                 commit : commitPopupParams
 932
 933                                                                                         },
 934                                                                                         {
 935                                                                                                 type :  'text',
 936                                                                                                 labelLayout : 'horizontal',
 937                                                                                                 widths : [ '50%', '50%' ],
 938                                                                                                 label : linkLang.popupLeft,
 939                                                                                                 id : 'left',
 940                                                                                                 setup : setupPopupParams,
 941                                                                                                 commit : commitPopupParams
 942
 943                                                                                         }
 944                                                                                 ]
 945                                                                         },
 946                                                                         {
 947                                                                                 type : 'hbox',
 948                                                                                 children :
 949                                                                                 [
 950                                                                                         {
 951                                                                                                 type :  'text',
 952                                                                                                 labelLayout : 'horizontal',
 953                                                                                                 widths : [ '50%', '50%' ],
 954                                                                                                 label : commonLang.height,
 955                                                                                                 id : 'height',
 956                                                                                                 setup : setupPopupParams,
 957                                                                                                 commit : commitPopupParams
 958
 959                                                                                         },
 960                                                                                         {
 961                                                                                                 type :  'text',
 962                                                                                                 labelLayout : 'horizontal',
 963                                                                                                 label : linkLang.popupTop,
 964                                                                                                 widths : [ '50%', '50%' ],
 965                                                                                                 id : 'top',
 966                                                                                                 setup : setupPopupParams,
 967                                                                                                 commit : commitPopupParams
 968
 969                                                                                         }
 970                                                                                 ]
 971                                                                         }
 972                                                                 ]
 973                                                         }
 974                                                 ]
 975                                         }
 976                                 ]
 977                         },
 978                         {
 979                                 id : 'upload',
 980                                 label : linkLang.upload,
 981                                 title : linkLang.upload,
 982                                 hidden : true,
 983                                 filebrowser : 'uploadButton',
 984                                 elements :
 985                                 [
 986                                         {
 987                                                 type : 'file',
 988                                                 id : 'upload',
 989                                                 label : commonLang.upload,
 990                                                 style: 'height:40px',
 991                                                 size : 29
 992                                         },
 993                                         {
 994                                                 type : 'fileButton',
 995                                                 id : 'uploadButton',
 996                                                 label : commonLang.uploadSubmit,
 997                                                 filebrowser : 'info:url',
 998                                                 'for' : [ 'upload', 'upload' ]
 999                                         }
1000                                 ]
1001                         },
1002                         {
1003                                 id : 'advanced',
1004                                 label : linkLang.advanced,
1005                                 title : linkLang.advanced,
1006                                 elements :
1007                                 [
1008                                         {
1009                                                 type : 'vbox',
1010                                                 padding : 1,
1011                                                 children :
1012                                                 [
1013                                                         {
1014                                                                 type : 'hbox',
1015                                                                 widths : [ '45%', '35%', '20%' ],
1016                                                                 children :
1017                                                                 [
1018                                                                         {
1019                                                                                 type : 'text',
1020                                                                                 id : 'advId',
1021                                                                                 label : linkLang.id,
1022                                                                                 setup : setupAdvParams,
1023                                                                                 commit : commitAdvParams
1024                                                                         },
1025                                                                         {
1026                                                                                 type : 'select',
1027                                                                                 id : 'advLangDir',
1028                                                                                 label : linkLang.langDir,
1029                                                                                 'default' : '',
1030                                                                                 style : 'width:110px',
1031                                                                                 items :
1032                                                                                 [
1033                                                                                         [ commonLang.notSet, '' ],
1034                                                                                         [ linkLang.langDirLTR, 'ltr' ],
1035                                                                                         [ linkLang.langDirRTL, 'rtl' ]
1036                                                                                 ],
1037                                                                                 setup : setupAdvParams,
1038                                                                                 commit : commitAdvParams
1039                                                                         },
1040                                                                         {
1041                                                                                 type : 'text',
1042                                                                                 id : 'advAccessKey',
1043                                                                                 width : '80px',
1044                                                                                 label : linkLang.acccessKey,
1045                                                                                 maxLength : 1,
1046                                                                                 setup : setupAdvParams,
1047                                                                                 commit : commitAdvParams
1048
1049                                                                         }
1050                                                                 ]
1051                                                         },
1052                                                         {
1053                                                                 type : 'hbox',
1054                                                                 widths : [ '45%', '35%', '20%' ],
1055                                                                 children :
1056                                                                 [
1057                                                                         {
1058                                                                                 type : 'text',
1059                                                                                 label : linkLang.name,
1060                                                                                 id : 'advName',
1061                                                                                 setup : setupAdvParams,
1062                                                                                 commit : commitAdvParams
1063
1064                                                                         },
1065                                                                         {
1066                                                                                 type : 'text',
1067                                                                                 label : linkLang.langCode,
1068                                                                                 id : 'advLangCode',
1069                                                                                 width : '110px',
1070                                                                                 'default' : '',
1071                                                                                 setup : setupAdvParams,
1072                                                                                 commit : commitAdvParams
1073
1074                                                                         },
1075                                                                         {
1076                                                                                 type : 'text',
1077                                                                                 label : linkLang.tabIndex,
1078                                                                                 id : 'advTabIndex',
1079                                                                                 width : '80px',
1080                                                                                 maxLength : 5,
1081                                                                                 setup : setupAdvParams,
1082                                                                                 commit : commitAdvParams
1083
1084                                                                         }
1085                                                                 ]
1086                                                         }
1087                                                 ]
1088                                         },
1089                                         {
1090                                                 type : 'vbox',
1091                                                 padding : 1,
1092                                                 children :
1093                                                 [
1094                                                         {
1095                                                                 type : 'hbox',
1096                                                                 widths : [ '45%', '55%' ],
1097                                                                 children :
1098                                                                 [
1099                                                                         {
1100                                                                                 type : 'text',
1101                                                                                 label : linkLang.advisoryTitle,
1102                                                                                 'default' : '',
1103                                                                                 id : 'advTitle',
1104                                                                                 setup : setupAdvParams,
1105                                                                                 commit : commitAdvParams
1106
1107                                                                         },
1108                                                                         {
1109                                                                                 type : 'text',
1110                                                                                 label : linkLang.advisoryContentType,
1111                                                                                 'default' : '',
1112                                                                                 id : 'advContentType',
1113                                                                                 setup : setupAdvParams,
1114                                                                                 commit : commitAdvParams
1115
1116                                                                         }
1117                                                                 ]
1118                                                         },
1119                                                         {
1120                                                                 type : 'hbox',
1121                                                                 widths : [ '45%', '55%' ],
1122                                                                 children :
1123                                                                 [
1124                                                                         {
1125                                                                                 type : 'text',
1126                                                                                 label : linkLang.cssClasses,
1127                                                                                 'default' : '',
1128                                                                                 id : 'advCSSClasses',
1129                                                                                 setup : setupAdvParams,
1130                                                                                 commit : commitAdvParams
1131
1132                                                                         },
1133                                                                         {
1134                                                                                 type : 'text',
1135                                                                                 label : linkLang.charset,
1136                                                                                 'default' : '',
1137                                                                                 id : 'advCharset',
1138                                                                                 setup : setupAdvParams,
1139                                                                                 commit : commitAdvParams
1140
1141                                                                         }
1142                                                                 ]
1143                                                         },
1144                                                         {
1145                                                                 type : 'hbox',
1146                                                                 widths : [ '45%', '55%' ],
1147                                                                 children :
1148                                                                 [
1149                                                                         {
1150                                                                                 type : 'text',
1151                                                                                 label : linkLang.rel,
1152                                                                                 'default' : '',
1153                                                                                 id : 'advRel',
1154                                                                                 setup : setupAdvParams,
1155                                                                                 commit : commitAdvParams
1156                                                                         },
1157                                                                         {
1158                                                                                 type : 'text',
1159                                                                                 label : linkLang.styles,
1160                                                                                 'default' : '',
1161                                                                                 id : 'advStyles',
1162                                                                                 validate : CKEDITOR.dialog.validate.inlineStyle( editor.lang.common.invalidInlineStyle ),
1163                                                                                 setup : setupAdvParams,
1164                                                                                 commit : commitAdvParams
1165                                                                         }
1166                                                                 ]
1167                                                         }
1168                                                 ]
1169                                         }
1170                                 ]
1171                         }
1172                 ],
1173                 onShow : function()
1174                 {
1175                         var editor = this.getParentEditor(),
1176                                 selection = editor.getSelection(),
1177                                 element = null;
1178
1179                         // Fill in all the relevant fields if there's already one link selected.
1180                         if ( ( element = plugin.getSelectedLink( editor ) ) && element.hasAttribute( 'href' ) )
1181                                 selection.selectElement( element );
1182                         else
1183                                 element = null;
1184
1185                         this.setupContent( parseLink.apply( this, [ editor, element ] ) );
1186                 },
1187                 onOk : function()
1188                 {
1189                         var attributes = {},
1190                                 removeAttributes = [],
1191                                 data = {},
1192                                 me = this,
1193                                 editor = this.getParentEditor();
1194
1195                         this.commitContent( data );
1196
1197                         // Compose the URL.
1198                         switch ( data.type || 'url' )
1199                         {
1200                                 case 'url':
1201                                         var protocol = ( data.url && data.url.protocol != undefined ) ? data.url.protocol : 'http://',
1202                                                 url = ( data.url && CKEDITOR.tools.trim( data.url.url ) ) || '';
1203                                         attributes[ 'data-cke-saved-href' ] = ( url.indexOf( '/' ) === 0 ) ? url : protocol + url;
1204                                         break;
1205                                 case 'anchor':
1206                                         var name = ( data.anchor && data.anchor.name ),
1207                                                 id = ( data.anchor && data.anchor.id );
1208                                         attributes[ 'data-cke-saved-href' ] = '#' + ( name || id || '' );
1209                                         break;
1210                                 case 'email':
1211
1212                                         var linkHref,
1213                                                 email = data.email,
1214                                                 address = email.address;
1215
1216                                         switch( emailProtection )
1217                                         {
1218                                                 case '' :
1219                                                 case 'encode' :
1220                                                 {
1221                                                         var subject = encodeURIComponent( email.subject || '' ),
1222                                                                 body = encodeURIComponent( email.body || '' );
1223
1224                                                         // Build the e-mail parameters first.
1225                                                         var argList = [];
1226                                                         subject && argList.push( 'subject=' + subject );
1227                                                         body && argList.push( 'body=' + body );
1228                                                         argList = argList.length ? '?' + argList.join( '&' ) : '';
1229
1230                                                         if ( emailProtection == 'encode' )
1231                                                         {
1232                                                                 linkHref = [ 'javascript:void(location.href=\'mailto:\'+',
1233                                                                                          protectEmailAddressAsEncodedString( address ) ];
1234                                                                 // parameters are optional.
1235                                                                 argList && linkHref.push( '+\'', escapeSingleQuote( argList ), '\'' );
1236
1237                                                                 linkHref.push( ')' );
1238                                                         }
1239                                                         else
1240                                                                 linkHref = [ 'mailto:', address, argList ];
1241
1242                                                         break;
1243                                                 }
1244                                                 default :
1245                                                 {
1246                                                         // Separating name and domain.
1247                                                         var nameAndDomain = address.split( '@', 2 );
1248                                                         email.name = nameAndDomain[ 0 ];
1249                                                         email.domain = nameAndDomain[ 1 ];
1250
1251                                                         linkHref = [ 'javascript:', protectEmailLinkAsFunction( email ) ];
1252                                                 }
1253                                         }
1254
1255                                         attributes[ 'data-cke-saved-href' ] = linkHref.join( '' );
1256                                         break;
1257                         }
1258
1259                         // Popups and target.
1260                         if ( data.target )
1261                         {
1262                                 if ( data.target.type == 'popup' )
1263                                 {
1264                                         var onclickList = [ 'window.open(this.href, \'',
1265                                                         data.target.name || '', '\', \'' ];
1266                                         var featureList = [ 'resizable', 'status', 'location', 'toolbar', 'menubar', 'fullscreen',
1267                                                         'scrollbars', 'dependent' ];
1268                                         var featureLength = featureList.length;
1269                                         var addFeature = function( featureName )
1270                                         {
1271                                                 if ( data.target[ featureName ] )
1272                                                         featureList.push( featureName + '=' + data.target[ featureName ] );
1273                                         };
1274
1275                                         for ( var i = 0 ; i < featureLength ; i++ )
1276                                                 featureList[i] = featureList[i] + ( data.target[ featureList[i] ] ? '=yes' : '=no' ) ;
1277                                         addFeature( 'width' );
1278                                         addFeature( 'left' );
1279                                         addFeature( 'height' );
1280                                         addFeature( 'top' );
1281
1282                                         onclickList.push( featureList.join( ',' ), '\'); return false;' );
1283                                         attributes[ 'data-cke-pa-onclick' ] = onclickList.join( '' );
1284
1285                                         // Add the "target" attribute. (#5074)
1286                                         removeAttributes.push( 'target' );
1287                                 }
1288                                 else
1289                                 {
1290                                         if ( data.target.type != 'notSet' && data.target.name )
1291                                                 attributes.target = data.target.name;
1292                                         else
1293                                                 removeAttributes.push( 'target' );
1294
1295                                         removeAttributes.push( 'data-cke-pa-onclick', 'onclick' );
1296                                 }
1297                         }
1298
1299                         // Advanced attributes.
1300                         if ( data.adv )
1301                         {
1302                                 var advAttr = function( inputName, attrName )
1303                                 {
1304                                         var value = data.adv[ inputName ];
1305                                         if ( value )
1306                                                 attributes[attrName] = value;
1307                                         else
1308                                                 removeAttributes.push( attrName );
1309                                 };
1310
1311                                 advAttr( 'advId', 'id' );
1312                                 advAttr( 'advLangDir', 'dir' );
1313                                 advAttr( 'advAccessKey', 'accessKey' );
1314
1315                                 if ( data.adv[ 'advName' ] )
1316                                         attributes[ 'name' ] = attributes[ 'data-cke-saved-name' ] = data.adv[ 'advName' ];
1317                                 else
1318                                         removeAttributes = removeAttributes.concat( [ 'data-cke-saved-name', 'name' ] );
1319
1320                                 advAttr( 'advLangCode', 'lang' );
1321                                 advAttr( 'advTabIndex', 'tabindex' );
1322                                 advAttr( 'advTitle', 'title' );
1323                                 advAttr( 'advContentType', 'type' );
1324                                 advAttr( 'advCSSClasses', 'class' );
1325                                 advAttr( 'advCharset', 'charset' );
1326                                 advAttr( 'advStyles', 'style' );
1327                                 advAttr( 'advRel', 'rel' );
1328                         }
1329
1330
1331                         // Browser need the "href" fro copy/paste link to work. (#6641)
1332                         attributes.href = attributes[ 'data-cke-saved-href' ];
1333
1334                         if ( !this._.selectedElement )
1335                         {
1336                                 // Create element if current selection is collapsed.
1337                                 var selection = editor.getSelection(),
1338                                         ranges = selection.getRanges( true );
1339                                 if ( ranges.length == 1 && ranges[0].collapsed )
1340                                 {
1341                                         // Short mailto link text view (#5736).
1342                                         var text = new CKEDITOR.dom.text( data.type == 'email' ?
1343                                                         data.email.address : attributes[ 'data-cke-saved-href' ], editor.document );
1344                                         ranges[0].insertNode( text );
1345                                         ranges[0].selectNodeContents( text );
1346                                         selection.selectRanges( ranges );
1347                                 }
1348
1349                                 // Apply style.
1350                                 var style = new CKEDITOR.style( { element : 'a', attributes : attributes } );
1351                                 style.type = CKEDITOR.STYLE_INLINE;             // need to override... dunno why.
1352                                 style.apply( editor.document );
1353                         }
1354                         else
1355                         {
1356                                 // We're only editing an existing link, so just overwrite the attributes.
1357                                 var element = this._.selectedElement,
1358                                         href = element.data( 'cke-saved-href' ),
1359                                         textView = element.getHtml();
1360
1361                                 element.setAttributes( attributes );
1362                                 element.removeAttributes( removeAttributes );
1363
1364                                 if ( data.adv && data.adv.advName && CKEDITOR.plugins.link.synAnchorSelector )
1365                                         element.addClass( element.getChildCount() ? 'cke_anchor' : 'cke_anchor_empty' );
1366
1367                                 // Update text view when user changes protocol (#4612).
1368                                 if ( href == textView || data.type == 'email' && textView.indexOf( '@' ) != -1 )
1369                                 {
1370                                         // Short mailto link text view (#5736).
1371                                         element.setHtml( data.type == 'email' ?
1372                                                 data.email.address : attributes[ 'data-cke-saved-href' ] );
1373                                 }
1374
1375                                 delete this._.selectedElement;
1376                         }
1377                 },
1378                 onLoad : function()
1379                 {
1380                         if ( !editor.config.linkShowAdvancedTab )
1381                                 this.hidePage( 'advanced' );            //Hide Advanded tab.
1382
1383                         if ( !editor.config.linkShowTargetTab )
1384                                 this.hidePage( 'target' );              //Hide Target tab.
1385
1386                 },
1387                 // Inital focus on 'url' field if link is of type URL.
1388                 onFocus : function()
1389                 {
1390                         var linkType = this.getContentElement( 'info', 'linkType' ),
1391                                         urlField;
1392                         if ( linkType && linkType.getValue() == 'url' )
1393                         {
1394                                 urlField = this.getContentElement( 'info', 'url' );
1395                                 urlField.select();
1396                         }
1397                 }
1398         };
1399 });
1400
1401 /**
1402  * The e-mail address anti-spam protection option. The protection will be
1403  * applied when creating or modifying e-mail links through the editor interface.<br>
1404  * Two methods of protection can be choosed:
1405  * <ol> <li>The e-mail parts (name, domain and any other query string) are
1406  *                      assembled into a function call pattern. Such function must be
1407  *                      provided by the developer in the pages that will use the contents.
1408  *              <li>Only the e-mail address is obfuscated into a special string that
1409  *                      has no meaning for humans or spam bots, but which is properly
1410  *                      rendered and accepted by the browser.</li></ol>
1411  * Both approaches require JavaScript to be enabled.
1412  * @name CKEDITOR.config.emailProtection
1413  * @since 3.1
1414  * @type String
1415  * @default '' (empty string = disabled)
1416  * @example
1417  * // href="mailto:tester@ckeditor.com?subject=subject&body=body"
1418  * config.emailProtection = '';
1419  * @example
1420  * // href="<a href=\"javascript:void(location.href=\'mailto:\'+String.fromCharCode(116,101,115,116,101,114,64,99,107,101,100,105,116,111,114,46,99,111,109)+\'?subject=subject&body=body\')\">e-mail</a>"
1421  * config.emailProtection = 'encode';
1422  * @example
1423  * // href="javascript:mt('tester','ckeditor.com','subject','body')"
1424  * config.emailProtection = 'mt(NAME,DOMAIN,SUBJECT,BODY)';
1425  */