File

projects/wms-framework/src/lib/baseframework/HtmlPage.ts

Description

Base class for HtmlPage

Index

Properties
Methods
Accessors

Properties

Static innerWindow
Default value : new HtmlWindow()

Methods

Static PopupWindow
PopupWindow(navigateToUri: any, target: string, options: any)

PopupWindow method

Parameters :
Name Type Optional
navigateToUri any No
target string No
options any No
Returns : any
Static RegisterCreateableType
RegisterCreateableType(scriptAlias: string, type: any)

RegisterCreateableType method.

Parameters :
Name Type Optional
scriptAlias string No
type any No
Returns : void
Static RegisterScriptableObject
RegisterScriptableObject(scriptKey: string, instance: object)

Registers an object instance in window.Content with the specified key.

Parameters :
Name Type Optional
scriptKey string No
instance object No
Returns : void
Static UnregisterCreateableType
UnregisterCreateableType(scriptAlias: string)

UnregisterCreateableType method

Parameters :
Name Type Optional
scriptAlias string No
Returns : void

Accessors

BrowserInformation
getBrowserInformation()

Browser information

Returns : any
IsEnabled
getIsEnabled()

A flag to determine if the page is enabled

Returns : boolean
IsPopupWindowAllowed
getIsPopupWindowAllowed()

Indicates if the popup windows is allowed

Returns : boolean
Plugin
getPlugin()

Gets the plugin

Returns : any
Window
getWindow()

Gets the current window object

Returns : any
import { Debugger } from '../diagnostics/Debugger';
import { HtmlWindow } from './HtmlWindow';

/**
 *  Base class for HtmlPage
 *
 * @export
 * @class HtmlPage
 * @wType System.Windows.Browser.HtmlPage
 */
// @dynamic
export class HtmlPage {
  static innerWindow = new HtmlWindow();
  /**
   * Browser information
   *
   * @readonly
   * @static
   * @type {*}
   * @memberof HtmlPage
   * @wNoMap
   */
  public static get BrowserInformation(): any {
    Debugger.Throw('Method not implemented');
    return null;
  }
  /**
   * A flag to determine if the page is enabled
   *
   * @readonly
   * @static
   * @type {boolean}
   * @memberof HtmlPage
   */
  public static get IsEnabled(): boolean {
    return true;
  }
  /**
   * Indicates if the popup windows is allowed
   *
   * @readonly
   * @static
   * @type {boolean}
   * @memberof HtmlPage
   * @wNoMap
   */
  public static get IsPopupWindowAllowed(): boolean {
    Debugger.Throw('Method not implemented');
    return null;
  }

  /**
   * Gets the plugin
   *
   * @readonly
   * @static
   * @type {*}
   * @memberof HtmlPage
   * @wNoMap
   */
  public static get Plugin(): any {
    Debugger.Throw('Method not implemented');
    return null;
  }

  /**
   *  Gets the current window object
   *
   * @readonly
   * @static
   * @type {*}
   * @memberof HtmlPage
   */
  public static get Window(): any {
    return HtmlPage.innerWindow;
  }

  /**
   * PopupWindow method
   *
   * @static
   * @param {*} navigateToUri
   * @param {string} target
   * @param {*} options
   * @returns {*}
   * @memberof HtmlPage
   * @wNoMap
   */
  public static PopupWindow(
    navigateToUri: any,
    target: string,
    options: any
  ): any {
    Debugger.Throw('Method not implemented');
    return null;
  }

  /**
   * RegisterCreateableType method.
   *
   * @static
   * @param {string} scriptAlias
   * @param {*} type
   * @memberof HtmlPage
   * @wNoMap
   */
  public static RegisterCreateableType(scriptAlias: string, type: any): void {
    Debugger.Throw('Method not implemented');
  }

  /**
   * Registers an object instance in window.Content with the specified key.
   *
   * @param {string} scriptKey
   * @param {object} instance
   * @memberof HtmlPage
   */
  public static RegisterScriptableObject(
    scriptKey: string,
    instance: object
  ): void {
    let _window: any = window;
    _window.Content = _window.Content || {};
    _window.Content[scriptKey] = instance;
  }

  /**
   * UnregisterCreateableType method
   *
   * @static
   * @param {string} scriptAlias
   * @memberof HtmlPage
   * @wNoMap
   */
  public static UnregisterCreateableType(scriptAlias: string): void {
    Debugger.Throw('Method not implemented');
  }
}

result-matching ""

    No results matching ""