RZdefaultLinkOption(linkname,'linkpathname') //prepended pathname (supported by RTE)
RZdefaultLinkOption(linkname,'linknewsection') //list of templates that can start new sections
RZdefaultLinkOption(linkname,'linkdisplaydefault') //default linkdisplay
RZdefaultLinkOption(linkname,'linktemplatedefault') //default template
RZdefaultLinkOption(linkname,'linkfilenamedefault') //default path/filename
RZdefaultLinkOption(linkname,'linkautocontinue') //Auto click Continue button
RZdefaultLinkOption(linkname,'nexturl') //next editform for all templates
RZdefaultLinkOption(linkname,'set') //Set passed to dependent module
RZdefaultLinkOption(linkname,'linkparent') //parent that added link
RZdefaultLinkOption(linkname,'linkmodule') //list module
//----- Determine link parent (defined by new or edit button - single level menu)
var linkparent = RZ.link[linkname].linkparent
if (linkparent == '')
{
if (RZ.permissions_parent != '') //this page is surogate parent (e.g. editlist)
linkparent = RZ.permissions_parent
else
linkparent = RZ.page_key
}
RZ.link[linkname].linkparent = linkparent
//----- Convert nexturl to absolute url (some RTE calls have property defined at this time)
var nexturl = RZ.link[linkname].nexturl
if (nexturl != '')
RZ.link[linkname].nexturl = RZabsoluteUrl(nexturl)
//----- Compute link manager window size
var width = 600
var height = 225 // base height IE or NS (includes target)
var testopt = ',' + options + ','
if (testopt.indexOf(',none,') != -1) height += 25
if (testopt.indexOf(',url,') != -1) height += 40
if (testopt.indexOf(',file,') != -1) height += 45
if (testopt.indexOf(',template,') != -1)
{
height += 220 + 40; //add 40 for section prompt
if (RZ.isnavigator) height += 25
}
//----- Store computed values in the link object itself
RZ.link[linkname].linkwidth = width
RZ.link[linkname].linkheight = height
RZ.link[linkname].linkscroll = 'yes'
//----- Store link manager url with parameters
RZ.link[linkname].linkurl = '/revize/util/linkmanager_frame.html' + RZ.parameters
//----- Display all link manager properties on trace
RZtrace('Link Manager linkname (' + linkname + ') url parameters',RZ.message)
var msg = ''
for (var i in RZ.link[linkname])
msg += i + ' = ' + RZ.link[linkname][i] + '\n'
RZtrace('RZsetLinkManagerProperties() linkname (' + linkname + ')',msg)
}
/*---------------------------------------------------------------------------
Save all link manager information for this link in a new object
that is referenced at run time by new and edit buttons.
This function is called by the link object to define link properties for use by
new and edit buttons. A separate link object is defined for each linkname so
these properties are available when the new or edit button is clicked. The new
and edit buttons can then simply supply the linkname to access these properties.
See RZTagSupport.java for more information on the link manager calling process.
**IMPORTANT**
When changing functionality, please update Dreamweaver help file:
RevizePermissionsWorks-Help.htm (contains high level description)
----------------------------------------------------------------------------*/
function RZlinkmanager( linkname, linkmodule, linkrecordid, linklevel,
linkpagekey, linkparent )
{
if (typeof linkname == 'undefined') linkname = RZ.linkname
if (typeof linkmodule == 'undefined') linkmodule = ''
if (typeof recordid == 'undefined') recordid = ''
if (typeof linklevel == 'undefined') linklevel = ''
if (typeof linkpagekey == 'undefined') linkpagekey = ''
if (typeof linkparent == 'undefined') linkparent = ''
//----- For multi-level link manager lists...
if (linkmodule != '' && linklevel != '')
{
//----- Save first non-blank linkparent for this level
if (typeof RZ.linkparentnew[linkname] == 'undefined')
RZ.linkparentnew[linkname] = new Object();
if (typeof RZ.linkparentreset[linklevel] == 'undefined')
RZ.linkparentreset[linklevel] = 'reset'
if (typeof RZ.linkparentnew[linkname][linklevel] == 'undefined'
|| RZ.linkparentreset[linklevel] == 'reset')
{
if (linkparent == '') linkparent = RZ.permissions_parent
RZ.linkparentnew[linkname][linklevel] = linkparent
RZ.linkparentreset[linklevel] = ''
}
//----- Indicate new next higher level linkparent can be reset
var nextlevel = RZinteger(linklevel) + 1
RZ.linkparentreset[nextlevel] = 'reset'
//----- Save most recent pagekey (used to get parent for new level button)
RZ.linkpagekey[linklevel] = linkpagekey
if (typeof RZ.linkpagekey[linklevel+1] != 'undefined')
RZ.linkpagekey[linklevel+1] = 'undefined'; //clear lower level value
}
//----- Create link object if not defined to hold module and parent
if (typeof RZ.link[linkname] == 'undefined')
{
RZ.link[linkname] = new Object()
RZ.link[linkname].linkparent = ''
RZ.link[linkname].linkmodule = ''
}
//----- Set linkparent to 1st non-blank parent encountered (used for single level links)
// When no linkparent is set, the page_key is used when new or edit button clicked.
if (linkparent != '' && RZ.link[linkname].linkparent == '')
RZ.link[linkname].linkparent = linkparent
//----- Save additional link properties
if(RZ.linkname != '')
{
if (RZ.link[linkname].linkmodule == '' && linkmodule != '')
RZ.link[linkname].linkmodule = linkmodule;
RZ.link[RZ.linkname].options = RZ.linkoptions
RZ.link[RZ.linkname].filelocation = RZ.linkfilelocation
RZ.link[RZ.linkname].fileextension = RZ.linkfileextension
RZ.link[RZ.linkname].imagelocation = RZ.linkimagelocation
RZ.link[RZ.linkname].imageextension = RZ.linkimageextension
RZ.link[RZ.linkname].template = RZ.linktemplate
RZ.link[RZ.linkname].editform = RZ.linkeditform
RZ.link[RZ.linkname].modulelinkfield = RZ.linkmodulelinkfield
//----- Properties not passed on url
// TODO: automatically pick up all options starting with link
RZ.link[RZ.linkname].linkpathname = RZ.linkpathname
RZ.link[RZ.linkname].linknewsection = RZ.linknewsection
RZ.link[RZ.linkname].linkdisplaydefault = RZ.linkdisplaydefault
RZ.link[RZ.linkname].linktemplatedefault = RZ.linktemplatedefault
RZ.link[RZ.linkname].linkfilenamedefault = RZ.linkfilenamedefault
RZ.link[RZ.linkname].linkautocontinue = RZ.linkautocontinue
}
//----- clear RZ.* action arguments
RZactionReset();
}
/*---------------------------------------------------------------------------
Call RZdefaultLinkOption then add to RZ.parameters
----------------------------------------------------------------------------*/
function RZdefaultLinkParameter(linkname,property)
{
RZdefaultLinkOption(linkname,property)
RZsetLinkUrlParameter(linkname,property)
}
/*---------------------------------------------------------------------------
If property is undefined, set to blank
----------------------------------------------------------------------------*/
function RZdefaultLinkOption(linkname,property)
{
if (typeof RZ.link[linkname][property] == 'undefined')
RZ.link[linkname][property] = ''
//RZtrace('RZdefaultLinkOption('+linkname+'):' + property
// + '
-->' +(RZ.link[linkname][property])+ '<--')
}
/*---------------------------------------------------------------------------
Build link manager url parameters using link properties presumably defined
elsewhere on the page if property is defined and not blank.
----------------------------------------------------------------------------*/
function RZsetLinkUrlParameter(linkname,property)
{
if (typeof RZ.link[linkname][property] != 'undefined')
{
var value = RZ.link[linkname][property]
if (value != '')
RZaddUrlParameter( 'link' + property + '=' + value )
}
}
/*---------------------------------------------------------------------------
Adds jsp parameter to url
----------------------------------------------------------------------------*/
function RZaddUrlParameter(parameter)
{
//----- Build url parameter
if (RZ.parameters.indexOf('?') == -1)
RZ.parameters += '?' + parameter
else
RZ.parameters += '&' + parameter
//----- Build trace message
RZ.message += unescape(parameter) + '\n'
}
/*---------------------------------------------------------------------------
Return back to calling page
If returnUrlKey ends with a semicolon, assume it is an expression for url
Otherwise, return to PRIOR PAGE using the following steps
1. If URL defined in cookie, use it (returnUrlKey specifies cookie name)
2. If not edit list page, use history
3. If RZ.page.home is not blank, use it
4. Make trace entry and stay on current page
----------------------------------------------------------------------------*/
function RZpriorPage(returnUrlKey) { RZback(returnUrlKey) }
function RZback(returnUrlKey)
{
var returnUrl = ''
if (RZright(returnUrlKey,1) == ';') //url passed as variable / equation
returnUrl = eval( returnUrlKey )
else //url read from cookie
{
returnUrl = RZgetCookieValue(returnUrlKey)
if (returnUrl != "")
{ // if cookie defined
RZsetCookieValue(returnUrlKey,"")
}else
{ // when cookie not defined
if (RZ.pagetype == 'editform')
{
returnUrl = ''
history.go(-1); // use history if not edit list
}
else
{
returnUrl = RZ.page.home // use home if edit list
}
}
}
if (returnUrl != null && returnUrl != '')
document.location = returnUrl
else
RZtrace('snipper_helper: RZback('+returnUrlKey+')',
'No Prior URL could be determined')
}
/*---------------------------------------------------------------------------
Following function is called by the DELETE ITEM button
***** Delete current row (after prompting) *****
1. Confirm delete, return if not Ok
2. Make trace entry
3. Submit Xml request to revize, redirect to current page
----------------------------------------------------------------------------*/
function RZrecordDelete( recordID, moduleName )
{ RZdelete( recordID, moduleName ) }
function RZdelete( recordID, moduleName, nextUrl )
{
if (typeof nextUrl == 'undefined') nextUrl = location.href
RZ.message = "WebSpace: " + RZ.webspace + "\n"
+ "Module: " + moduleName + "\n"
+ "Record Id: (" + recordID + ")\n"
+ "Redirect Url: " + nextUrl + "\n"
RZtrace( "Delete Item Clicked", RZ.message );
if (isNaN(recordID))
{
alert( 'Invalid Record Id: ' + recordID )
return void(0)
}
else if (recordID=='')
{
alert( 'Record Not Specified (Id is Blank)' )
return void(0)
}
if (!confirm("Klicka på OK för att ta bort")) return
//----- Call Developer defined ondelete handler and quit if it returns false
if (typeof window.ondelete == 'function')
{
RZ.recordid = recordID
RZ.module = moduleName
var status = window.ondelete()
if (status == false)
{
window.status = 'Delete Canceled'
return void(0)
}
else if (typeof status == 'object')
{
if (typeof status.nexturl != 'undefined')
nextUrl = status.nexturl
}
}
//
// Use the XML translator servlet instead of the old XML form method.
var deleteUrl = "/revize/HTTPTranslatorServlet" +
"?resourcetype=record" +
"&action=delete" +
"&webspace=" + RZ.webspace +
"&id=" + recordID +
"&modulename=" + moduleName +
"&redirect=" + escape(RZabsoluteUrl(nextUrl));
RZtrace( "Delete Item Request", deleteUrl );
RZactionReset();
document.location = deleteUrl;
}
/*---------------------------------------------------------------------------
Bring up page permissions window.
The options argument can contain one of the following:
nexturl, linkname, module, object
----------------------------------------------------------------------------*/
function RZpermissions(set,options)
{
var pos;
if (typeof set == 'undefined') set = ''
if (typeof options == 'undefined') options = ''
var nexturl = RZgetoption( options, 'nexturl' )
var linkname = RZgetoption( options, 'linkname')
var module = RZgetoption( options, 'module')
if (nexturl == '')
{
var fileInfo = RZgetfileinfo('/revize/util/permissions-editform.jsp')
nexturl = RZbuildurl(fileInfo)
}
RZ.message = ''
RZ.parameters = nexturl
RZaddUrlParameter( 'webspace=' + RZ.webspace )
if (set == '')
{
set = RZ.permissions_module + '.page_key=' + RZ.page_key
if (linkname != '')
set += linkname
else if (module != '')
set += module
}
RZaddUrlParameter('set='+escape(set))
RZtrace('Page Permissions Call',RZ.message)
RZ.editWindow = RZpopupUrl( 'EditWindow', RZ.parameters, 400, 400, 'yes')
}
/*------------------------------------------------------------------------------
Remove any leading or ending blank spaces from string
------------------------------------------------------------------------------*/
function RZtrim(tmpStr)
{
while(tmpStr.substring(0,1) == ' ')
tmpStr = tmpStr.substring(1, tmpStr.length);
while(tmpStr.substring(tmpStr.length-1,tmpStr.length) == ' ')
tmpStr = tmpStr.substring(0, tmpStr.length - 1);
return tmpStr;
}
/*------------------------------------------------------------------------------
RZreplace(inStr, fromString, toString)
Replace all occurances of fromString with toString
(retain RZreplaceAll & RZreplacesubstring for backward compatibility)
------------------------------------------------------------------------------*/
function RZreplace( inStr, fromString, toString )
{ return RZreplacesubstring( inStr, fromString, toString ) }
function RZreplaceAll( inStr, fromString, toString )
{ return RZreplacesubstring( inStr, fromString, toString ) }
function RZreplacesubstring( inStr, fromString, toString )
{
var pos = 0
if (inStr == null
|| typeof inStr.length == 'undefined' //true or false
|| inStr.length == 0) return '';
var fromLen = fromString.length
if (fromLen == 0) return inStr
while (true)
{
pos = inStr.indexOf(fromString,pos)
if (pos == -1) break
inStr = RZsubstring( inStr, 0, pos )
+ toString
+ RZsubstring( inStr, pos + fromLen )
pos += toString.length
}
return inStr
}
/*------------------------------------------------------------------------------
Subsitute for substring method (does not produce javascript errors)
A null or empty input string returns empty string
Start and end positions outside boundries intrepreted as follows:
if end position not specified or greater than string length,
adjust to input string length
if end position before 1st character,
return empty string
if start position greater than ending position,
return empty string
if start position less than 0,
assume 0
Input Arguments
===============
str Input string
startpos Starting position
endpos Ending position (optional)
------------------------------------------------------------------------------*/
function RZsubstring(str, startpos, endpos)
{
if (typeof endpos == 'undefined') endpos = str.length + 1
//----- Validate input string
if (str == null || str.length == 0) //if null or empty string
return ""; //...return empty string
//----- Validate end position
if (endpos > str.length ) //greater than string length
endpos = str.length; //...set to length
else if( endpos <= 0 ) //if end position before 1st character
return ""; //...return empty string
//----- Validate start position
if( startpos >= endpos ) //if start position greater than ending position
return ""; //...return empty string
else if (startpos < 0) //if start position less than 0
startpos = 0; //...assume 0
//----- Return the substring
return str.substring(startpos,endpos);
}
/*---------------------------------------------------------------------------
returns rightmost number of characters specified
Example: right("1234",2) returns "34"
right("1234",0) returns ""
right("0",4) returns "0"
----------------------------------------------------------------------------*/
function RZright( str, noChars )
{
var len = str.length;
if (len == 0) return "";
if (noChars > len) noChars = len;
return str.substring(len-noChars);
}
/*---------------------------------------------------------------------------------------------
this function converts number to the nearest integer
0 is returned if not a valid number unless a defaultValue is supplied
---------------------------------------------------------------------------------------------*/
function RZinteger(number,defaultValue)
{
if (typeof defaultValue == 'undefined') defaultValue = 0
if (isNaN(number))
return defaultValue
return parseInt( parseFloat(number)+.5 ) //convert number to number then round up
}
/*---------------------------------------------------------------------------------------------
Look for specific option choice(s) in the options string.
Input Arguments:
pOptions String of options to be checked
pChoices One of more choices to check separated by comma
Returns
true if at least one of the choices found in the options
**NOTE** copy and converted from RZTagSupport but not yes tested
---------------------------------------------------------------------------------------------*/
function RZcheckoptions( pOptions, pChoices )
{
var str, pos;
var inputOpts = "," + pOptions + ",";
inputOpts = inputOpts.toLowerCase();
var searchOpts = pChoices.toLowerCase();
//----- For each desired choice ...
while ( !searchOpts == "" )
{
str = searchOpts;
pos = str.indexOf(",");
if (pos == 0)
{
searchOpts = str.substring(pos+1); //strip comma
continue;
} else if (pos > 0)
{
searchOpts = str.substring(pos+1);
str = str.substring(0,pos);
} else
{// no commaa
searchOpts = "";
}
// check for this choice
if (inputOpts.indexOf("," + str + ",") >= 0) return true;
if (inputOpts.indexOf("," + str + "=") >= 0) return true;
}
return false;
}
/*---------------------------------------------------------------------------
Looks for a key=value in the options string and returns the value portion.
(clone of getValue in RZTabSupport)
Input Arguments:
options String searched for key=value
key Key to find in options string
Returns the associated value when key is found, otherwise returns blank string
----------------------------------------------------------------------------*/
function RZgetoption( pOptions, pKey )
{
var pos, str, keyEqual;
//----- Search for key=
keyEqual = pKey + "=";
str = "," + pOptions;
pos = str.toLowerCase().indexOf( keyEqual.toLowerCase() );
if (pos == -1) // key not found
str = "";
else
{
//----- Keep everything after =
str = pOptions.substring(pos + keyEqual.length - 1);
pos = str.indexOf(",");
if (pos >= 0) str = str.substring( 0, pos ); // value
}
return str;
}
/*---------------------------------------------------------------------------
Call Next URL (popup or forward link)
----------------------------------------------------------------------------*/
function RZcallNextUrl( name,url, width,height,scroll)
{
if ( RZpopupUrl(name,url, width,height,scroll) == null )
{
RZtrace("Calling Next URL Form", "URL: " + url )
document.location = url
}
}
/*---------------------------------------------------------------------------
RZeditor(): See RZeditorsetup in snippet_helper_rte.
Stub kept here for backward compatibility and warning message.
----------------------------------------------------------------------------*/
function RZeditor()
{
if( RZ.pagetype == 'editform' )
RZeditorsetup()
else
RZalert('Rich Text Editor Must be Opened on Form Page')
}
/*---------------------------------------------------------------------------
Set Link Property value in link object passed to RTE (NOT yet used or tested)
Might be useful on edit forms to set link manager properties.
----------------------------------------------------------------------------*/
function RZsetLinkProperty( linkObj, property )
{
if (typeof RZ.link[linkname] != 'object')
if (typeof RZ.link[property] == 'undefined')
linkObj[property] = ''
else
linkObj[property] = RZ[property]
}
/*---------------------------------------------------------------------------
Open Trace Window and Display Message
----------------------------------------------------------------------------*/
function RZtrace(heading,text)
{
if( !RZ.trace ) return
if( typeof text == 'undefined') text = ''
text = text.toString();
text = text.split('--').join('\n')
var MSIE = true;
if (navigator.appVersion.indexOf('MSIE') == -1) MSIE = false;
//----- Always open using browser specific options
// (if already open, it reconnects to existing window)
while (true)
{
if(!MSIE) //Navigator
{
RZ.tracewin = window.open('', 'RevizeTrace',
'width=420,height=580,location=no,menubar=no,resizable=yes,screenX='
+ (screen.availWidth-430)
+ ',screenY=20,directories=no,status=no,scrollbars=yes');
}
else //IE
{
RZ.tracewin = window.open('', 'RevizeTrace',
'width=420,height=580,location=no,menubar=no,resizable=yes,left='
+ (screen.availWidth-430)
+ ',top=20,directories=no,status=no,scrollbars=yes');
}
//----- Close trace window if no access and open again
if (MSIE && !RZwinaccess(RZ.tracewin))
RZ.tracewin.close()
else
break
}
//----- Convert special characters
text = text.split('<').join('<');
text = text.split('>').join('>');
//----- Display message.
if (heading != '')
RZ.tracewin.document.writeln(
'',
'Trace\n',
'',heading,'
\n',
'',location.href,'\n',
'\n',
text)
else if (text != '')
RZ.tracewin.document.writeln( text )
else
RZ.tracewin.document.writeln( '
' )
//----- Give focus, if trace window already open and accessible
if (!MSIE || RZwinaccess(RZ.tracewin)) RZ.tracewin.scrollBy(0,600)
}
/*---------------------------------------------------------------------------
POPUP EDITOR CAN NO LONGER BE CALLED FROM PUBLISHED PAGES
***** Editor Support Code ***** Open Html Editor in popup window
If specified field exists in XMLForm, use that value.
Otherwise Revize editor will read and store data from content database.
----------------------------------------------------------------------------*/
function RZcallEditor( moduleName, fieldName, width, height, options, recordid )
{
if (typeof moduleName == 'undefined') moduleName = '';
if (typeof fieldName == 'undefined') fieldName = '';
if (typeof width == 'undefined' || width=='' ) width = '600';
if (typeof height == 'undefined' || height=='') height = '400';
if (typeof options == 'undefined') options = '';
if (typeof recordid == 'undefined') recordid = '';
//----- Make sure field and image elements are supplied
var msg = '';
var useDatabase = false;
if (moduleName == '')
msg = "Module Name Not Specified"
else
{
if (fieldName == '')
msg = "Editable Field Name Not Specified"
else
{
if (typeof document.XMLForm == 'undefined')
useDatabase = true;
else
if (typeof document.XMLForm[fieldName] == 'undefined')
useDatabase = true;
}
}
//----- Report any problems with arguments before using
if (msg != '')
{
RZalert( 'Invalid Revize Editor Request\n\n'
+ 'Function: snippet_helper.js:RZcallEditor()\n\n'
+ 'Problem: ' + msg + '\n' )
return;
}
//----- Make trace entry
RZ.message = '';
RZmsgAdd( "module" , '\t' + moduleName )
RZmsgAdd( "field" , '\t' + fieldName )
RZmsgAdd( "width" , '\t' + width )
RZmsgAdd( "height" , '\t' + height )
RZmsgAdd( "recordid", '\t' + recordid )
RZmsgAdd( "options" , '\t' + options )
RZtrace( "Revize Editor Request", RZ.message )
//----- Call Editor screen, passing parameters via Url
var url;
var editorDir = '/revize/'
if (!RZ.MSIE || RZ.browserversion < 5.5)
{
editorDir += 'javaeditor'
// Convert any rich edit options to applet editor Url parameters syntax
options = RZ.options.split(';').join('&')
if (options.substring(1,3) == '&&') options = options.substring(1)
}else
{
editorDir += 'htmleditor'
options = RZeditorOptions(options); //convert to rich edit format
options = 'options=' + escape(options) //passed as a single parameter
}
url = editorDir + '/editor-editform.jsp?webspace=' + RZ.webspace;
if (useDatabase != '') url += '&module=' + moduleName;
url += '&field=' + fieldName
if (recordid != '') url += '&recordid=' + recordid
url += '&width=' + width + '&height=' + height + '&' + options
RZpopupUrl('revize_editor',url,width,height,'no')
}
/*---------------------------------------------------------------------------
Open Url in Popup Window (return true if popup)
Originally used popup window if either width, height or SCROLL was not blank;
with advent of RZaction() and use of RZ object arguments, do not assume popup
based on scroll value or if both width and height are set to 0.
Since scroll is last feature, it can specify other features after the scroll
value. For example:
yes,location=yes,menubar=yes,toolbar=yes,directories=yes'
If niether width, heigth or scroll are specified assume popup window with no
features specified.
Returns
window object of popup window or null if popup window not used
----------------------------------------------------------------------------*/
function RZpopupUrl(name,url,width,height,scroll)
{
var useFeatures = true;
if(typeof width == 'undefined'
&& typeof height == 'undefined'
&& typeof scroll == 'undefined')
useFeatures = false;
else
{
var popup = false;
if(typeof width != 'undefined' && width != '' && width != 0 && width != '0')
popup = true;
if(typeof height != 'undefined' && height != '' && height != 0 && height!= '0')
popup = true;
if ( !popup) return null;
}
RZ.message = "Name: " + name + "\n"
+ "Url: " + url + "\n"
+ "Width: " + width + "\n"
+ "Heigth: " + height + "\n"
+ "Scroll: " + scroll + "\n"
RZtrace("Opening Popup Window", RZ.message)
//----- Determine popup properties
if(typeof url == 'undefined') url = ''
if(typeof name == 'undefined') name = 'RevizeWindow'
if(typeof width == 'undefined' || width=='') width = 400
if(typeof height == 'undefined' || height=='') height = 400
if(typeof scroll == 'undefined' || scroll=='') scroll = 'yes'
var menubar = 'no'
var location = 'no'
var toolbar = 'no'
var directories = 'no'
var status = 'yes'
if( RZ.trace || RZ.debug )
{
scroll = 'yes'
menubar = 'yes'
location = 'yes'
toolbar = 'yes'
directories = 'yes'
status = 'yes'
width = parseInt(width) + 15
height = parseInt(height) + 50
}
else if (name == 'admin')
{
menubar = 'yes'
location = 'yes'
}
var features = 'width=' + width + ',height=' + height
+ ',location='+location
+ ',menubar='+menubar
+ ',resizable=yes'
+ ',toolbar=' + toolbar
+ ',directories=' + directories
+ ',status=' + status
+ ',scrollbars=' + scroll //must be last to allow specify features
var x = (screen.availWidth - width) / 2 - 10
var y = (screen.availHeight - height) / 2 - 30
if (y < 50) y = 0
if(navigator.appVersion.indexOf('MSIE') == -1) // Netscape
features += ',screenX=' + x.toString()
+ ',screenY=' + y.toString()
else // IE browser
features += ',left=' + x.toString()
+ ',top=' + y.toString()
if (!useFeatures) features = '' //do not specify features
/*****
First open the popup window and give it focus in case it was already open.
It is possible that the popup window has been left open by another instance
of the browser. When this occurs on IE, the popup window will NOT have
access to window.opener property. To avoid this problem, we wait a second
and then call RZpopupAccess() to close and reopen the popup if the popup
window does not have proper access to this window. We did not want to
always close and reopen the window because it can be distracting for
content editors.
*****/
//TODO: This statement gets 1075 error on IE when opening publishing window
// if popup edit form was left open from another edit (calendar_app)
RZ.popupwin = window.open( url, name, features );
//----- On Netscape, RZ.popupwin sometimes not defined
if (RZ.popupwin == null || typeof RZ.popupwin == 'undefined')
RZ.popupwin = window.open( url, name, features );
//----- Give popup window focus
RZ.timeoutfocus = window.setTimeout('RZfocus(RZ.popupwin)', 500);
//----- Check for access after page loads
var str = 'RZpopupAccess("' + url + '","' + name+ '","' + features + '")'
RZ.timeoutaccess = window.setTimeout(str, 1000)
return RZ.popupwin;
}
/*---------------------------------------------------------------------------
Cancel focus and access timeout events.
----------------------------------------------------------------------------*/
function RZcancelPopupEvents()
{
window.clearTimeout(RZ.timeoutfocus)
window.clearTimeout(RZ.timeoutaccess)
}
/*---------------------------------------------------------------------------
Sets focus in case the specified window was left open from a previous call
----------------------------------------------------------------------------*/
function RZfocus(win)
{
if (RZwinaccess(win))
if (win.name != 'rzrte') win.focus();
}
/*---------------------------------------------------------------------------
See above description in RZpopupUrl
----------------------------------------------------------------------------*/
function RZpopupAccess(url,name,features)
{
var str = ''
if (!RZwinaccess(RZ.popupwin))
{
str = 'popup window closed'
}else
{
str = 'opener: '
if (RZwinaccess(RZ.popupwin.opener))
{
if (typeof RZ.popupwin.opener.location == 'undefined')
str += '*no url*'
else
str += RZ.popupwin.opener.location.href
}
else if (typeof RZ.popupwin.opener != 'undefined')
str += 'no access to opener'
else
str += 'opener not defined'
}
var msg = 'name: ' + name + '\n'
+ 'url: ' + url + '\n'
+ str + '\n'
//alert('Popup Properties\n\n' + msg)
RZtrace( 'Popup Properties', msg)
//----- Quit if popup window has been closed
if (!RZwinaccess(RZ.popupwin)) return
//----- If no access to opener, close window and reopen
if ( !RZwinaccess(RZ.popupwin.opener))
{
RZ.popupwin.close();
RZ.popupwin = window.open( url, name, features );
return
}
/*
//----- If Revize Control Panel... (future)
if ( name == 'revizecontrol' )
{
if (typeof RZ.popupwin.RZ == 'undefined')
{
window.focus()
RZ.popupwin.document.write('Revize Control Panel')
}
}
*/
RZ.popupwin = null //indicate popup processing complete
}
/*---------------------------------------------------------------------------------------------
Wait for access to "win" to perform "waitCommand" displaying "waitMsg" while waiting;
Only wait "maxSeconds" (default 30); check every "msInterval" (default 1000) milliseconds.
---------------------------------------------------------------------------------------------*/
function RZwait(win, waitCommand, waitMsg, maxSeconds, msInterval)
{
if (typeof waitMsg == 'undefined') waitMsg = 'Waiting for access'
if (typeof maxSeconds == 'undefined') maxSeconds = 30
if (typeof msInterval == 'undefined') msInterval = 1000
RZcancelPopupEvents() //RZwait overrides automatic popup events
var now = new Date()
RZ.waitstart = now.getTime() //start of wait
RZ.waitaccess = 0
waitCommand = RZreplacesubstring( waitCommand, '"', '\\"' )
RZ.waitcall = 'RZwaitCheck( ' + win
+ ', "' + waitCommand + '" '
+ ', "' + waitMsg + '" '
+ ', ' + maxSeconds
+ ', ' + msInterval
+ ' )'
RZtrace('Setup Wait', RZ.waitcall )
//eval( RZ.waitcall ) //call RZwaitCheck() immediately
setTimeout( RZ.waitcall, msInterval ); //give the url a chance to load
}
/*---------------------------------------------------------------------------
----------------------------------------------------------------------------*/
function RZwaitError(message)
{
return true
}
/*---------------------------------------------------------------------------------------------
RZwaitCheck
-----------
If access to "win" or "maxSeconds" have passed since "RZ.waitstart", perform "waitCommand";
otherwise wait another "msInterval" milliseconds.
Access means permisison to access window, RZ not null and...
either window name is not blank (works for most non-Revize enabled pages)
--or-- RZ.loaded is not undefined nor null
Debugger Notes:
--------------
It is possible that access to "win" is lost after checking access but prior to actually
accessing "win" variables which can cause one of the following JavaScript errors:
RZ is null or not an object
object does not support this property or method
Checking the page access before the new url starts to load is believed to be one cause.
An alternative onerror handler is set to catch these potential javascript errors.
This function stops running after a javascript error but unfortunately when MS studio is
installed and IE script debugging is not disabled, the currently defined onerror handler
does not run either and therefore can't be used to restore the original onerror handler
or schedule RZwaitCheck() to run again.
In order to restart RZwaitCheck in all cases is therefore rescheduled before the any
javascript error can occur and canceled if no more waiting is required.
---------------------------------------------------------------------------------------------*/
function RZwaitCheck (win, waitCommand, waitMsg, maxSeconds, msInterval)
{
if (window.onerror == RZwaitError)
window.onerror = RZ.waitonerror //restore original handler
var now = new Date()
var seconds = (now.getTime() - RZ.waitstart).toString() / 1000
waitcallId = setTimeout( RZ.waitcall, msInterval)
var waitMore = ''
if( !RZwinaccess(win) )
{
waitMore = 'no access'
RZ.waitaccess = 0
}
else
{ // see debugger notes this function description for onerror handling
if (window.onerror != RZwaitError)
RZ.waitonerror = window.onerror
window.onerror = RZwaitError
//simulate race error one time as described in debugger notes above
RZ.waitaccess++
//if (RZ.waitaccess <= 1 && RZ.error.force) RZ.waitaccess = 99
// if window reloading, RZ.loaded first set to null
if (typeof win.RZ != 'undefined' && win.RZ != null
&& typeof win.RZ.loaded != 'undefined' && win.RZ.loaded != true)
waitMore = 'refresh pending'
// window name undefined until window loaded (at least on IE)
else if (typeof win.name == 'undefined')
waitMore = 'window loading'
// if window name is not blank, assume window loaded
// (recognizes non-revize enabled pages especially frames)
else if (win.name != '')
waitMore = ''
// RZ.loaded not defined until onload handler complete
else if (typeof win.RZ == 'undefined' || win.RZ == null
|| typeof win.RZ.loaded == 'undefined' || win.RZ.loaded != true)
waitMore = 'onload pending'
window.onerror = RZ.waitonerror //restore original handler
}
var waitDone = false
if (waitMore != '')
{
var waitedMsg = ' waited ' + parseInt(seconds) + ' seconds'
RZtrace(waitMsg, waitedMsg )
RZ.parent.status = waitMsg + ': ' + waitedMsg + ' (' + waitMore + ')'
if (seconds > maxSeconds ) //don't wait too long
waitDone = true; //waited long enough
}
if (waitMore=='' || waitDone)
{
RZ.waitcall = '' //clear in case scheduled timeout starts
clearTimeout( waitcallId ) //cancel scheduled waitCheck
waitedMsg = 'waited ' + seconds + ' total seconds'
RZtrace('RZwaitCheck(): ' + waitMsg, waitedMsg )
if (!waitDone) RZ.parent.status = ''
eval( waitCommand )
}
}
/*---------------------------------------------------------------------------
Determine if opener properties are still accessible
(they will not be if window closed or moved to another url)
//TODO: check access on NS (unknown)
// The following is always false on Netscape
if ( typeof RZ.popupwin.opener.document == 'unknown' )
----------------------------------------------------------------------------*/
function RZwinaccess(win)
{
//default to opener for backward compatibility but all calls
//now probably pass an argument.
if (arguments.length == 0) win = RZ.parent.opener
//TODO: gets interface error if calling window is closed
if (typeof win == 'undefined' || win == 'undefined') return false
if(win != null
&& typeof win != 'undefined'
&& win.closed != true
&& typeof win.document != 'unknown' //if access denied on IE (not sure for NS)
&& win !='undefined')
return true
return false
}
/*---------------------------------------------------------------------------
Give focus to opener if still accessible.
----------------------------------------------------------------------------*/
function RZopenerFocus(win)
{
if (RZ.refresh)
RZ.refresh = false
else
{
if (typeof win == 'undefined') win = RZ.parent.opener
if (RZwinaccess(win)) win.focus()
}
}
/*---------------------------------------------------------------------------
Display page permission warning defined by code.
----------------------------------------------------------------------------*/
function RZpagemessage(code,linkname,linkparent,linklevel)
{
if (typeof linkname == 'undefined') linkname = ''
if (typeof linkparent == 'undefined') linkparent = ''
if (typeof linklevel == 'undefined') linklevel = ''
var msg = ''
var hash = '';
switch ( code )
{
// button warning
case "":
break;
// page permission icon appearing in upper left corner of page is clicked.
case "noparent":
msg += 'No parent defined for this PAGE'
break;
// link manager
case "nolinkparentfield":
msg += 'No linkparent field defined for this LINK'
break;
// link manager
case "nolinkparent":
msg += 'No parent defined for this LINK'
break;
// button warning
case "nomodule":
msg += 'Revize module not defined on button'
break;
// button warning
case "parent_itself":
msg += 'Page can not be a parent of itself \n(no longer true)'
break;
// unknown warning
default:
msg += 'Page permission incongruency'
code = RZreplace(code,'--','\n')
if (code.length > 25)
msg += ':\n\n' + code
else
msg += ' (reason:' + code + ')'
break;
}
RZ.message = ''
RZ.parameters = ''
if (linkname != '')
{
RZ.message += 'Link Information:\n\n'
RZaddUrlParameter('Link Name: ' + linkname )
RZaddUrlParameter('Link Module: ' + RZ.link[linkname].linkmodule )
RZ.message += '\n'
if (linkparent == '*nofield*')
RZ.message += 'No linkparent field in linkmodule\n'
else if (RZ.link[linkname].linkmodule != '')
RZaddUrlParameter(RZ.link[linkname].linkmodule+'.linkparent: '+ linkparent)
RZaddUrlParameter('First List Item Parent: '+ RZ.link[linkname].linkparent)
if (linklevel != '')
{
RZ.message += '\n'
RZaddUrlParameter('Link Level: '+ linklevel)
if (typeof RZ.linkparentnew[linkname] != 'undefined')
RZaddUrlParameter('Level '+linklevel+' new parent_key: '
+ RZ.linkparentnew[linkname][linklevel])
}
}
else
{
RZ.message += 'Page Information:\n\n'
var templateType = '(unique)'
if (RZ.pagemodule != '') templateType = '(dependent)'
RZaddUrlParameter('Template: ' + RZ.pagetemplatename + ' ' + templateType )
if (RZ.pagemodule != '')
{
RZaddUrlParameter('Module: ' + RZ.pagemodule )
RZaddUrlParameter('Record Id: ' + RZ.editrecordid )
hash = '#' + RZ.pagemodule + "_" + RZ.editrecordid;
}
RZ.message += '\n'
RZaddUrlParameter('page_key: ' + RZ.page_key )
RZaddUrlParameter('parent_key: ' + RZ.parent_key )
RZ.message += '\n'
RZaddUrlParameter('Permitted roles: ' + RZ.page_roles )
RZaddUrlParameter('Permitted users: ' + RZ.page_users )
if (RZ.inherit_key != '')
RZaddUrlParameter('Inherited from: ' + RZ.inherit_key )
}
RZ.message += '\n'
RZaddUrlParameter('permissions_options: ' + RZ.permissions_options )
if (msg != '')
{
msg = '---------------------------------------------------\n' + msg + '\n'
msg += '---------------------------------------------------\n\n'
}
msg += RZ.message + '\n'
msg += '---------------------------------------------------\n'
msg += 'Click Ok to find pages that link to this page \n'
msg += '---------------------------------------------------\n'
if (confirm(msg))
location.href = RZ.webspacelinksurl + hash
return void(0)
}
/*---------------------------------------------------------------------------
Display and clear warning from jsp code
----------------------------------------------------------------------------*/
function RZwarning()
{
if (RZ.warning != '')
{
window.status = RZreplaceAll( RZ.warning, '-- --', '; ')
RZtrace( 'Warning from JSP code', RZ.warning )
RZ.warning = ''
}
}
/*---------------------------------------------------------------------------
Display alert using confirm
----------------------------------------------------------------------------*/
function RZconfirm(message)
{
return RZalert(message,true)
}
/*---------------------------------------------------------------------------
Send alert & trace message
----------------------------------------------------------------------------*/
function RZalert(message,isConfirm)
{
if (typeof isConfirm == 'undefined') isConfirm = false;
if (typeof message == 'undefined' || typeof message == 'object')
message = 'Error Message is ' + typeof message
if (message == '')
message = 'No Error Details'
message = message.split('--').join('\n\n')
var trace = message + '\n\n' + 'CALLED FROM: ...\n';
if (typeof RZ.jsversion == 'undefined' || RZ.jsversion < 1.2)
trace += '\ncaller trace requires IE 5.0 or Netscape 4.0 browser'
else
{
for(var a = arguments.caller; a != null; a = a.caller)
{
funcName = a.callee.toString().match(/function (\w*)/)[1];
if (funcName == null || funcName.length == 0) funcName = "anonymous"
trace += funcName + "\n";
if (a.caller == a) break; //NS 4.0 bug workaround
}
trace += '-main html page-'
}
RZtrace('Alert: ', trace)
message = 'This Revize ' + RZ.pagetype + ' has the following problem:\n\n'
+ message + '\n\n'
+ 'Developers can enable trace with the URL below: \n'
+ ' ' + RZ.page.domain + '/revize/trace/'
//----- Determine whether to user alert or confirm
if (RZ.debug == false && RZ.trace == false)
{
if (isConfirm)
return confirm(message)
else
alert(message)
}
else if ( confirm(message + '\n\nEnter Debug Mode?') )
RZstartDebugger()
//----- Clear message - only works if message is called by reference
// which is unlikely calling scenario.
message = ''
return '' //can be used to clear message
}
/*---------------------------------------------------------------------------
Resize window; if width or hieght not specified use available size respectively
----------------------------------------------------------------------------*/
function RZresize(width,height,justify,win)
{
if (typeof width == 'undefined' || width=='') width = screen.availWidth;
if (typeof height == 'undefined' || height=='') height = screen.availHeight;
if (typeof justify == 'undefined') justify = 'center'
if (typeof win == 'undefined') win = window
if (RZ.isnavigator) height -= 125 //TODO: for linkmanager ???
var x = (screen.availWidth - width) / 2
var y = (screen.availHeight - height) / 2
if (justify == 'right')
x = screen.availWidth - width - 10
else if (justify == 'left')
x = 0
if (x < 0) x = 0
if (y < 0) y = 0
win.resizeTo(width,height);
win.moveTo( x,y )
}
/*---------------------------------------------------------------------------
Write html if user is authenticated for current webspace (RZ.webspace).
During page initialization RZ.login is set to the RZlogin cookie defined by
the login function.
TODO: Do not write html for production channels.
Input Parameters:
html html code to be written if logged in and proper permission
module Module requiring permissions
permits Permissions required on module
action Button action
----------------------------------------------------------------------------*/
function RZlogin( html, module, permits, action )
{
// 2nd parameter was webspace way back and there was not a 3rd parameter
// so defaulting permits to blank retains backward compatibility.
if (typeof module == 'undefined') module = '';
if (typeof permits == 'undefined') permits = '';
if (typeof action == 'undefined') action = '';
// backward compatibility
if(typeof RZ.webspace == 'undefined'
&& typeof RZ.webSpaceName != 'undefined')
RZ.webspace = RZ.webSpaceName
// if login webspace does not match page webspace, return false
if(RZ.login != RZ.webspace && RZ.login != '*ALL')
return false
// if pointbasedemo webspace and NOT preview directory, return false
if(RZ.webspace.indexOf('pointbasedemo') >= 0
&& RZ.page.pathname.indexOf('-preview') == -1)
return false;
// if demosite webspace and production directory, return false
if(RZ.webspace.indexOf('demosite') >= 0
&& RZ.page.pathname.indexOf('-prod') != -1)
return false;
// if atwatercounty webspace and production directory, return false
if(RZ.webspace.indexOf('atwatercounty') == 0
&& RZ.page.pathname.indexOf('-prod') != -1)
return false;
// if paradigm webspace and production directory, return false
if(RZ.webspace.indexOf('paradigm') == 0
&& RZ.page.pathname.indexOf('-prod') != -1)
return false;
//----- If called with a module and required permits, check them.
// If no access, return false and do not write any html.
if ( module != '' && permits != ''
&& RZpermits(module , permits) != true )
return false;
//----- Hide button if no page permissions (TODO: hides what? seq?)
if ( action != 'save' && action != 'cancel' && action != 'history')
if ( !RZ.pagepermission && module != '' ) return false;
if ( typeof html != 'undefined' && html != '')
document.write(html);
return true;
}
/*---------------------------------------------------------------------------
Toggle debug mode with prompt that includes optional notes argument.
----------------------------------------------------------------------------*/
function RZdebug(notes)
{
var debugState = !RZ.debug
var msg = 'Set debug ' + debugState + '?'
if (typeof notes != 'undefined')
msg = notes + '\n\n' + msg
if (confirm(msg))
RZ.debug = debugState
return void(0)
}
/*---------------------------------------------------------------------------
Prompt to start debugger with optional notes argument.
----------------------------------------------------------------------------*/
function RZdebugger(notes)
{
var msg = 'Start Debugger?'
if (typeof notes != 'undefined')
msg = notes + '\n\n' + msg
if (confirm(msg)) RZcallDebugger()
return void(0)
}
/*---------------------------------------------------------------------------
Ask to start IE or Netscript Javascript debugger.
----------------------------------------------------------------------------*/
function RZstartDebugger()
{
if (RZ.MSIE)
RZcallDebugger()
else
{
if (!confirm('Start debugger?')) return void(0)
alert( 'Set breakpoint on following return statement in:\n'
+ 'snippet_helper.js::RZstartDebugger()\n\n'
+ 'When debugger then appears after displaying this statement,\n'
+ 'Click on Out button once or twice to see calling statement')
}
return void(0)
}
if (RZ.MSIE) //the debugger statement causes syntax error in NS
document.write('
',
' 
',
'
'
+ ''
}
// Display hidden icon in case template can not be determineed
else if (RZ.template == '' && RZ.linkname == '')
{
RZ.html = ''
+ ' ![Click for Details](\"/revize/images/warning-button.gif\"')
'
+ ''
//RZ.html = RZ.html.replace(/' + RZ.img + ''
else
{
if (RZ.caption == '') RZ.caption = 'Edit Page'
html += ''
}
}
//----- Add 
'
RZlogin(html)
}
/*---------------------------------------------------------------------------
Display message regarding button configuration issue
----------------------------------------------------------------------------*/
function RZiconMessage(action,index)
{
module = RZ.icons[index]
var msg = RZpermissionWarning(action,'',module)
if (msg != '')
if (!RZconfirm(msg)) return
}
/*---------------------------------------------------------------------------
Format a permission warning message if button not configured correctly
----------------------------------------------------------------------------*/
function RZpermissionWarning(action,template,module)
{
var msg = '';
var buttonName = ''
if (RZsubstring(action,0,3).toLowerCase() == 'new')
buttonName = 'NEW '
else if (RZsubstring(action,0,4).toLowerCase() == 'edit')
buttonName = 'EDIT '
// Get dependent template for page permissions
if (template == '')
{
if (module == '') //test by clearing RZ.template and RZ.module on button
{
msg = 'The template used to create the new page could not be \n'
+ 'determined because no module was specified on the '
+ buttonName + 'button.'
}
// Get template processed from the list associated with the specified module
else if (typeof RZ.linktemplates[module] != 'undefined')
template = RZ.linktemplates[module];
else //test by specifing incorrect module on button
msg = 'The template used to create new pages can not be determined\n'
+ 'because there does not appear to be any lists associated with\n'
+ 'with the currently specified module: ' + module + '.'
}
if (msg == '' && template == '') //test by clearing RZ.template on button
msg = 'The template used to create new pages can not be determined\n'
+ 'because there are no links in the list associated with the\n'
+ 'currently specified module: ' + module + '\n\n'
+ 'The developer may need to specify the template on the ' + buttonName + 'button\n'
+ 'If pages are not created when list items are added, a template of none\n'
+ 'should be specified.'
// template not required for single record edits
if (template == '*none*'
|| action == 'editform' || action == 'editpage' || action == 'editglobal')
msg = ''
// Warn content editor about potential permissions inheritance issues
if (msg != '')
{
if (buttonName == 'NEW ')
msg = 'If this NEW button creates a new page, that page will NOT\n'
+ 'inherit permissions for the following reason:\n\n'
+ msg
else if ( !RZcheckoptions(RZ.permissions_options,"warnings") )
msg = '' //no warning if migration option not enabled
else
msg = 'The EDIT button is not configured to properly pass page permissions\n'
+ 'to the page created when this item was added to the associated list.\n\n'
+ 'The template must be known to assign a parent to child pages.\n\n'
+ msg
}
return msg
}
/*---------------------------------------------------------------------------
Sets general edit url parameters used with or w/o link manager.
----------------------------------------------------------------------------*/
function RZsetEditParameters(module,field,set)
{
RZ.parameters = ''
//----- Append webspace parameter
RZaddUrlParameter( 'webspace=' + RZ.webspace )
//----- Append module & field
if (module!='')
RZaddUrlParameter( 'module=' + module ) //used by link manager
if (field!='')
RZaddUrlParameter( 'field=' + field ) //future
//----- Append set parameters
if (set != '')
{
set = set.split('pagerecord._recordid').join( RZ.editrecordid )
RZaddUrlParameter( 'set=' + escape(set) )
}
}
/*---------------------------------------------------------------------------
Sets recordid parameter used with or w/o link manager.
----------------------------------------------------------------------------*/
function RZsetEditRecordParameter(recordid)
{
var recordidParameter = '*ERROR*'
if (recordid == 'new')
recordidParameter = '&new'
//----- Calculated value
else if (recordid.length>0 && recordid.substring(recordid.length-1)==';')
recordidParameter = '&recordid=' + eval(recordid)
//----- If rz.fetch returned an error message as text
// (use alert because it may not be design flaw)
else if (recordid != '' && isNaN(recordid))
alert( 'Revize Button specifies Invalid Record Id: \n' + recordid )
else if (recordid != '')
recordidParameter = '&recordid=' + recordid
else
recordidParameter = ''
return recordidParameter
}
/*---------------------------------------------------------------------------
Called from above and also from snippet_helper_editform.js before calling RTE.
Computed window size just fits 800 X 600 for all options.
Create link object if undefined and use default options if undefined.
----------------------------------------------------------------------------*/
function RZsetLinkManagerProperties(linkname,module,field,recordid,set,url)
{
//----- Set general edit Url paramters
RZ.message = ''
RZsetEditParameters(module,field,set)
//----- If link object not yet defined, define it
if (typeof RZ.link[linkname] == 'undefined') RZ.link[linkname] = new Object()
//----- Get current options (use default values if undefined)
var options = RZ.link[linkname].options
if (typeof options == 'undefined') options = 'url,template,file'
RZ.link[linkname].options = options
//----- Following properties are used by jsp code and must be passed on url
RZaddUrlParameter( "linkname=" + linkname )
RZsetLinkUrlParameter(linkname,'options')
RZaddUrlParameter( "nexturl=" + RZabsoluteUrl(url) )
//----- Template specfic properties (DW only defines template property)
RZdefaultLinkParameter(linkname,'template') //blank for all templates
RZdefaultLinkParameter(linkname,'editform') //template specific editforms
RZdefaultLinkParameter(linkname,'modulelinkfield') //back link from dependent module
//----- TODO: Following properties are now passed on url (but should NOT)
// (they are not used by jsp code except to retrieve values for js)
RZdefaultLinkParameter(linkname,'filelocation') //file manager location (supported by RTE)
RZdefaultLinkParameter(linkname,'fileextension') //file manager extensions
//----- TODO: Following properties are now passed on url (but probably NOT even used)
RZdefaultLinkParameter(linkname,'imagelocation') //image manager location
RZdefaultLinkParameter(linkname,'imageextension') //image manager extensions
//----- Following properties NOT used by jsp code are accessed from the opener window
// They can be set on RZ.link.