[Sommaire] [Imprimer]

   1  /*
   2   * FCKeditor - The text editor for internet
   3   * Copyright (C) 2003-2006 Frederico Caldeira Knabben
   4   * 
   5   * Licensed under the terms of the GNU Lesser General Public License:
   6   *         http://www.opensource.org/licenses/lgpl-license.php
   7   * 
   8   * For further information visit:
   9   *         http://www.fckeditor.net/
  10   * 
  11   * "Support Open Source software. What about a donation today?"
  12   * 
  13   * File Name: fck_othercommands.js
  14   *     Definition of other commands that are not available internaly in the
  15   *     browser (see FCKNamedCommand).
  16   * 
  17   * File Authors:
  18   *         Frederico Caldeira Knabben (fredck@fckeditor.net)
  19   */
  20  
  21  // ### General Dialog Box Commands.
  22  var FCKDialogCommand = function( name, title, url, width, height, getStateFunction, getStateParam )
  23  {
  24      this.Name    = name ;
  25      this.Title    = title ;
  26      this.Url    = url ;
  27      this.Width    = width ;
  28      this.Height    = height ;
  29  
  30      this.GetStateFunction    = getStateFunction ;
  31      this.GetStateParam        = getStateParam ;
  32  }
  33  
  34  FCKDialogCommand.prototype.Execute = function()
  35  {
  36      FCKDialog.OpenDialog( 'FCKDialog_' + this.Name , this.Title, this.Url, this.Width, this.Height ) ;
  37  }
  38  
  39  FCKDialogCommand.prototype.GetState = function()
  40  {
  41      if ( this.GetStateFunction )
  42          return this.GetStateFunction( this.GetStateParam ) ;
  43      else
  44          return FCK_TRISTATE_OFF ;
  45  }
  46  
  47  // Generic Undefined command (usually used when a command is under development).
  48  var FCKUndefinedCommand = function()
  49  {
  50      this.Name = 'Undefined' ;
  51  }
  52  
  53  FCKUndefinedCommand.prototype.Execute = function()
  54  {
  55      alert( FCKLang.NotImplemented ) ;
  56  }
  57  
  58  FCKUndefinedCommand.prototype.GetState = function()
  59  {
  60      return FCK_TRISTATE_OFF ;
  61  }
  62  
  63  // ### FontName
  64  var FCKFontNameCommand = function()
  65  {
  66      this.Name = 'FontName' ;
  67  }
  68  
  69  FCKFontNameCommand.prototype.Execute = function( fontName )
  70  {
  71      if (fontName == null || fontName == "")
  72      {
  73          // TODO: Remove font name attribute.
  74      }
  75      else
  76          FCK.ExecuteNamedCommand( 'FontName', fontName ) ;
  77  }
  78  
  79  FCKFontNameCommand.prototype.GetState = function()
  80  {
  81      return FCK.GetNamedCommandValue( 'FontName' ) ;
  82  }
  83  
  84  // ### FontSize
  85  var FCKFontSizeCommand = function()
  86  {
  87      this.Name = 'FontSize' ;
  88  }
  89  
  90  FCKFontSizeCommand.prototype.Execute = function( fontSize )
  91  {
  92      if ( typeof( fontSize ) == 'string' ) fontSize = parseInt(fontSize) ;
  93  
  94      if ( fontSize == null || fontSize == '' )
  95      {
  96          // TODO: Remove font size attribute (Now it works with size 3. Will it work forever?)
  97          FCK.ExecuteNamedCommand( 'FontSize', 3 ) ;
  98      }
  99      else
 100          FCK.ExecuteNamedCommand( 'FontSize', fontSize ) ;
 101  }
 102  
 103  FCKFontSizeCommand.prototype.GetState = function()
 104  {
 105      return FCK.GetNamedCommandValue( 'FontSize' ) ;
 106  }
 107  
 108  // ### FormatBlock
 109  var FCKFormatBlockCommand = function()
 110  {
 111      this.Name = 'FormatBlock' ;
 112  }
 113  
 114  FCKFormatBlockCommand.prototype.Execute = function( formatName )
 115  {
 116      if ( formatName == null || formatName == '' )
 117          FCK.ExecuteNamedCommand( 'FormatBlock', '<P>' ) ;
 118      else if ( formatName == 'div' && FCKBrowserInfo.IsGecko )
 119          FCK.ExecuteNamedCommand( 'FormatBlock', 'div' ) ;
 120      else
 121          FCK.ExecuteNamedCommand( 'FormatBlock', '<' + formatName + '>' ) ;
 122  }
 123  
 124  FCKFormatBlockCommand.prototype.GetState = function()
 125  {
 126      return FCK.GetNamedCommandValue( 'FormatBlock' ) ;
 127  }
 128  
 129  // ### Preview
 130  var FCKPreviewCommand = function()
 131  {
 132      this.Name = 'Preview' ;
 133  }
 134  
 135  FCKPreviewCommand.prototype.Execute = function()
 136  {
 137       FCK.Preview() ;
 138  }
 139  
 140  FCKPreviewCommand.prototype.GetState = function()
 141  {
 142      return FCK_TRISTATE_OFF ;
 143  }
 144  
 145  // ### Save
 146  var FCKSaveCommand = function()
 147  {
 148      this.Name = 'Save' ;
 149  }
 150  
 151  FCKSaveCommand.prototype.Execute = function()
 152  {
 153      // Get the linked field form.
 154      var oForm = FCK.LinkedField.form ;
 155  
 156      if ( typeof( oForm.onsubmit ) == 'function' )
 157      {
 158          var bRet = oForm.onsubmit() ;
 159          if ( bRet != null && bRet === false )
 160              return ;
 161      }
 162  
 163      // Submit the form.
 164      oForm.submit() ;
 165  }
 166  
 167  FCKSaveCommand.prototype.GetState = function()
 168  {
 169      return FCK_TRISTATE_OFF ;
 170  }
 171  
 172  // ### NewPage
 173  var FCKNewPageCommand = function()
 174  {
 175      this.Name = 'NewPage' ;
 176  }
 177  
 178  FCKNewPageCommand.prototype.Execute = function()
 179  {
 180      FCKUndo.SaveUndoStep() ;
 181      FCK.SetHTML( '' ) ;
 182      FCKUndo.Typing = true ;
 183  //    FCK.SetHTML( FCKBrowserInfo.IsGecko ? '&nbsp;' : '' ) ;
 184  //    FCK.SetHTML( FCKBrowserInfo.IsGecko ? GECKO_BOGUS : '' ) ;
 185  }
 186  
 187  FCKNewPageCommand.prototype.GetState = function()
 188  {
 189      return FCK_TRISTATE_OFF ;
 190  }
 191  
 192  // ### Source button
 193  var FCKSourceCommand = function()
 194  {
 195      this.Name = 'Source' ;
 196  }
 197  
 198  FCKSourceCommand.prototype.Execute = function()
 199  {
 200      if ( FCKConfig.SourcePopup )    // Until v2.2, it was mandatory for FCKBrowserInfo.IsGecko.
 201      {
 202          var iWidth    = FCKConfig.ScreenWidth * 0.65 ;
 203          var iHeight    = FCKConfig.ScreenHeight * 0.65 ;
 204          FCKDialog.OpenDialog( 'FCKDialog_Source', FCKLang.Source, 'dialog/fck_source.html', iWidth, iHeight, null, null, true ) ;
 205      }
 206      else
 207          FCK.SwitchEditMode() ;
 208  }
 209  
 210  FCKSourceCommand.prototype.GetState = function()
 211  {
 212      return ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ? FCK_TRISTATE_OFF : FCK_TRISTATE_ON ) ;
 213  }
 214  
 215  // ### Undo
 216  var FCKUndoCommand = function()
 217  {
 218      this.Name = 'Undo' ;
 219  }
 220  
 221  FCKUndoCommand.prototype.Execute = function()
 222  {
 223      if ( FCKBrowserInfo.IsIE )
 224          FCKUndo.Undo() ;
 225      else
 226          FCK.ExecuteNamedCommand( 'Undo' ) ;
 227  }
 228  
 229  FCKUndoCommand.prototype.GetState = function()
 230  {
 231      if ( FCKBrowserInfo.IsIE )
 232          return ( FCKUndo.CheckUndoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ;
 233      else
 234          return FCK.GetNamedCommandState( 'Undo' ) ;
 235  }
 236  
 237  // ### Redo
 238  var FCKRedoCommand = function()
 239  {
 240      this.Name = 'Redo' ;
 241  }
 242  
 243  FCKRedoCommand.prototype.Execute = function()
 244  {
 245      if ( FCKBrowserInfo.IsIE )
 246          FCKUndo.Redo() ;
 247      else
 248          FCK.ExecuteNamedCommand( 'Redo' ) ;
 249  }
 250  
 251  FCKRedoCommand.prototype.GetState = function()
 252  {
 253      if ( FCKBrowserInfo.IsIE )
 254          return ( FCKUndo.CheckRedoState() ? FCK_TRISTATE_OFF : FCK_TRISTATE_DISABLED ) ;
 255      else
 256          return FCK.GetNamedCommandState( 'Redo' ) ;
 257  }
 258  
 259  // ### Page Break
 260  var FCKPageBreakCommand = function()
 261  {
 262      this.Name = 'PageBreak' ;
 263  }
 264  
 265  FCKPageBreakCommand.prototype.Execute = function()
 266  {
 267  //    var e = FCK.EditorDocument.createElement( 'CENTER' ) ;
 268  //    e.style.pageBreakAfter = 'always' ;
 269  
 270      // Tidy was removing the empty CENTER tags, so the following solution has 
 271      // been found. It also validates correctly as XHTML 1.0 Strict.
 272      var e = FCK.EditorDocument.createElement( 'DIV' ) ;
 273      e.style.pageBreakAfter = 'always' ;
 274      e.innerHTML = '<span style="DISPLAY:none">&nbsp;</span>' ;
 275      
 276      var oFakeImage = FCKDocumentProcessor_CreateFakeImage( 'FCK__PageBreak', e ) ;
 277      oFakeImage    = FCK.InsertElement( oFakeImage ) ;
 278  }
 279  
 280  FCKPageBreakCommand.prototype.GetState = function()
 281  {
 282      return 0 ; // FCK_TRISTATE_OFF
 283  }
 284  
 285  // FCKUnlinkCommand - by Johnny Egeland (johnny@coretrek.com)
 286  var FCKUnlinkCommand = function()
 287  {
 288      this.Name = 'Unlink' ;
 289  }
 290  
 291  FCKUnlinkCommand.prototype.Execute = function()
 292  {
 293      if ( FCKBrowserInfo.IsGecko )
 294      {
 295          var oLink = FCK.Selection.MoveToAncestorNode( 'A' ) ;
 296          if ( oLink ) 
 297              FCK.Selection.SelectNode( oLink ) ;
 298      }
 299      
 300      FCK.ExecuteNamedCommand( this.Name ) ;
 301  
 302      if ( FCKBrowserInfo.IsGecko )
 303          FCK.Selection.Collapse( true ) ;
 304  }
 305  
 306  FCKUnlinkCommand.prototype.GetState = function()
 307  {
 308      return FCK.GetNamedCommandState( this.Name ) ;
 309  }