Methods - Functional Reference Listed by Usage (New)
Methods - Alphabetized Quick Reference
Events
 

Overview
 

Summary of callback events (Updated)

How to load and print a page in the background and then close the FE window

Radio buttons - how to determine which one is currently selected on a page.

Leveraging the power of the HTML DOM with JavaScript and FileExplorer (New)

How to open Word document inside Internet Explorer, and hence inside FileExplorer (New)

How to remove parts of a loaded page before displaying it to the user (New)

Back     ( ) ,byte,proc

ThisViewer.Back()

• Same effect as the "Back" button in Internet Explorer.
• Returns a byte indicating success (1) or failure (0).

ThisViewer.ClickByName('Button1')
ThisViewer.ClickByName ('Button1', 2)

• See the GetElementQ method to understand the context of this method.
• Use this method when you have a button in an html page that you want to be able to "click" from within your own code (cool!).
• To see this code in action, have a look at the "Advanced_feBrowser_DOM" example in the feabc.app example application.
• Use the NameInstance parameter to specify which button to click if there is more than one button with the same name in the same frame.  If you do not use this parameter then the first button found which matches the ElementName parameter will be used.

ThisViewer.ClickByRecordNumber (5)

• See the GetElementQ method to understand the context of this method.
• Use this method when you have an image (IMG) in an html page that you want to "click", but the image has no NAME (which is normally the case).  Use the GetElementQ method to find the element's RecordNumber, which can then be used in this method to "click" the image from your code...
• NOTE: This method should also work with Input elements, although this has not been extensively tested.
• To see this code in action, have a look at the "Advanced_feBrowser_DOM" example in the feabc.app example application.

Edit     (long EditType, long pAction = 0, <string pValue>) , byte, proc

The Edit method is used to call various "Editing" commands. These range from command that are in the Edit menu of the browser such as "Copy", "Paste", "Cut", "Undo" and so on to those that are in the File menu, such as "Save", "Print", "Close" and so on.

Parameters

long EditType

An equate that specifies what action the Edit method needs to perform. The values for this equate are as follows:

fe:Browser_Save	The same as the File->Save command, saves the contents of the Browser control to a file. This has no effect on the Browse control unless the contents of the page have been modified
fe:Browser_SaveAs	File->Save As. The same as the Save command, but with the opportunity to set the file name, and to optionally to prompt the user for a file name (dependant on the value of the pAction parameter, see below). Note: unfortunately the Web Browser control always displays a dialog box, and ignores the value of the pValue parameter passed. We have implemented this interface with support for the parameters, however unless the MS control is modified it will continue to behave in this fashion.
fe:Browser_Print	File->Print. Prints the document, again the behaviour of the print command and whether the print options dialog is displayed is controlled by the pAction parameter.
fe:Browser_PrintPreview	File->Print Preview. Displays the Print Preview dialog box. This has been greatly improved with IE7.
fe:Browser_PageSetup	File->Page Setup. Displays the Page Setup dialog box.
fe:Browser_Properties	File->Properties. Displays information about the currently loaded page.
fe:Browser_Cut	Edit->Cut (not exposed in IE itself). Cuts the current selection (removes it from the browser and places it on the clipboard). Unlike a standard browser, the FE browser actually allows you to remove content from a document.
fe:Browser_Copy	Edit->Copy. Copies the current selection to the clipboard.
fe:Browser_Undo	Edit->Undo (not exposed in IE itself). Undoes the last action, typically not used for the Browser control, unless you are using the Cut or Delete actions (which are not typically used with the Html Browser).
fe:Browser_Redo	Edit->Redo (not exposed in IE itself). Redoes the last action that was undone using the Undo command. If no Undo has been performed this has no effect whatsoever. You can cycle through the "undo" list using the Undo and Redo commands to move back and forth through the performed actions.
fe:Browser_SelectAll	Edit->Select All. Selects everything within the browser control.
fe:Browser_ClearSelection	Edit->Clear Selection. Deselects everything, so that nothing in the control is selected.
fe:Browser_Find	Edit->Find. Displays the Find dialog and allows the user to type a string to locate within the loaded document. Each time the Find button is pressed the next instance of the string is located and selected.
fe:Browser_Delete	Edit->Delete (not exposed in IE itself). Deletes the current selection (removes it from the document).
fe:Browser_StopDownloading	Equivalent to pressing the Stop button in IE. This stops the current document from loading.
fe:Browser_CloseDocument	File->Exit (no exact equivalent command in IE). Closes the current document, in the case of FileExplorer this does not close the Window that the FE control is on, it simply closes the loaded document and displays a blank page.

 

long pAction = 0 (optional)

The optional second parameter allows you to specify how the command is executed for commands that normally require user feedback. For example the fe:Browser_SaveAs action normally displays a Save As dialog box, you can circumvent the display of the dialog by passing pAction as fe:OLECMDEXECOPT_DONTPROMPTUSER as the second parameter.

There are four possible values for this parameter:

fe:OLECMDEXECOPT_DODEFAULT (0)
Prompt the user for input or not, whichever is the default behavior.

fe:OLECMDEXECOPT_PROMPTUSER (1)
Execute the command after obtaining user input.

fe:OLECMDEXECOPT_DONTPROMPTUSER (2)
Execute the command without prompting the user. For example, clicking the Print toolbar button causes a document to be immediately printed without user input.

fe:OLECMDEXECOPT_SHOWHELP (3)
Show help for the corresponding command, but do not execute.

string pValue (optional)

The third parameter allows a value to be passed for those actions that require one, or can optionally use one. For example the SaveAs action allows the file name to save the document to, and in combination with the pAction set to fe:OLECMDEXECOPT_DONTPROMPTUSER this would save the document to a specific file name, without prompting the user.

Currently supported actions:

fe:Browser_SaveAs - is documented as supporting this property, however the implementation of the COM object does not use the passed path unfortunately, and does not respect the value of the pAction parameter (a dialog is always displayed).

Return Values

Returns a byte indicating success (1) or failure (0).

Example:

    !--- Copy the entire loaded document onto the clipboard
    ThisViewer.Edit(fe:Browser_SelectAll)
    ThisViewer.Edit(fe:Browser_Copy)        

    !--- Note that the below example could be done simply by calling the feBrowser.PrintMe() method:

    !--- Print the document without displaying the "print" dialog box
    ThisViewer.Edit(fe:Browser_Print, fe:OLECMDEXECOPT_DONTPROMPTUSER)    

              

Typically you would never use this method, FileExplorer provides a number of callback method for you to embed code in that provide a neat and clear approach to responding the events that the Browser control produces. See Summary of callback events for more information. For an example of using a callback method see the "How to Print a web page in the Background" example at the end of this document.

Technical Information:

Because File Explorer uses COM (not the Clarion OLE control) for this object, callback functionality is not implemented using the standard Clarion "callback embeds".  Instead we have made this method, which you can simply override (the templates do this for you).  The method is then "called" by File Explorer each time a callback event fires.  The logic flow is as follows:

1. Internet Explorer fires an event
2. File Explorer "catches" that event, and the File Explorer dll calls the FeBrowser::EventCallback method
3. Any code in your app, before the call to parent.EventCallback runs
4. File Explorer processes the code inside the FeBrowser::EventCallback method (you have no control over this)
5. Any code in your app, after the call to parent.EventCallback runs
6. Your app returns from the EventCallback (virtual) method, and depending on the value of "ReturnVar" which your app returns, File Explorer will act accordingly

• Things you can do with this functionality include knowing when a page has finished loading, when a user clicks on something on a page, implementing a status bar etc etc etc.
• Have a look at the "Advanced_feBrowser_SimpleCallbacks" procedure in the feabc.app example application to see how this works.
• For more info on the various events and associated parameters, click here.
• NOTE:  In order to implement Event Callbacks you need to activate them from the Viewer Control's properties tab.
• See Summary of callback events for more information

ThisViewer.Forward()

• Same effect as the "Forward" button in Internet Explorer.
• Returns a byte indicating success (1) or failure (0).

• This method then scans though the loaded html page for all elements (think "objects") which have TagNames (think "the catagory of the elements") which match the parameter you passed as "TagName".  So if you pass "input" for instance, it will pick up all the "input" elements in the html.
• Once it has scanned the loaded html document for all elements (objects) of the type you passed as "TagName", it then populates this information (a list of the elements that were found) into a queue, which you pass as the second parameter, "QParm".  You can then process this queue from your own code to get whatever data you need.
• So to summarize, you pass this method two things.  First there is a cstring which contains the TagName you're searching the loaded document for.  This could be something like "input", "form", "meta" or whatever.  If you omit this parameter, then all elements (objects) are looked for.  The second parameter is the name of the queue (which you must create in your app) which is to receive the list of elements.  This queue should be declared as type "fe:QParam_Type" which is declared in fe.inc as follows:
  
  fe:QParam_Type   queue,type
  RecordNumber         long
  ElementName          string(256)
  ElementID            string(256)
  ElementType          string(256)
  TagName              string(256)
  ElementValue         string(2048)
  ElementValue2        string(2048)
  ElementValue3        string(2048)
  ElementValue4        string(2048)
  ElementValue5        string(2048)
  CheckedStatus        byte
                   end
  
• The FrameNumber parameter can be used if you have a loaded document which contains frames.  This parameter is passed as 0 (zero / false) by default, indicating that the document contains no frames.  If the document which you're working on does contain frames, pass this value as a number to work with any one of the frames.  For instance, passing "1" will work with the first frame, "2" with the second frame and so on.  Use the "Advanced_feBrowser_DOM" example mentioned below to test a page to see which frame number relates to which frame.
• The RecordNumber field (returned in the queue) is simply an auto-incrementing long.. The first element that File Explorer finds will be "1", then next one will be "2" and so on..  Don't use this field in your code as if the html page ever changes then these numbers could also change (element "4" could become element "5" for instance).
• The ElementName field (returned in the queue) is the name of the element, assuming the element has a name
• The ElementID field (returned in the queue) is the ID (number) of the element, assuming that it has one
• The ElementType field (returned in the queue) is the element's "Type".  e.g. "text", or "hidden"
• The TagName field (returned in the queue) is the name of the html tag surrounding the element, e.g. "META" or "IMG"
• There are also five ElementValue fields (returned in the queue), which return useful data for each element.
• The CheckedStatus field (returned in the queue) only applies to check boxes and returns their checked status.
• To see this in action, have a look at the "Advanced_feBrowser_DOM" procedure in the feabc.app example application.

• This method was written primarily to make it easier to use File Explorer with NetTalk, to create and send emails.
• The idea is that you use File Explorer to create / view an email (html).
• To send this email (using NetTalk), you need to set several NetTalk properties.  Two of these properties are a comma separated list of graphics in the html (ThisEmailSend.EmbedList), and a modified version of the html code (ThisEmailSend.MessageHtml), where image paths are changed from qualified paths to paths prefixed with "cid".
• This File Explorer method simply updates two File Explorer properties, self.Source and self.GraphicsList.
• Also look at the notes below on the "RootFolder" property.
• The code above gives a rough idea how this works, for a detailed example see the fenetalk.app example that ships with File Explorer.

• This method is used to find things out about the loaded document.  The method works by either updating a class property, or by returning a pointer to a cstring which contains information, or sometimes by doing both.
• If you call the method without passing any parameters ( ThisViewer.GetInfo( ) ), then the method will update all the properties that it supports (not recommended).
• If you call this method and pass something in the Parm1 parameter, then only one property (determined by what you pass as this parameter) will be updated (recommended).  Below follows a list of equates which you can pass, along with the name of the property that will be updated:
  • fe:LocationURL  - ThisViewer.GetInfo_LocationURL  (and ThisViewer.URL for backward compatibility)
  • fe:LocationName  - ThisViewer.GetInfo_PageTitle  (and ThisViewer.PageTitle for backward compatibility)
  • fe:DocumentType  - ThisViewer.GetInfo_DocumentType  (and ThisViewer.DocumentType for backward compatibility)
  • fe:BusyStatus  - ThisViewer.Busy
  • fe:InnerText - ThisViewer.GetInfo_InnerText
  • fe:OuterText - ThisViewer.GetInfo_OuterText
  • fe:InnerHTML - ThisViewer.GetInfo_InnerHTML
  • fe:OuterHTML - ThisViewer.GetInfo_OuterHTML

  The following equates / properties are not currently supported:

  • fe:ClassName - ThisViewer.GetInfo_ClassName
  • fe:ID - ThisViewer.GetInfo_ID
  • fe:TagName - ThisViewer.GetInfo_TagName
  • fe:Language - ThisViewer.GetInfo_Language
  • fe:Lang - ThisViewer.GetInfo_Lang
  • fe:offsetLeft
  • fe:offsetTop
  • fe:offsetWidth
  • fe:offsetHeight

  Note that in addition to these properties being updated, the values which they are updated with are also returned an a *cstring.  So the following code does the same thing ( i.e. The three messages below will all show the same result ):

  ThisViewer.GetInfo ( fe:LocationURL )
  message (ThisViewer.URL )

  or:
  
  Loc:CStringPointer  &CSTRING
  ...
  Loc:CStringPointer &= ThisViewer.GetInfo ( fe:LocationURL )
  message ( ThisViewer.GetInfo_LocationURL )
  message ( Loc:CStringPointer )

  Note that you should never write to a cstring which is returned to you, or to any of the properties (above): these values should be treated as read-only.  Note also that you do not need to "new" or "dispose" anything here, all the "new-ing" and "dispose-ing" is taken care of for you inside the library.

• Note that the GetInfo method is getting information about the loaded document at a moment in time.  So if you want to get the same information ( say the name of the loaded document ) every 5 seconds, you should call GetInfo every 5 seconds to make sure you have the latest information.
• The FrameNumber parameter can be used if you have a loaded document which contains frames.
• To see this method in action, have a look at the "Advanced_feBrowser_GetInfo" procedure in the feabc.app example application.

• See the GetElementQ method to understand the context of this method.
• Use this method when you know the ElementID (each element (think "object") in an html page has its own ElementID), and want to establish its value.  For instance, if you have loaded an html page which has an entry field on it where users enter their last names, so long as you know that entry field's ElementID you can use this method to "read" the value from that field.  To elaborate, if you have an entry field in an html page as follows...

<input id="id5" type="text" name="LastName" size="20">

• ... you could actually read what the user types into this html field by using the code at the top of this section.
• To see this code in action, have a look at the Advanced_feBrowser_DOM procedure in the feabc.app example application.

MyCStringPtr &= ThisViewer.GetValueByName ('LastName')

• See the GetElementQ method to understand the context of this method.
• Use this method when you know the ElementName (each element (think "object") in an html page has its own ElementName), and want to establish its value.  For instance, if you have loaded an html page which has an entry field on it where users enter their last names, so long as you know that entry field's ElementName you can use this method to "read" the value from that field.  To elaborate, if you have an entry field in an html page as follows...

<input id="id5" type="text" name="LastName" size="20">

• ... you could actually read what the user types into this html field by using the code at the top of this section.
• To see this code in action, have a look at the Advanced_feBrowser_DOM procedure in the feabc.app example application.

ThisViewer.HideControl ()

• Hides the File Explorer viewer control.  Note: ?feControl{prop:hide} = true will not work.

ThisViewer.Home()

• Same effect as the "Home" button in Internet Explorer.
• Returns a byte indicating success (1) or failure (0).

• Handles initialization for the object, must be called before you call any other methods.
• The ParentControl parameter is your File Explorer window control.
• Four of the five parameters are optional.
  • The LoadPath parameter will load a document into the object once initialization is complete
  • The Handle1 and Handle2 parameters should not be passed.
  • The SkipCallbacks parameter determines whether the object will be initialized with callback function support.
• This method returns a byte indicating success (1) or failure (0).

ThisViewer.Kill()

• Handles the "closing down" of the feBrowser object.
• Must be called (typically) as the window which hosts the object is closed.
• Do not pass anything as the "level" parameter, leave it to default to 0.
• This method returns a byte indicating success (1) or failure (0).

Loads a document (passed as the CurrentPath parameter) into the html viewer control.

Parameters

• string CurrentPath: The URL to navigate to. This can be the address of a web site, the path to a document on disk etc.
• long currentControl: (Optional) The control to load the document into. If the CurrentControl parameter is omitted, the control which you passed in the Init() method is used.
• long pFlags: Currently unsupported. (Optional) Specifies whether to add the resource to the history list, whether to read from or write to the cache, and whether to display the resource in a new window
• string pTargetFrameName: (Optional) Used to set which frame the document will load into. Have a look in the feabc.app example, in the procedure called "Advanced_feBrowser_Frames1" to see how this is implemented.  Possible values are:

_BLANK: Load the link into a new unnamed window.
_PARENT: Load the link into the immediate parent of the document the link is in.
_SELF: Load the link into the same window the link was clicked in.
_TOP: Load the link into the full body of the current window.
<WINDOW_NAME>: A named HTML frame. If no frame or window exists that matches the specified target name, a new window is opened for the specified link.

• string pPostData: Currently unsupported. (Optional) Specifies data to send with the HTTP POST transaction. If you omit this parameter File Explorer does a HTTP GET. Support for this parameter is currently not working and will be added to a future release of File Explorer.
• string pHeaders: (Optional) Used to send HTTP headers to the server, which will be added to the default Microsoft Internet Explorer headers.

Return Value

Returns a byte indicating success (1) or failure (0).

Examples

ThisViewer.Load('www.CapeSoft.com')
ThisViewer.Load('www.CapeSoft.com',,, '_top')
ThisViewer.Load('www.CapeSoft.com',,, 'BannerFrame')

Loads the Browser control from a string in memory. This can be used to load web pages stored in BLOB, HTML contents directly back into the browser and using .GetInfo() to retrieve the content, modifying it, and then .LoadFromStream() to update the contents of the browser etc.

Parameters

*cstring szHtml: A cstring (null terminated string) that contains the HTML to load. This parameter is passed by address, but is not modifying by the function.

Return Value

This method has no return value.

Note: If an error occurs then the error information will be output to the system debug log (this and all other debug information can be viewed using SysInternals DebugView, available from www.sysinternals.com.)

Examples

htmlData       cstring(4096)  
! Note: Typically the string should be dynamically allocated unless the exact size is known.
  code
    htmlData = '<html><head><title>Loaded From Memory</title></head>' |
               & '<body bgcolor="white"><h1>Hello World</h1>' |
               & '<p>Loaded from memory!</p></html>'

    feWebBrowser.LoadFromStream(htmlData)

frameName  STRING(20)
  code
    frameName  = ThisViewer.NameOfFrame(2) ! returns the name of frame 2

• Returns the name of a frame.
• See the Advanced_feBrowser_GetInfo procedure in the feabc.app example application to see this method being used.

totalFrames      long
  code
    totalFrames = ThisViewer.NumberOfFrames()

• Returns the number of frames in the currently loaded document.
• See the Advanced_feBrowser_GetInfo procedure in the feabc.app example application to see this method being used.

  ThisViewer.PrintMe()
or
  ThisViewer.PrintMe(false)

• Prints the loaded document.
• If you pass true (1) as the ShowDialog parameter, the "Print Options" dialog window is called.  If you pass false (0), the document is printed immediately.
• Returns a byte indicating success (1), or failure (0).

Provides the same effect as the "Refresh" button in Internet Explorer. This forces the control to reload the page from the server, the parameter will determine how the refresh is done (for example whether a cached version of the page can be used etc.)

Parameters

Optionally, you can pass this method a byte (Level), which will determine the "type" / "level" or refreshing you want done.  This can be one of the following values:

fe:Browser_RefreshLevel_Normal

Refresh that does not include sending the HTTP "pragma:nocache" header to the server. The server may return a cached version of the page.

fe:Browser_RefreshLevel_Default

Behaves in the same manner as fe:Browser_RefreshLevel_Normal.

fe:Browser_RefreshLevel_IfExpired

Refresh that occurs if the page has expired. This refreshes the page, and if the cached version has expired then a new version will be fetched.

fe:Browser_RefreshLevel_Completely

Refresh that includes sending a "pragma:nocache" header to the server (HTTP URLs only). This refreshes the actual page, and asks the server not to returned a cached version. This is potentially the slowest (the most data needs to be transferred) however it ensures the current version of the actual page is retrieved.

Return Values

Returns a byte, indicating success (1), or failure (0)

ThisViewer.Reload()

• This method reloads the last document which you loaded into the object.  (i.e. The last documented loaded using the Load method).
• If you omit the CurrentControl parameter, the same control which you used in the Init method is used.

ThisViewer.Resize()

• In one sentence:  This method handles the resizing of the object ("viewer control") on the window, and should be called whenever the window resizes ( the templates will do this for you by generating code in the WindowResizeClass::Resize method ).
• In many sentences:  The object you see on the window is not actually created "inside" the ParentControl (see the Init method).  We actually use the parent control to get the coordinates for the object, then create the object "on top" of those coordinates!  So if the parent control resizes, the File Explorer object needs to know about that so that it too can resize to appear to resize "with" the parent control.  The templates call this method for you in the WindowResizeClass's "Resize" method.  If you "manually" resize the parent control (hand code), you'll need to call File Explorer's Resize method to keep the object "in synch" with the parent control, as shown above.

ThisViewer.SearchPage()

• Loads the default (Internet Explorer) search page.
• Returns an (optional) byte indicating success (1), or failure (0).
• Note that this purely loads a page, if you need to locate a specific string of text in a loaded document use the feBrowser.Edit() method.

ThisViewer.SelectElementByID(3)

• Use this method to select the contents of an element (field), where you do not know the name of the element (in which case it is better to use the SelectElementByName method), but where you know the ID (number) of the element (note: this number is provided by File Explorer, and will change if fields are added or removed to the html page you are dealing with).
• To see this code in action, have a look at the Advanced_feBrowser_DOM procedure in the feabc.app example application.

ThisViewer.SelectElementByName ('MyField1')
ThisViewer.SelectElementByName ('MyField1', 3)

• Use this method to select the contents of an element (field), where you know the name of the element (field).
• The FrameNumber parameter can be used if you have a loaded document which contains frames.
• To see this code in action, have a look at the Advanced_feBrowser_DOM procedure in the feabc.app example application.

Note: Certain elements (e.g.. FileInputElements) are marked read-only, and cannot be set using methods such as SetValueByName.  The following code does work, but is a bit of a hack..  Provided here as an additional example:

ThisViewer.SetFocus()
ThisViewer.SelectElementByName ('MyField1')
presskey(TabKey)
presskey(ShiftTab)
presskey(CtrlA)
presskey(DeleteKey)
press('Hello!')

ThisViewer.SetFocus()

• Sets the focus to the Window that contains the feBrowser object.

ThisViewer.SetValueByID ('id5', 'James')

• See the GetElementQ method to understand the context of this method.
• Use this method when you want to set a field's value in an html document, where you know the field's ("element's" / "object's") ElementID (each element (think "object") in an html page has its own ElementID)  For instance, if you have loaded an html page which has an entry field on it where users enter their last names, so long as you know that entry field's ElementID you can set the value for that field from your own (Clarion) code.  To elaborate, if you have an entry field in an html page as follows...

<input id="id5" type="text" name="LastName" size="20">

• ... you could actually set the value in that field by using the code at the top of this section.
• To see this code in action, have a look at the "Advanced_feBrowser_DOM" example in the feabc.app example application.

ThisViewer.SetValueByName ('LastName', 'James')

• See the GetElementQ method to understand the context of this method.
• Use this method when you want to set a field's value in an html document, where you know the field's ("element's" / "object's") ElementName (each element (think "object") in an html page has its own ElementName)  For instance, if you have loaded an html page which has an entry field on it where users enter their last names, so long as you know that entry field's ElementName you can set the value for that field from your own (Clarion) code.  To elaborate, if you have an entry field in an html page as follows...
  <input id="id5" type="text" name="LastName" size="20">
  
• Here's another useful example:
  ! This example shows how to write to a field if there is
  ! more than one field with the same name! In this example
  ! there were two fields bothe names "zip", and we are
  ! writing different values to those two fields.
  ! ThisViewer1.SetValueByName ('zip', 'First ZIP Field', 0, 1)
  ! ThisViewer1.SetValueByName ('zip', 'Second ZIP Field', 0, 2)
  
• ... you could actually set the value in that field by using the code at the top of this section.
• The FrameNumber parameter can be used if you have a loaded document which contains frames.
• To see this code in action, have a look at the "Advanced_feBrowser_DOM" example in the feabc.app example application.

ThisViewer.Stop()

• Same effect as the "Stop" button in Internet Explorer.
• Returns a byte indicating success (1), or failure (0).

ThisViewer.SubmitForm()
ThisViewer.SubmitForm ('form2')

• If there is a form in the html page which you are browsing, and the form has a "submit" button, this method will trigger that button.  Very cool!
• What's more, if you have a page that contains more than one form, you can specify which form to "submit" using the "FormName" parameter.
• To see this in action, have a look at the Advanced_feBrowser_DOM procedure in the feabc.app example application.

TempString  STRING(40)
...
TempString = ThisViewer1.TranslateEventID (SomeEventID)

• See the EventCallback method for background info.
• The EventCallback method allows you to see EventID's as callback events are fired.  These longs are explained in the Useful References section of this document, along with the actual name (string) of each event that the longs represent.  The TranslateEventID method takes the long (EventID) as a parameter, and returns the name of the event (string) if the event number is known.
• See the Advanced_feBrowser_SimpleCallbacks procedure in the feabc.app example application to see this method in action.

ThisViewer.UnhideControl()

• Unhides the File Explorer viewer control.  Note: ?feControl{prop:hide} = false will not work.

ThisViewer1.Update ('PrinterHeader', 'This is my header')
ThisViewer1.Update ('PrinterFooter', 'This is my footer')
ThisViewer1.Update ('PrinterOrientation', 'Landscape')
ThisViewer1.Update ('PrinterOrientation', 'Portrait')
ThisViewer1.Update ('SilentMode', true)

• Use this method to update various "properties" / "values" for the object.  Some times these "values" are actual properties of the File Explorer class, sometimes not.  The reason you use this method and don't just change the properties "directly" is because using this method results in the changes being implemented "immediately", and not for instance only coming into effect the next time you load a document into the object which is often the "default" behaviour.
• The Property parameter can be one of the following:
  • PrinterHeader
  • PrinterFooter
  • PrinterOrientation
  • OuterHtml  - not yet working, still busy with this...
  • SilentMode  - (see "Note 2" below)
  • Offline
  • RegisterAsBrowser
  • RegisterAsDropTarget
  • TheaterMode
  • AddressBar
  • MenuBar
• NOTE 1:
  For backward compatibility, this method still supports "Html1PrinterHeader" and "Html1PrinterFooter" as the Property parm.  Please change your code to use "PrinterHeader" and "PrinterFooter" instead if you have hand-coded this anywhere.  Not urgent, just more tidy.
• NOTE 2: SilentMode
  The SilentMode property is used to set whether dialog boxes can be shown or not.  You can call the update method to set this property to either true or false any time after you've called the Init method.  By default this property is set to false, so dialog boxes will be shows (script errors etc).  Setting it to true (as in the code example above) will result in dialog boxes not being shown (so you won't see script error messages etc).  You could also set this property to say true before loading a certain page, then back to false again once you've finished on that page...

Fired when the user double clicks in the control.