BVB Source Codes

Jie Yang v0.6.3 article system Show fckdialog.html Source code

Return Download Jie Yang v0.6.3 article system: download fckdialog.html Source code - Download Jie Yang v0.6.3 article system Source code - Type:.html
  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
  2. <!--
  3. * FCKeditor - The text editor for Internet - http://www.fckeditor.net
  4. * Copyright (C) 2003-2008 Frederico Caldeira Knabben
  5. *
  6. * == BEGIN LICENSE ==
  7. *
  8. * Licensed under the terms of any of the following licenses at your
  9. * choice:
  10. *
  11. *  - GNU General Public License Version 2 or later (the "GPL")
  12. *    http://www.gnu.org/licenses/gpl.html
  13. *
  14. *  - GNU Lesser General Public License Version 2.1 or later (the "LGPL")
  15. *    http://www.gnu.org/licenses/lgpl.html
  16. *
  17. *  - Mozilla Public License Version 1.1 or later (the "MPL")
  18. *    http://www.mozilla.org/MPL/MPL-1.1.html
  19. *
  20. * == END LICENSE ==
  21. *
  22. * This page is used by all dialog box as the container.
  23. -->
  24. <html xmlns="http://www.w3.org/1999/xhtml">
  25.         <head>
  26.                 <title></title>
  27.                 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  28.                 <meta name="robots" content="noindex, nofollow" />
  29.                 <script type="text/javascript">
  30. // Domain relaxation logic.
  31. (function()
  32. {
  33.         var d = document.domain ;
  34.  
  35.         while ( true )
  36.         {
  37.                 // Test if we can access a parent property.
  38.                 try
  39.                 {
  40.                         var parentDomain = ( Args().TopWindow || E ).document.domain ;
  41.  
  42.                         if ( document.domain != parentDomain )
  43.                                 document.domain = parentDomain ;
  44.  
  45.                         break ;
  46.                 }
  47.                 catch( e ) {}
  48.  
  49.                 // Remove a domain part: www.mytest.example.com => mytest.example.com => example.com ...
  50.                 d = d.replace( /.*?(?:\.|$)/, '' ) ;
  51.  
  52.                 if ( d.length == 0 )
  53.                         break ;         // It was not able to detect the domain.
  54.  
  55.                 document.domain = d ;
  56.         }
  57. })() ;
  58.  
  59. var E = frameElement._DialogArguments.Editor ;
  60.  
  61. // It seems referencing to frameElement._DialogArguments directly would lead to memory leaks in IE.
  62. // So let's use functions to access its members instead.
  63. function Args()
  64. {
  65.         return frameElement._DialogArguments ;
  66. }
  67.  
  68. function ParentDialog( dialog )
  69. {
  70.         return dialog ? dialog._ParentDialog : frameElement._ParentDialog ;
  71. }
  72.  
  73. var FCK                         = E.FCK ;
  74. var FCKTools            = E.FCKTools ;
  75. var FCKDomTools         = E.FCKDomTools ;
  76. var FCKDialog           = E.FCKDialog ;
  77. var FCKBrowserInfo      = E.FCKBrowserInfo ;
  78. var FCKConfig           = E.FCKConfig ;
  79.  
  80. // Steal the focus so that the caret would no longer stay in the editor iframe.
  81. window.focus() ;
  82.  
  83. // Sets the Skin CSS
  84. document.write( FCKTools.GetStyleHtml( FCKConfig.SkinDialogCSS ) ) ;
  85.  
  86. // Sets the language direction.
  87. var langDir = document.documentElement.dir = E.FCKLang.Dir ;
  88.  
  89. // For IE6-, the fck_dialog_ie6.js is loaded, used to fix limitations in the browser.
  90. if ( FCKBrowserInfo.IsIE && !FCKBrowserInfo.IsIE7 )
  91.         document.write( '<' + 'script type="text/javascript" src="' + FCKConfig.SkinPath + 'fck_dialog_ie6.js"><' + '\/script>' ) ;
  92.  
  93. FCKTools.RegisterDollarFunction( window ) ;
  94.  
  95. // Resize related functions.
  96. var Sizer = function()
  97. {
  98.         var bAutoSize = false ;
  99.  
  100.         var retval = {
  101.                 // Sets whether the dialog should auto-resize according to its content's height.
  102.                 SetAutoSize : function( autoSize )
  103.                 {
  104.                         bAutoSize = autoSize ;
  105.                         this.RefreshSize() ;
  106.                 },
  107.  
  108.                 // Fit the dialog container's layout to the inner iframe's external size.
  109.                 RefreshContainerSize : function()
  110.                 {
  111.                         var frmMain = $( 'frmMain' ) ;
  112.  
  113.                         if ( frmMain )
  114.                         {
  115.                                 // Get the container size.
  116.                                 var height = $( 'contents' ).offsetHeight ;
  117.  
  118.                                 // Subtract the size of other elements.
  119.                                 height -= $( 'TitleArea' ).offsetHeight ;
  120.                                 height -= $( 'TabsRow' ).offsetHeight ;
  121.                                 height -= $( 'PopupButtons' ).offsetHeight ;
  122.  
  123.                                 frmMain.style.height = Math.max( height, 0 ) + 'px' ;
  124.                         }
  125.                 },
  126.  
  127.                 // Resize and re-layout the dialog.
  128.                 // Triggers the onresize event for the layout logic.
  129.                 ResizeDialog : function( width, height )
  130.                 {
  131.                         FCKDomTools.SetElementStyles( window.frameElement,
  132.                                         {
  133.                                                 'width' : width + 'px',
  134.                                                 'height' : height + 'px'
  135.                                         } ) ;
  136.  
  137.                         // If the skin have defined a function for resize fixes, call it now.
  138.                         if ( typeof window.DoResizeFixes == 'function' )
  139.                                 window.DoResizeFixes() ;
  140.                 },
  141.  
  142.                 // if bAutoSize is true, automatically fit the dialog size and layout to
  143.                 // accomodate the inner iframe's internal height.
  144.                 // if bAutoSize is false, then only the layout logic for the dialog decorations
  145.                 // is run to accomodate the inner iframe's external height.
  146.                 RefreshSize : function()
  147.                 {
  148.                         if ( bAutoSize )
  149.                         {
  150.                                 var frmMain             = $( 'frmMain' ) ;
  151.                                 var innerDoc    = frmMain.contentWindow.document ;
  152.                                 var isStrict    = FCKTools.IsStrictMode( innerDoc ) ;
  153.  
  154.                                 // Get the size of the frame contents.
  155.                                 var innerWidth  = isStrict ? innerDoc.documentElement.scrollWidth : innerDoc.body.scrollWidth ;
  156.                                 var innerHeight = isStrict ? innerDoc.documentElement.scrollHeight : innerDoc.body.scrollHeight ;
  157.  
  158.                                 // Get the current frame size.
  159.                                 var frameSize = FCKTools.GetViewPaneSize( frmMain.contentWindow ) ;
  160.  
  161.                                 var deltaWidth  = innerWidth - frameSize.Width ;
  162.                                 var deltaHeight = innerHeight - frameSize.Height ;
  163.  
  164.                                 // If the contents fits the current size.
  165.                                 if ( deltaWidth <= 0 && deltaHeight <= 0 )
  166.                                         return ;
  167.  
  168.                                 var dialogWidth         = frameElement.offsetWidth + Math.max( deltaWidth, 0 ) ;
  169.                                 var dialogHeight        = frameElement.offsetHeight + Math.max( deltaHeight, 0 ) ;
  170.  
  171.                                 this.ResizeDialog( dialogWidth, dialogHeight ) ;
  172.                         }
  173.                         this.RefreshContainerSize() ;
  174.                 }
  175.         }
  176.  
  177.         /**
  178.          * Safari seems to have a bug with the time when RefreshSize() is executed - it
  179.          * thinks frmMain's innerHeight is 0 if we query the value too soon after the
  180.          * page is loaded in some circumstances. (#1316)
  181.          * TODO : Maybe this is not needed anymore after #35.
  182.          */
  183.         if ( FCKBrowserInfo.IsSafari )
  184.         {
  185.                 var originalRefreshSize = retval.RefreshSize ;
  186.                 retval.RefreshSize = function()
  187.                 {
  188.                         FCKTools.SetTimeout( originalRefreshSize, 1, retval ) ;
  189.                 }
  190.         }
  191.         window.onresize = function()
  192.         {
  193.                 retval.RefreshContainerSize() ;
  194.         }
  195.         window.SetAutoSize = FCKTools.Bind( retval, retval.SetAutoSize ) ;
  196.         return retval ;
  197. }() ;
  198. // Manages the throbber image that appears if the inner part of dialog is taking too long to load.
  199. var Throbber = function()
  200. {
  201.         var timer ;
  202.         var updateThrobber = function()
  203.         {
  204.                 var throbberParent = $( 'throbberBlock' ) ;
  205.                 var throbberBlocks = throbberParent.childNodes ;
  206.                 var lastClass = throbberParent.lastChild.className ;
  207.                 // From the last to the second one, copy the class from the previous one.
  208.                 for ( var i = throbberBlocks.length - 1 ; i > 0 ; i-- )
  209.                         throbberBlocks[i].className = throbberBlocks[i-1].className ;
  210.  
  211.                 // For the first one, copy the last class (rotation).
  212.                 throbberBlocks[0].className = lastClass ;
  213.         }
  214.  
  215.         return {
  216.                 Show : function( waitMilliseconds )
  217.                 {
  218.                         // Auto-setup the Show function to be called again after the
  219.                         // requested amount of time.
  220.                         if ( waitMilliseconds && waitMilliseconds > 0 )
  221.                         {
  222.                                 timer = FCKTools.SetTimeout( this.Show, waitMilliseconds, this, null, window ) ;
  223.                                 return ;
  224.                         }
  225.  
  226.                         var throbberParent = $( 'throbberBlock' ) ;
  227.  
  228.                         // Create the throbber blocks.
  229.                         var classIds = [ 1,2,3,4,5,4,3,2 ] ;
  230.                         while ( classIds.length > 0 )
  231.                                 throbberParent.appendChild( document.createElement( 'div' ) ).className = ' throbber_' + classIds.shift() ;
  232.  
  233.                         // Center the throbber.
  234.                         var frm = $( 'contents' ) ;
  235.                         var frmCoords = FCKTools.GetDocumentPosition( window, frm ) ;
  236.                         var x = frmCoords.x + ( frm.offsetWidth - throbberParent.offsetWidth ) / 2 ;
  237.                         var y = frmCoords.y + ( frm.offsetHeight - throbberParent.offsetHeight ) / 2 ;
  238.                         throbberParent.style.left = parseInt( x, 10 ) + 'px' ;
  239.                         throbberParent.style.top = parseInt( y, 10 ) + 'px' ;
  240.  
  241.                         // Show it.
  242.                         throbberParent.style.visibility = ''  ;
  243.  
  244.                         // Setup the animation interval.
  245.                         timer = setInterval( updateThrobber, 100 ) ;
  246.                 },
  247.  
  248.                 Hide : function()
  249.                 {
  250.                         if ( timer )
  251.                         {
  252.                                 clearInterval( timer ) ;
  253.                                 timer = null ;
  254.                         }
  255.  
  256.                         var throbberParent = document.getElementById( 'throbberBlock' ) ;
  257.                         if ( throbberParent )
  258.                                 FCKDomTools.RemoveNode( throbberParent ) ;
  259.                 }
  260.         } ;
  261. }() ;
  262.  
  263. // Drag and drop handlers.
  264. var DragAndDrop = function()
  265. {
  266.         var registeredWindows = [] ;
  267.         var lastCoords ;
  268.         var currentPos ;
  269.  
  270.         var cleanUpHandlers = function()
  271.         {
  272.                 for ( var i = 0 ; i < registeredWindows.length ; i++ )
  273.                 {
  274.                         FCKTools.RemoveEventListener( registeredWindows[i].document, 'mousemove', dragMouseMoveHandler ) ;
  275.                         FCKTools.RemoveEventListener( registeredWindows[i].document, 'mouseup', dragMouseUpHandler ) ;
  276.                 }
  277.         }
  278.  
  279.         var dragMouseMoveHandler = function( evt )
  280.         {
  281.                 if ( !lastCoords )
  282.                         return ;
  283.  
  284.                 if ( !evt )
  285.                         evt = FCKTools.GetElementDocument( this ).parentWindow.event ;
  286.  
  287.                 // Updated the last coordinates.
  288.                 var currentCoords =
  289.                 {
  290.                         x : evt.screenX,
  291.                         y : evt.screenY
  292.                 } ;
  293.  
  294.                 currentPos =
  295.                 {
  296.                         x : currentPos.x + ( currentCoords.x - lastCoords.x ),
  297.                         y : currentPos.y + ( currentCoords.y - lastCoords.y )
  298.                 } ;
  299.  
  300.                 lastCoords = currentCoords ;
  301.  
  302.                 frameElement.style.left = currentPos.x + 'px' ;
  303.                 frameElement.style.top  = currentPos.y + 'px' ;
  304.  
  305.                 if ( evt.preventDefault )
  306.                         evt.preventDefault() ;
  307.                 else
  308.                         evt.returnValue = false ;
  309.         }
  310.  
  311.         var dragMouseUpHandler = function( evt )
  312.         {
  313.                 if ( !lastCoords )
  314.                         return ;
  315.                 if ( !evt )
  316.                         evt = FCKTools.GetElementDocument( this ).parentWindow.event ;
  317.                 cleanUpHandlers() ;
  318.                 lastCoords = null ;
  319.         }
  320.  
  321.         return {
  322.  
  323.                 MouseDownHandler : function( evt )
  324.                 {
  325.                         var view = null ;
  326.                         if ( !evt )
  327.                         {
  328.                                 view = FCKTools.GetElementDocument( this ).parentWindow ;
  329.                                 evt = view.event ;
  330.                         }
  331.                         else
  332.                                 view = evt.view ;
  333.  
  334.                         var target = evt.srcElement || evt.target ;
  335.                         if ( target.id == 'closeButton' || target.className == 'PopupTab' || target.className == 'PopupTabSelected' )
  336.                                 return ;
  337.  
  338.                         lastCoords =
  339.                         {
  340.                                 x : evt.screenX,
  341.                                 y : evt.screenY
  342.                         } ;
  343.  
  344.                         // Save the current IFRAME position.
  345.                         currentPos =
  346.                         {
  347.                                 x : parseInt( FCKDomTools.GetCurrentElementStyle( frameElement, 'left' ), 10 ),
  348.                                 y : parseInt( FCKDomTools.GetCurrentElementStyle( frameElement, 'top' ), 10 )
  349.                         } ;
  350.  
  351.                         for ( var i = 0 ; i < registeredWindows.length ; i++ )
  352.                         {
  353.                                 FCKTools.AddEventListener( registeredWindows[i].document, 'mousemove', dragMouseMoveHandler ) ;
  354.                                 FCKTools.AddEventListener( registeredWindows[i].document, 'mouseup', dragMouseUpHandler ) ;
  355.                         }
  356.  
  357.                         if ( evt.preventDefault )
  358.                                 evt.preventDefault() ;
  359.                         else
  360.                                 evt.returnValue = false ;
  361.                 },
  362.  
  363.                 RegisterHandlers : function( w )
  364.                 {
  365.                         registeredWindows.push( w ) ;
  366.                 }
  367.         }
  368. }() ;
  369.  
  370. // Selection related functions.
  371. //(Became simple shortcuts after the fix for #1990)
  372. var Selection =
  373. {
  374.         /**
  375.          * Ensures that the editing area contains an active selection. This is a
  376.          * requirement for IE, as it looses the selection when the focus moves to other
  377.          * frames.
  378.          */
  379.         EnsureSelection : function()
  380.         {
  381.                 FCK.Selection.Restore() ;
  382.         },
  383.  
  384.         /**
  385.          * Get the FCKSelection object for the editor instance.
  386.          */
  387.         GetSelection : function()
  388.         {
  389.                 return FCK.Selection ;
  390.         },
  391.  
  392.         /**
  393.          * Get the selected element in the editing area (for object selections).
  394.          */
  395.         GetSelectedElement : function()
  396.         {
  397.                 return FCK.Selection.GetSelectedElement() ;
  398.         }
  399. }
  400.  
  401. // Tab related functions.
  402. var Tabs = function()
  403. {
  404.         // Only element ids should be stored here instead of element references since setSelectedTab and TabDiv_OnClick
  405.         // would build circular references with the element references inside and cause memory leaks in IE6.
  406.         var oTabs = new Object() ;
  407.  
  408.         var setSelectedTab = function( tabCode )
  409.         {
  410.                 for ( var sCode in oTabs )
  411.                 {
  412.                         if ( sCode == tabCode )
  413.                                 $( oTabs[sCode] ).className = 'PopupTabSelected' ;
  414.                         else
  415.                                 $( oTabs[sCode] ).className = 'PopupTab' ;
  416.                 }
  417.  
  418.                 if ( typeof( window.frames["frmMain"].OnDialogTabChange ) == 'function' )
  419.                         window.frames["frmMain"].OnDialogTabChange( tabCode ) ;
  420.         }
  421.  
  422.         function TabDiv_OnClick()
  423.         {
  424.                 setSelectedTab( this.TabCode ) ;
  425.         }
  426.  
  427.         window.AddTab = function( tabCode, tabText, startHidden )
  428.         {
  429.                 if ( typeof( oTabs[ tabCode ] ) != 'undefined' )
  430.                         return ;
  431.  
  432.                 var eTabsRow = $( 'Tabs' ) ;
  433.  
  434.                 var oCell = eTabsRow.insertCell(  eTabsRow.cells.length - 1 ) ;
  435.                 oCell.noWrap = true ;
  436.  
  437.                 var oDiv = document.createElement( 'DIV' ) ;
  438.                 oDiv.className = 'PopupTab' ;
  439.                 oDiv.innerHTML = tabText ;
  440.                 oDiv.TabCode = tabCode ;
  441.                 oDiv.onclick = TabDiv_OnClick ;
  442.                 oDiv.id = Math.random() ;
  443.  
  444.                 if ( startHidden )
  445.                         oDiv.style.display = 'none' ;
  446.  
  447.                 eTabsRow = $( 'TabsRow' ) ;
  448.  
  449.                 oCell.appendChild( oDiv ) ;
  450.  
  451.                 if ( eTabsRow.style.display == 'none' )
  452.                 {
  453.                         var eTitleArea = $( 'TitleArea' ) ;
  454.                         eTitleArea.className = 'PopupTitle' ;
  455.  
  456.                         oDiv.className = 'PopupTabSelected' ;
  457.                         eTabsRow.style.display = '' ;
  458.  
  459.                         if ( window.onresize )
  460.                                 window.onresize() ;
  461.                 }
  462.  
  463.                 oTabs[ tabCode ] = oDiv.id ;
  464.  
  465.                 FCKTools.DisableSelection( oDiv ) ;
  466.         } ;
  467.  
  468.         window.SetSelectedTab = setSelectedTab ;
  469.  
  470.         window.SetTabVisibility = function( tabCode, isVisible )
  471.         {
  472.                 var oTab = $( oTabs[ tabCode ] ) ;
  473.                 oTab.style.display = isVisible ? '' : 'none' ;
  474.  
  475.                 if ( ! isVisible && oTab.className == 'PopupTabSelected' )
  476.                 {
  477.                         for ( var sCode in oTabs )
  478.                         {
  479.                                 if ( $( oTabs[sCode] ).style.display != 'none' )
  480.                                 {
  481.                                         setSelectedTab( sCode ) ;
  482.                                         break ;
  483.                                 }
  484.                         }
  485.                 }
  486.         } ;
  487. }() ;
  488.  
  489. // readystatechange handler for registering drag and drop handlers in cover
  490. // iframes, defined out here to avoid memory leak.
  491. // Do NOT put this function as a private function as it will induce memory leak
  492. // in IE and it's not detectable with Drip or sIEve and undetectable leaks are
  493. // really nasty (sigh).
  494. var onReadyRegister = function()
  495. {
  496.         if ( this.readyState != 'complete' )
  497.                 return ;
  498.         DragAndDrop.RegisterHandlers( this.contentWindow ) ;
  499. } ;
  500. // The business logic of the dialog, dealing with operational things like
  501. // dialog open/dialog close/enable/disable/etc.
  502. (function()
  503. {
  504.         var setOnKeyDown = function( targetDocument )
  505.         {
  506.                 targetDocument.onkeydown = function ( e )
  507.                 {
  508.                         e = e || event || this.parentWindow.event ;
  509.                         switch ( e.keyCode )
  510.                         {
  511.                                 case 13 :               // ENTER
  512.                                         var oTarget = e.srcElement || e.target ;
  513.                                         if ( oTarget.tagName == 'TEXTAREA' )
  514.                                                 return true ;
  515.                                         Ok() ;
  516.                                         return false ;
  517.                                 case 27 :               // ESC
  518.                                         Cancel() ;
  519.                                         return false ;
  520.                         }
  521.                         return true ;
  522.                 }
  523.         } ;
  524.         var contextMenuBlocker = function( e )
  525.         {
  526.                 var sTagName = e.target.tagName ;
  527.                 if ( ! ( ( sTagName == "INPUT" && e.target.type == "text" ) || sTagName == "TEXTAREA" ) )
  528.                         e.preventDefault() ;
  529.         } ;
  530.         var disableContextMenu = function( targetDocument )
  531.         {
  532.                 if ( FCKBrowserInfo.IsIE )
  533.                         return ;
  534.                 targetDocument.addEventListener( 'contextmenu', contextMenuBlocker, true ) ;
  535.         } ;
  536.         // Program entry point.
  537.         window.Init = function()
  538.         {
  539.                 // Start the throbber timer.
  540.                 Throbber.Show( 1000 ) ;
  541.                 Sizer.RefreshContainerSize() ;
  542.                 LoadInnerDialog() ;
  543.                 FCKTools.DisableSelection( document.body ) ;
  544.                 // Make the title area draggable.
  545.                 var titleElement = $( 'header' ) ;
  546.                 titleElement.onmousedown = DragAndDrop.MouseDownHandler ;
  547.                 // Connect mousemove and mouseup events from dialog frame and outer window to dialog dragging logic.
  548.                 DragAndDrop.RegisterHandlers( window ) ;
  549.                 DragAndDrop.RegisterHandlers( Args().TopWindow ) ;
  550.                 // Disable the previous dialog if it exists.
  551.                 if ( ParentDialog() )
  552.                 {
  553.                         ParentDialog().contentWindow.SetEnabled( false ) ;
  554.                         if ( FCKBrowserInfo.IsIE && !FCKBrowserInfo.IsIE7 )
  555.                         {
  556.                                 var currentParent = ParentDialog() ;
  557.                                 while ( currentParent )
  558.                                 {
  559.                                         var blockerFrame = currentParent.contentWindow.$( 'blocker' ) ;
  560.                                         if ( blockerFrame.readyState == 'complete' )
  561.                                                 DragAndDrop.RegisterHandlers( blockerFrame.contentWindow ) ;
  562.                                         else
  563.                                                 blockerFrame.onreadystatechange = onReadyRegister ;
  564.                                         currentParent = ParentDialog( currentParent ) ;
  565.                                 }
  566.                         }
  567.                         else
  568.                         {
  569.                                 var currentParent = ParentDialog() ;
  570.                                 while ( currentParent )
  571.                                 {
  572.                                         DragAndDrop.RegisterHandlers( currentParent.contentWindow ) ;
  573.                                         currentParent = ParentDialog( currentParent ) ;
  574.                                 }
  575.                         }
  576.                 }
  577.                 // If this is the only dialog on screen, enable the background cover.
  578.                 if ( FCKBrowserInfo.IsIE && !FCKBrowserInfo.IsIE7 )
  579.                 {
  580.                         var blockerFrame = FCKDialog.GetCover().firstChild ;
  581.                         if ( blockerFrame.readyState == 'complete' )
  582.                                 DragAndDrop.RegisterHandlers( blockerFrame.contentWindow ) ;
  583.                         else
  584.                                 blockerFrame.onreadystatechange = onReadyRegister;
  585.                 }
  586.                 // Add Enter/Esc hotkeys and disable context menu for the dialog.
  587.                 setOnKeyDown( document ) ;
  588.                 disableContextMenu( document ) ;
  589.         } ;
  590.         window.LoadInnerDialog = function()
  591.         {
  592.                 if ( window.onresize )
  593.                         window.onresize() ;
  594.                 // First of all, translate the dialog box contents.
  595.                 E.FCKLanguageManager.TranslatePage( document ) ;
  596.                 // Create the IFRAME that holds the dialog contents.
  597.                 $( 'innerContents' ).innerHTML = '<iframe id="frmMain" src="' + Args().Page + '" name="frmMain" frameborder="0" width="100%" height="100%" scrolling="auto" style="visibility: hidden;" allowtransparency="true"></iframe>' ;
  598.         } ;
  599.  
  600.         window.InnerDialogLoaded = function()
  601.         {
  602.                 // If the dialog has been closed before the iframe is loaded, do nothing.
  603.                 if ( !frameElement.parentNode )
  604.                         return null ;
  605.  
  606.                 Throbber.Hide() ;
  607.  
  608.                 var frmMain = $('frmMain') ;
  609.                 var innerWindow = frmMain.contentWindow ;
  610.                 var innerDoc = innerWindow.document ;
  611.  
  612.                 // Show the loaded iframe.
  613.                 frmMain.style.visibility = '' ;
  614.  
  615.                 // Set the language direction.
  616.                 innerDoc.documentElement.dir = langDir ;
  617.  
  618.                 // Sets the Skin CSS.
  619.                 innerDoc.write( FCKTools.GetStyleHtml( FCKConfig.SkinDialogCSS ) ) ;
  620.  
  621.                 setOnKeyDown( innerDoc ) ;
  622.                 disableContextMenu( innerDoc ) ;
  623.  
  624.                 Sizer.RefreshContainerSize();
  625.  
  626.                 DragAndDrop.RegisterHandlers( innerWindow ) ;
  627.  
  628.                 innerWindow.focus() ;
  629.  
  630.                 return E ;
  631.         } ;
  632.  
  633.         window.SetOkButton = function( showIt )
  634.         {
  635.                 $('btnOk').style.visibility = ( showIt ? '' : 'hidden' ) ;
  636.         } ;
  637.  
  638.         window.Ok = function()
  639.         {
  640.                 Selection.EnsureSelection() ;
  641.  
  642.                 var frmMain = window.frames["frmMain"] ;
  643.  
  644.                 if ( frmMain.Ok && frmMain.Ok() )
  645.                         CloseDialog() ;
  646.                 else
  647.                         frmMain.focus() ;
  648.         } ;
  649.  
  650.         window.Cancel = function( dontFireChange )
  651.         {
  652.                 Selection.EnsureSelection() ;
  653.                 return CloseDialog( dontFireChange ) ;
  654.         } ;
  655.  
  656.         window.CloseDialog = function( dontFireChange )
  657.         {
  658.                 Throbber.Hide() ;
  659.  
  660.                 // Points the src to a non-existent location to avoid loading errors later, in case the dialog
  661.                 // haven't been completed loaded at this point.
  662.                 if ( $( 'frmMain' ) )
  663.                         $( 'frmMain' ).src = FCKTools.GetVoidUrl() ;
  664.  
  665.                 if ( !dontFireChange && !FCK.EditMode )
  666.                 {
  667.                         // All dialog windows, by default, will fire the "OnSelectionChange"
  668.                         // event, no matter the Ok or Cancel button has been pressed.
  669.                         // It seems that OnSelectionChange may enter on a concurrency state
  670.                         // on some situations (#1965), so we should put the event firing in
  671.                         // the execution queue instead of executing it immediately.
  672.                         setTimeout( function()
  673.                                 {
  674.                                         FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  675.                                 }, 0 ) ;
  676.                 }
  677.  
  678.                 FCKDialog.OnDialogClose( window ) ;
  679.         } ;
  680.  
  681.         window.SetEnabled = function( isEnabled )
  682.         {
  683.                 var cover = $( 'cover' ) ;
  684.                 cover.style.display = isEnabled ? 'none' : '' ;
  685.  
  686.                 if ( FCKBrowserInfo.IsIE && !FCKBrowserInfo.IsIE7 )
  687.                 {
  688.                         if ( !isEnabled )
  689.                         {
  690.                                 // Inser the blocker IFRAME before the cover.
  691.                                 var blocker = document.createElement( 'iframe' ) ;
  692.                                 blocker.src = FCKTools.GetVoidUrl() ;
  693.                                 blocker.hideFocus = true ;
  694.                                 blocker.frameBorder = 0 ;
  695.                                 blocker.id = blocker.className = 'blocker' ;
  696.                                 cover.appendChild( blocker ) ;
  697.                         }
  698.                         else
  699.                         {
  700.                                 var blocker = $( 'blocker' ) ;
  701.                                 if ( blocker && blocker.parentNode )
  702.                                         blocker.parentNode.removeChild( blocker ) ;
  703.                         }
  704.                 }
  705.         } ;
  706. })() ;
  707.                 </script>
  708.         </head>
  709.         <body onload="Init();" class="PopupBody">
  710.                 <div class="contents" id="contents">
  711.                         <div id="header">
  712.                                 <div id="TitleArea" class="PopupTitle PopupTitleBorder">
  713.                                         <script type="text/javascript">
  714. document.write( Args().Title ) ;
  715.                                         </script>
  716.                                         <div id="closeButton" onclick="Cancel();"></div>
  717.                                 </div>
  718.                                 <div id="TabsRow" class="PopupTabArea" style="display: none">
  719.                                         <table border="0" cellpadding="0" cellspacing="0" width="100%">
  720.                                                 <tr id="Tabs">
  721.                                                         <td class="PopupTabEmptyArea">&nbsp;</td>
  722.                                                         <td class="PopupTabEmptyArea" width="100%">&nbsp;</td>
  723.                                                 </tr>
  724.                                         </table>
  725.                                 </div>
  726.                         </div>
  727.                         <div id="innerContents"></div>
  728.                         <div id="PopupButtons" class="PopupButtons">
  729.                                 <table border="0" cellpadding="0" cellspacing="0">
  730.                                         <tr>
  731.                                                 <td width="100%">&nbsp;</td>
  732.                                                 <td nowrap="nowrap">
  733.                                                         <input id="btnOk" style="visibility: hidden;" type="button" value="Ok" class="Button" onclick="Ok();" fckLang="DlgBtnOK" />
  734.                                                         &nbsp;
  735.                                                         <input id="btnCancel" type="button" value="Cancel" class="Button" onclick="Cancel();" fckLang="DlgBtnCancel" />
  736.                                                 </td>
  737.                                         </tr>
  738.                                 </table>
  739.                         </div>
  740.                 </div>
  741.                 <div class="tl"></div>
  742.                 <div class="tc"></div>
  743.                 <div class="tr"></div>
  744.                 <div class="ml"></div>
  745.                 <div class="mr"></div>
  746.                 <div class="bl"></div>
  747.                 <div class="bc"></div>
  748.                 <div class="br"></div>
  749.                 <div class="cover" id="cover" style="display:none"></div>
  750.                 <div id="throbberBlock" style="position: absolute; visibility: hidden"></div>
  751.                 <script type="text/javascript">
  752.                         // Set the class name for language direction.
  753.                         document.body.className += ' ' + langDir ;
  754.  
  755.                         var cover = $( 'cover' ) ;
  756.                         cover.style.backgroundColor = FCKConfig.BackgroundBlockerColor ;
  757.                         FCKDomTools.SetOpacity( cover, FCKConfig.BackgroundBlockerOpacity ) ;
  758.                 </script>
  759.         </body>
  760. </html>
  761.  
downloadfckdialog.html Source code - Download Jie Yang v0.6.3 article system Source code
Related Source Codes/Software:
Jilin classification information release system v5.0 trial version - A ready-made classifieds site publishing system, h... 2016-09-21
Linyi CMS v6.5 market classification information - A. supply and demand information function: informa... 2016-09-21
Tesco discount net SQL version - And presentations, faster. 2016-09-21
- electronic enterprise website management system In a fully functional version - Super suitable for enterprise agents build a corpo... 2016-09-21
Rio mesh network hard disk system v3.0 - System functions: 1, increase the progress of Asp... 2016-09-21
Classified information network business in suzhou - Overall module: classification of supply and deman... 2016-09-21
NPOINT virtual host v1.7.0 formal version management system - The system main function is introduced 2016-09-21
IDC sales web site - Beautiful IDC sales web site source code 2016-09-21
Oo 126 CMS movie site system - This procedure ASP + ACC/ASP + SQL, using new kern... 2016-09-21
Pcook CMS bubble guest v3.0 SDCMS version - Developed by Asp+Access, and meet the needs of sma... 2016-09-21
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top