Restrictions Associated with Environment

Caret position when focus moves into MaskEdit

The position of a caret will move to the end of text when focus moves into the MaskEdit component. This problem occurs in the iOS environment when the type property of the MaskEdit is set to "string".

Restriction related to file download when applying Enhanced Protected Mode.

If you check the Enhanced Protected Mode option in IE10 or later, the download path will be virtualized so that files will be downloaded only to a specific folder while other Windows folders are protected. In this case, therefore, users are prevented from designating their own download paths.

appendItem method of FileUpload fails to be executed

If you call the appendItem method of a FileUpload component repeatedly in the Safari browser, the method will not work from the second instance of calling.

Restriction on search for text value in editable field

In Internet Explorer, you cannot search for the text value entered in the editable field of a component by using the search feature of the browser.

Windows increasingly takes up memory when WebBrowser is created and deleted repeatedly

Windows will increasingly take up memory if you repeat the creation and deletion of a WebBrowser component when running the NRE. Consequently, Windows will slow down.

One example is a case where you link a Div component to a Form that contains a WebBrowser by specifying the Form as the value of the Div's url property. Whenever you change the value of url, the creation and deletion of a WebBrowser are repeated, increasing the use of memory.

onmouseout event of Div fails to occur if you move mouse pointer quickly

If the onmouseout event is set for a Div component that contains child components, onmouseout should occur when a mouse cursor moves through the Div. However, the event will not occur if the cursor moves quickly.

See the below example where the blue and red zones are a Div and Button component respectively. If you move a mouse pointer quickly from the bottom to the top of the Div through the Button, onmouseout may not occur occasionally.

The below HTML code represents the above example, while the code would be more complicated if it was generated with the Button actually placed. The failure to trigger onmouseout in a web browser happens only when a Div tag is nest within another Div tag.

<div id="mainframe.QuickViewFrame.form.Div00" 
    style="left: 141px; top: 504px; width: 400px; height: 115px; 
    background:#0000ff; ">
    <div style="left: 20px; top: 20px; width: 300px; height: 73px; 
        background:red; ">Button00
    </div>
</div>

Restriction on use of virtual numeric keyboard in accessibility mode

With an app whose accessibility features turn on in iOS, the default type keyboard will appear instead of a numeric keyboard for a component with an editable field even when the component’s inputtype property is set to “number”. This is because, in iOS, a screen will scroll up to the top automatically if a numeric keyboard appears with the accessibility features on. Therefore, Nexacro Platform is programmed to display the default keyboard in such a case.

Script error caused by ActiveX Filtering

If you enable ActiveX Filtering in IE9 or higher, an ActiveX object cannot be used, resulting in the failed execution of the object and a script error.

Use of cookies is restricted in iOS depending on update types

If you set the update type to “Update” or “Local” for deploying an app running in iOS, cookies are not allowed for content (Run.html) that is installed in a device’s local directory. If you have to use cookies nevertheless, you should set the update type to “Server” and specify the same domain for two servers: one is the server that manages the content and the other is the request server defined in the transaction method.

With the content file (Run.html) running in a local path (file://), no cookies are allowed. You are also not allowed to access cookies through a script (document.cookie) or to set cookies by using a WKWebView API (WKHTTPCookieStore).

Installation of Nexacro Platform-based app fails due in Windows.

Upon the execution of the installation file of a Nexacro Platform-based app running in Windows (nexacro17_SetupRuntime_xXX.exe), the installation can fail due to an error related to api-ms-win-crt-runtime-l1-1-0.dll. This error occurs when your Windows is not updated with the latest version. Therefore, the error will be fixed once you install the latest update.

For example, the error can occur if you have not updated your Windows 7 after SP1. To solve the problem, you should start Windows Update or download a package that can fix the error. Please click the below link for the details.

Value of type property of Screen object is predetermined for iPads

When an app is launched in a device, Nexacro Platform will check the type, specifiedos and specifiedlocale properties of defined screens to find the best fit for the device’s display and its operating system. However, only the value "mobile_large" applies to iPad series because those tablets do not provide enough information on their display sizes.

The below list presents related iPad devices. The list can grow as time goes by, depending the plan of the vendor.

Apple iPad 1,2
Apple iPad Air 1,2
Apple iPad Pro
Apple iPad mini 1,2,3,4

Date displayed in Calendar differs according to devices.

If a month and day is a single digit (1 to 9), the month and day displayed by a Calendar will vary according to operating environments. This restriction cannot be resolved by Nexacro Platform since how to display a date is controlled by web browsers.

If the popuptype and value properties are set to “system” and “20190501” respectively, for example, an iOS- and Android-powered devices will display "2019. 5. 1." and "2019. 05. 01" respectively. (System language is set to Korean in both OSes.)

Local file cannot be accessed through url property of WebBrowser

WKWebView in iOS does not allow you to access a file by using the URL scheme File://. Because of this restriction, it is impossible to distribute an HTML file to a local computer and then load the file using a WebBrowser component.

If you want to access an HTML file by using the callMethod method of a WebBrowser, you should set the update type to “Server”, an option selected in the Packing stage for accessing an HTML file located in a server. If you set the update type to “Update” or “Local”, you cannot access an HTML file through a WebBrowser.

Some Korean QWERTY keyboard produces output of English characters

Korean text input with a virtual keyboard in Android may result in the output of the English characters allocated to the keys that were pressed. This problem occurs when an Android app contains a MaskEdit whose format property includes @ as its value. @ is a mask that prevents the input of non-English languages including Korean.

This restriction applies to some virtual QWERTY keyboards that support Korean language. This anomaly is treated as a restriction because users can select their virtual keyboards at their discretion and it is impossible to deal with all virtual keyboard programs.

Grid leaves residual images when resized.

A Grid may leave its residual images when it is resized. This problem can occur when the Grid is laid out within a complicated structure and the application that includes the Grid runs on Internet Explorer running in a slow PC.

A large amount of calculation will be conducted when an HTML page is resized if there are many nodes in the HTML document and the CSS table model is used to express a table. In this process, a Grid may leave residual images depending on the performance of the hardware.

Text is hidden when italicized and aligned to the right

Right side of text may be hidden in a component when the -nexa-text-align and font-style properties are set to "right" and "italic", depending on the values of the font-family and font-size properties.

Different timings of determining change in date when system calendar is used

The timing of determining a change in a date differs according to operating systems. This restriction applies to a Calendar component that operates in mobile devices and whose popuptype property is set to "system". As this restriction is caused by the difference between OSes, you should check how this restriction applies to the OS on which your application runs.

imemode Property Value not Being Applied

In operating systems of Windows 8 or later, the IME application method has been changed, resulting in different input methods being set for each application, and the imemode property value is not applied when the focus on the application changes.

For example, if you open Notepad while running the Nexacro app, work on other tasks, and return to the Nexacro app, then the imemode property value of the component that has the first focus is not applied (when the focus is moved to another component after the first component, the imemode property value is applied).

The same applies when you open a window such as alert, confirm, or when you open a pop-up window through another process within the Nexacro app and then move the focus back to the Nexacro app.

In order to maintain the imemode property value in the Nexacro app, the user must manually change the related properties. In the Windows 10 operating system, you need to select the [Advanced keyboard settings > Switching input methods > Let me use a different input method for each app window] item as shown in the figure below (the unselected is the default setting).

canchange and onchanged Events Not Occurring even when ENTER Key is Pressed during Text Editing

The canchange and onchanged events occur when the value property value is changed when the ENTER key is pressed or the focus moves during text editing. However, in some operating systems, the events do not occur when the ENTER key is pressed.

When entering Japanese IME in the iOS/iPadOS operating system Safari browser, if the text input is confirmed with the ENTER key, then the event does not occur. This occurs as the keycode value is processed as an incorrect value when the ENTER key is pressed.

Parent Window Being Affected when Window Is Closed during HttpRequest Communication Being Processed in Pop-up Window

When the user clicks the close button to close the pop-up window while HttpRequest communication is in progress in the pop-up window opened with the nexacro.open method, the parent window may be closed together or refreshed. This can happen if your network is slow or if the file size you are loading is large.

In the case of the IE browser, the same PID (process ID) is shared in the pop-up window, and if a problem occurs in the pop-up window, then it may affect the parent window.

Please refer to the information below.

https://docs.microsoft.com/en-us/troubleshoot/browsers/webpage-fails-to-get-focus-ie-9

Screen Information Being Processed as Wrong Type in iOS 13 or Later Version

When running the Safari browser in iOS 13 or later operating systems, the screen size specified by the app may not be applied. This is the "desktop" type screen information being applied even though the "mobile_small" type screen should be used in iPhone. This occurs when the “Request Desktop Website” option of the safari browser is turned on in iOS 13 or later operating systems, and if the option is turned on, then the device information cannot be checked.

Line Breaking when Setting fittocontents Property Value

In browsers below IE11, when the fittocontents property value is set to "width" or "both" and the wordWrap property value is set to "char" or "english", a line break may occur. This occurs because browsers below IE11 cannot calculate the correct size depending on the font type or size, and the size changed according to the fittocontents property does not fit.

width: 120
height: 60
fittocontents: width
text: Nexacro Platform 17 is a software development platform
wordWrap: char
font: 11px/normal "Arial" / 12px/normal "Arial"

In the browser IE11 or earlier versions, line breaks may not occur depending on the font size as shown below.

Complete Button Being Displayed when Touching Edit Area Set as readonly

In iOS 12 and earlier versions, when the edit area set to readonly is touched, the complete button is displayed. This has been corrected in iOS 13 or later versions.

This occurs when you touch the edit area when the readonly property value of the Edit component is set to true. Even if the readonly property value is not directly specified, the same occurs when readonly is processed by the internal operation of the component. For example, the Combo component processes the comboedit area as readonly when the type property value is set to "dropdown", and if you touch the comboedit area rather than the dropbutton, then the “Complete” button is displayed.

Difference between Browsers

Difference in displaying cursor in editable field

If a component with an editable field has the readonly property set to "true", a cursor will be displayed in the field differently according to browsers. The value of readonly will be applied regardless of how to display a cursor, and you cannot edit the text in the editable field.

Restriction on style-related properties

The below table is a list of style-related properties that are not supported by Nexacro Platform or are supported in some browsers only.

Difference in text alignment when string contains line feed character

A string is aligned differently in the NRE and web browsers if the string contains a line feed character. This anomaly also entails the component’s -nexa-text-align and wordwrap properties that are set to “center” and “none” respectively.

This restriction applies to a Button, Static, FileDownload and GridCellControl object.

Restriction on hotkey property

The hotkey property can work differently according to browsers if you specify the property with a value that is the same as one of the keyboard shortcuts defined by web browsers.

Difference in presenting file paths in FileUpload

With the multiselect property set to "true", a FileUpload component will present file paths differently according to browsers.

With the multiselect property set to "false", a FileUpload component will present file paths differently according to browsers.

Difference in processing repeated child frame names produced by open method

A script error occurs in Internet Explorer 8 and thus a pop-up fails to appear when you call the open method of nexacroAPI multiple times. This error occurs when you specify all the strName parameters with the same value. The parameter is designed to define the name of a child frame opened by the method.

While a script error will not occur in the NRE or web browsers under the same condition, this problem is caused by the difference between browsers in processing pop-ups.

Difference in processing alert or confirm method that is included in a function

Google Chrome and Safari process the alert or confirm method earlier than any other codes when those method are included in a function.

For instance, the below sample codes are intended to print the string "TEST" first and then execute the alert method. However, Google Chrome and Safari will call alert first and will not print "TEST" until you close the alert window.

function fn_click() {
	document.write("TEST");
	alert("TEST");
}

Slow application of visible property

When you change the value of the visible property of a component through a script, subsequent codes may be executed before the status of the component displayed on the screen changes. This problem occurs often in IEs running in low-performance PCs.

Sequence of onmouseenter and onmousemove events

If a component has both the onmouseenter and the onmousemove events, the sequence of the events varies depending on browsers. The below table presents the sequences according to browsers.

Base for executing trackPopup method

The base for opening a component (PopupDiv or PopupMenu) can vary when calling the trackPopup method. In the NRE, the frame area including a titlebar serves as the base while the contents area excluding a title bar serves as the base in web browsers. Therefore, the position of opening a component can vary even when the same coordinate values are specified with the showtitlebar property set to "true".

// Using the trackPopupByComponent method
var x = this.Button00.getOffsetLeft();
var y = this.Button00.getOffsetBottom();
this.pdiv.trackPopupByComponent(this, x, y);

// Removing the value of the frame area in the NRE
var objBut = this.Button00; // Button serving as the base for opening the component
var v_nX = system.clientToScreenX(objBut, 0) - system.clientToScreenX(application.mainframe, 0);
var v_nY = system.clientToScreenY(objBut, parseInt(objBut.height)) - system.clientToScreenY(application.mainframe, 0);
var v_sRet = this.pdiv.trackPopup (v_nX, v_nY);

Difference in results of executing nexacro.getTextSize

The getTextSize method is used to calculate text size by factoring into its parameters. However, calculation results may vary according to browsers.

Calculation results can vary according to browsers as well as the arguments of the parameters. The below table shows the difference in results when the method is executed with certain arguments in different browsers. The below table is presented just to help your understanding.

this.Static00.set_text("nexacro");
this.Static00.set_font("10 Arial");
var textSize = nexacro.getTextSize(this.Static00.text, this.Static00.font, null, "none", 0);
trace(textSize.nx, textSize.ny); // result

Browser treats certain component as its own object.

This restriction can occur when the ID of a Geolocation, which is one of the DeviceAPI objects, is defined as “Geolocation” in TypeDefinition. In this case, a web browser will not be able to find the Geolocation when the app is launched. Instead, the web browser will treat the Geolocation as its own object.

This anomaly occurs since the name "Geolocation" is used for an object of web browsers. If you use another ID like "NexacroGeolocation", you can use the Geolocation of the DeviceAPI properly.

Restriction caused by transaction method executed in synchronous mode

You can set the synchronous mode for transmitting data by setting the bAsync parameter of the transaction method to "false". In this case, however, your app may not work properly in some browsers.

Text Entered in Edit Blinks

Text entered in an Edit component can appear blinking or moving if you enter the text, move the focus out from the Edit and bring the focus back to the component.

Restriction on Calling of setPrivateProfile or getPrivateProfile Method in Safari

A script error will occur if you call the setPrivateProfile or getPrivateProfile method of an Application object when you use Safari. The error will occur in the below-mentioned case and is attributable to Apple's policies for Safari.

• When Private Browsing is turned on

Caret in Edit Penetrates Another Component

This error occurs when another component hovers over an Edit component. If you move focus to the under-lying Edit, a caret in the Edit will appear penetrating the hovering component.

IE fails to process pending events while it is taken up for a certain amount of time by a specific script

IE fails to process pending events while it is taken up for a certain amount of time by a script that conducts the sleep method of a Form or performs a repetitive statement like a for-loop.

Let us assume that you trigger an event by clicking a Button component while sleep is being executed in IE. In addition, assume that you have designed the script to process the Button-triggered event after the span specified by the parameter of sleep. However, you will find IE failing to process the event.

Different behavior between browsers when the 'undo' item is selected from a context menu

Browsers show different behavior in response to the 'undo' command. This restriction is faced under the following condition. To begin, select text in an editable component, right-click to open a context menu and choose 'Delete' or 'Cut'. Then, move the focus to another component, open a context menu and choose 'Undo'. This is the point when the restriction has an effect.

When you use the <input> tag of HTML, executing the 'undo' command yields partially different results compared to the NRE. The reason for this difference is that some browsers cannot deliver the event triggered by the 'undo' command.

Restriction on calling of alert and confirm methods within onbeforeexit or onexit event

Some browsers may fail to call the alert and confirm methods if they are written within the handler of the onbeforeexit or onexit event of an Application object. Browsers should call those methods indeed unless they are written within the handler of those events.

Focus fails to move to editable component when you make touch actions quickly

This restriction is caused by the Safari browser running in the iOS environment when there is an editable component like an Edit. If you touch another component and then an editable component quickly, the editable component will not become focused while the 'focused' status-class will apply to the component.

This is a browser-specific restriction. Nexacro Platform changes the status-class of the editable component when a touch event occurs in Safari. However, Safari fails to move the focus although the browser has triggered the touch event. Accordingly, Nexacro Platform cannot correct this problem since Safari successfully delivers the event to Nexacro although it fails to move the focus.

Div blinks when focus moves to an editable child component that is partially hidden

This restriction is caused by Internet Explorer (IE) when a Div component contains an editable component that is partially hidden. If focus moves to the editable component, IE is designed to scroll the Div so that the editable component shows entirely. In this case, however, Nexacro Platform is designed to scroll the Div back to the original position because the previous scrolling was not intended by a user. Going through the whole process, the entire Div may appear to blink.

Caret moves unintentionally if focus moves to editable component when wait cursor shows

In the editable field of a component, you can see a caret moving to the end of the field rather than showing in the position that you click. This problem occurs as the following two actions happen at the very same time: one is moving focus to the component by clicking and the other is calling transaction or setWaitCursor method.

This restriction applies only to Internet Explorer (IE). The cause is that a layer for a wait cursor is activated, and the layer overlaps the editable field of a component. This restriction occurs when an <input> tag is nested within a <div> tag.

Event bubbling when enable property is set to 'false'

As for editable components, rules of event bubbling (to a Div or Form) are different according to web browsers. This restriction is imposed when you click the editable fields with the enable properties of those components set to 'false'.

You can test this restriction with the below HTML code. If you click the inputtable field of the component at the lowest level, the onmousedown event within the <div> tag will be fired in the browsers that bubble the event. In Firefox and Microsoft Edge, however, the event will not be fired.

<div onmousedown="console.log('div onmousedown')">
	<input type="text" disabled>
	<input type="text">
</div>

File dialog cannot be opened by callback

Certain web browsers fail to open a file dialog when a method called by a callback attempts to open the dialog. Here, the callback is programmed to operate after the execution of the transaction method. For example, a file dialog will fail to be opened when the importData method of an ExcelImportObject is called by such a callback.

The isTrusted property is set to “false” for an event defined in a script rather than an event fired by a user’s click. Certain web browsers restrict some actions when isTrusted is set to “false”.

Focus cannot move from modeless pop-up to parent window

Focus will not move to the parent window (or a component in the parent window) when the setFocus method is called from a child modeless window. This restriction occurs when you open the modeless pop-up by calling the open method in a web browser.

To control the focus within the screen launched in the parent window, the relevant web browser window must be activated. However, you cannot control the activation of a web browser window; hence this restriction.

Component does not appear when trackPopup comes after alert or confirm

In some browsers, the trackPopup method seems not to be executed when the execution comes after alert, confirm or other methods that require users to click a button to close a dialog (See the below sample code). This restriction can occur to a PopupDiv or PopupMenu component.

this.Button00_onclick = function(obj:nexacro.Button,e:nexacro.ClickEventInfo)
{
	confirm('test');
	this.PopupMenu00.trackPopup(0,0);
};

Although the trackPopup method is in normal progress, closing a dialog will fire the ondeactivate event at the exact time when the execution of trackPopup begins. As a result, the component is closed as soon as it appears.

To avoid this restriction, which applies to Google Chrome and Opera, you should not use the alert/confirm method and the trackPopup method consecutively.

Application behaves differently when first-focused component holds editable field

A screen will behave differently according to operating systems and browsers if an editable field is held by the first component that receives focus after the loading of the screen.

Caret in TextArea is placed outside screen when virtual keyboard appears

A caret in a TextArea cannot be displayed on the visible area of the screen when you move the caret to a certain position in the component and then a virtual keyboard appears. This anomaly happens when text is written on multiple lines. There will be too many possible positions of a caret if a TextArea is bigger than the visible area of the screen while a virtual keyboard is displayed on the screen. Since it is impossible to deal with all every possible case, this issue is defined as a restriction.

This restriction has been confirmed in the default browser of Android. This restriction may be found later in other running environments.

Text is hidden partially when padding applies to component

Text inside a component will be displayed in varying ways according to components and browsers with the padding property applied. This anomaly occurs when the text and padding areas overlap.

In the below example, the padding areas of the Edit and Button components are all set at 20px. In the NRE, the text is hidden as much as the sizes of the padding areas. In Google Chrome, however, the text is not hidden under the padding areas as the web browser applies the padding property partially, although the application of this technique varies according to components.

Text is partially hidden when wordwrap property is set to "english"

With the wordWrap property of a component set to “english”, the NRE and web browsers display the text in the component in different ways when the width of the component shrinks to a certain extent.

In the below image, for example, the two segments surrounded by red rectangles are the result produced by Google Chrome while those without red rectangles are produced in the NRE. When the widths are enough for the entire text, both the NRE and a web browser show the same result. When the widths are not enough for the entire text, however, the NRE breaks lines within a word while a web browser does not show the portion of text that exceeds the border line.

This restriction applies to the components that have the wordWrap property, except for the TextArea component.

Clicking Cancel button in file dialog of FileUpload leads to different behaviors

Assume that you open a file dialog by clicking the Find button of a FileUpload component and then select a file. Next, you click the Find button again and then click the Cancel button to close the dialog without selecting any file. Eventually, you will find that the previously-selected file has been removed from the FileUpload after closing the file dialog.

Because clicking the Cancel button calls off the previously-selected file, the relevant item will be removed from the filelist property, followed by the occurrence of the onitemchanged event. This incident can occur only in Google Chrome.

-- the onitemchanged event occurs when you select a file
onitemchanged / this.FileUpload00.filelist[e.index]: [object VirtualFile]
onitemchanged / e.newvalue: C:\fakepath\a.png
onitemchanged / e.oldvalue: 
-- the onitemchanged event occurs when you click the Cancel button without selecting a file.
onitemchanged / this.FileUpload00.filelist[e.index]: undefined
onitemchanged / e.newvalue: 
onitemchanged / e.oldvalue: C:\fakepath\a.png

Difference between browsers shown when component with editable field is scrolled out of view by mouse wheel

Browsers show different behaviors when you enter text in an editable field that is placed out of the screen. This restriction occurs when you move the screen by using a mouse wheel in the middle of entering text in a component with an editable field like an Edit or TextArea. In such a case, some browsers will adjust its scrolling position to get the component back into sight while other browsers do move the screen.

For example, Internet Explorer will change its scrolling position to bring a component from the outside to the top of the screen.

Even if a browser does not adjust its scrolling position, leaving a component outside the screen, you still can keep entering text because the focus and caret will stay in the component.

Difference between browsers over virtual keyboard shown when focus moves to content loaded by WebBrowser

In the NRE, an editable field will be hidden by a virtual keyboard that appears after the field is focused. This anomaly occurs when the editable field is included in the content defined as a value of the url property of a WebBrowser.

Border of PopupDiv is not displayed when placed upon SWF content

Various restrictions can occur when HTML content is placed upon SWF content. In Internet Explorer, for example, the border of a PopupDiv may not be displayed if the component is placed on SWF content. In this case, you should add the option wmode="transparent" to the SWF content.

<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="600" height="200" id="myFlashContent">
        <param name="movie" value="./logo.swf" />
        <param name="wmode" value="transparent" />
        <!--[if !IE]>-->
        <object type="application/x-shockwave-flash" data="./logo.swf" width="800" height="200">
            <param name="wmode" value="transparent" />
        <!--<![endif]-->
            <a href="http://www.adobe.com/go/getflashplayer">
                <img src="http://www.adobe.com/images/shared/download_buttons/get_flash_player.gif" alt="Get Adobe Flash player" />
            </a>
        <!--[if !IE]>-->
        </object>
        <!--<![endif]-->
</object>

onclose of MainFrame fails to occur in web browser

The onclose event of a MainFrame object will not occur even if you close a web browser or its tab. The below table presents the cases where onclose occurs according to browsers.

Border of PopupDiv is not displayed when placed upon Plugin

The border of a PopupDiv may not be displayed if the component is placed upon ActiveX content (windowed plug-in) loaded by a Plugin component. The portion of the border in the overlapping area will be hidden. The Plugin component should be restructured to resolve this problem. However, it has been decided that this restriction will remain because the attempt to fix it may have a large impact.

oncelldblclick event of Grid is processed differently according browsers

This restriction occurs when the edittype property of a Grid cell is set to button, date, mask, readonly, text or textarea—values with which clicking the cell prompts the activation of an editable control. Depending on browsers, double-clicking the cell does not fire the oncelldblclick event.

A new control varying according to edittype is exposed in a Grid cell after the cell is clicked. However, a double-click can fail to be processed depending on browsers.

Mouse wheel scrolling does not work in WebBrowser

Mouse wheel scrolling may not work in a WebBrowser component. This restriction occurs when you set the url property of the WebBrowser with content from a domain different from the current one. Moreover, the scrollbars of the WebBrowser are activated due to the content size while the scrollbars in the content have been removed forcibly.

Error when Entering Input Characters Quickly for Japanese IME Input

When the type property value of the MaskEdit component is set to "string", the format property value is set to "99-99-99", and when Japanese IME is entered, the caret position or input value may be incorrectly processed in the following cases.

• When entering numbers quickly with the keypad

• When entering quickly while correcting unconfirmed characters during Japanese IME input

This is a problem caused by browser-specific differences in how caret position is processed at the DOM level, and it cannot be correct in Nexacro Platform.

Content Not Being Displayed after Page 2 for system.print Method Execution

When the target content to be displayed exceeds 2 pages, the content cannot be displayed after the 2^nd page for the system.print method execution in the Firefox browser.

The content not being able to be displayed after the 2^nd page also occurs even in the HTML/CSS contents using the position:absolute style.

Japanese Input Being Reflected as value Property Value before Confirmation

In the Chrome and Edge browsers, if you select the character string that was confirmed after Japanese IME input using the CTRL+A shortcut key and reenter the same character as the first character, then the character entered before the confirmation may be reflected as the value property value.

For example, if you enter and confirm the character string "あああ" in the Edit component, and then select "あ" with the CTRL+A shortcut key, then the value property value is reflected as follows.

Restrictions Inherent in Nexacro Platform

Restriction on popuptype property of Calendar

There will be change in the range of supported events if the popuptype property of a Calendar component is set to "system" in mobile devices. The supported/unsupported events are listed below.

Color fails to be copied from cell in Excel file exported from ExcelExportObject

If you copy a cell in an exported Excel file and paste it into a new Excel document, the color defined in the copied cell will not be copied. This problem occurs with the exporttype property of the ExcelExportObject set to nexacro.ExportTypes.EXCEL when the Excel file was exported.

Restriction on selecting multiple cells in Grid after zooming in/out

Selection of multiple Grid cells will function differently from your intention when you drag-select those cells after you have zoomed in or out on the web page. This problem occurs when the selecttype property of the Grid is set to “multiarea”. The function of selecting multiple cells uses screen coordinate values because cells should be selected even if the mouse pointer leaves the Grid area in the process of selection. This mechanism causes the malfunction.

Restriction on printing out WebBrowser

Normally, the System.print method prints out the whole area of a Form, including the hidden area to which you have to scroll to present the area on the screen. If a WebBrowser component is included in the Form, however, such a hidden area will not be printed out while only a currently-seen area will be printed. The reason is that, in that case, calling the System.print method will lead to the execution of the window.print method of JavaScript.

In the below sample, two Edit components are placed on the upper and lower sides of a Form while a WebBrowser component is placed on the right-hand side, showing a map. If the System.print method is called in the NRE, the area of a red rectangle will be printed out. By contrast, the area of a blue rectangle will be printed out in web browsers as the area is currently seen on the screen.

Difference between Nexacro Platform and JavaScript methods

If you call the alert or confirm method without specifying a selector, the relevant methods from JavaScript will be executed. Those JavaScript methods may function differently to those from Nexacro Platform.

this.Button00_onclick = function(obj:nexacro.Button,  e:nexacro.ClickEventInfo) {
	alert("TEST"); // javascript alert method
	this.alert("TEST"); // Form object alert method
	nexacro.getApplication().alert("TEST"); // Application object alert method
}

As seen in the below picture, methods redefined in Nexacro Platform include codes for performing the platform's unique algorithms. Therefore, those will be processed in a way different to basic JavaScript methods.

Restriction caused by HTTP Header

If you set HTTP headers on the server side or use meta tags in HTML documents, some features of your application can be restricted according to security policies. The natures of the product account for such restrictions.

Content-Security-Policy

If you apply this policy, some functionalities may not work depending on the settings of directives. Nexacro Platform libraries include codes containing eval functions and in-line scripts. Such codes can conflict with the policy.

Therefore, you should add directives that grant permission for eval functions and in-line scripts, as presented below.

<meta http-equiv="Content-Security-Policy" 
    content="default-src *;
    style-src 'self' 'unsafe-inline'; 
    script-src 'self' 'unsafe-inline' 'unsafe-eval'">

X-Frame-Options

If the value of this header is set to "DENY", some features of your application may not work properly. Particularly, the "DENY" value forbids a WebBrowser component as well as image processing and text size caching features, which all use an iframe as a result of generating the application.

This problem can be solved if you do not apply the "DENY" value, as presented below.

<meta http-equiv="X-Frame-Options" 
    content="… " />

Restriction on character length when receiving value from WebBrowser within onusernotify event

The onusernotify event is used to fetch a value from a web document loaded onto a WebBrowser component. In the NRE, however, the delivered value has limits in the length of characters.

Virtual keyboard covers editable component when Fullscreen is set in Android

Setting Fullscreen in the AndroidManifest.xml file as presented below may cause a restriction: when you move focus to an editable component, a virtual keyboard can cover the component so that you cannot make an input.

android:theme="@android:style/Theme.NoTitleBar.Fullscreen"

Components Being Displayed at the Top in Android OS

You cannot place other components on top of some components in Android NRE. Components displayed as pop-ups are also displayed under the corresponding components if they overlap the corresponding components.

The target components are as follows.

GoogleMap, WebBrowser

Text is hidden partially when fittocontents is applied

Part of text in a Static will be hidden if you italicize the text or specify “italic” as a value of the font property with the usedecorate property set to “true”. This problem occurs when the fittocontents property is set to “width”. Nexacro Platform calculates the width of text written in a component when fittocontents is applied. However, this restriction occurs because it is impossible to calculate the text width exactly if the text is italicized.

Strings appear garbled when a non-UTF-8 file is opened

If not encoded in the UTF-8 format, a string will come out garbled. For example, Korean strings will appear garbled if you open a file in Nexacro Studio with the file encoded in EUC-KR.

In Nexacro Studio, files are created with UTF-8 encoding and without a Byte Order Mark (BOM). It will take too long if an editor checks the encoding format of a file that does not have a BOM. For the sake of performance, therefore, Nexacro Studio presumes that files are encoded in the UTF-8 format.

MouseMove event stops in WebBrowser when content from different domain is linked

The MouseMove event will stop in a WebBrowser component when you try to resize a window. This problem occurs when you set the url property of the WebBrowser with content from a domain different from the current one.

In the below picture, for example, you can resize the window by dragging the position 1, the edge of the pop-up, with the left button of a mouse. However, you cannot conduct resizing from the position 2, the border between the WebBrowser and its content, because the MouseMove event stops.

Restriction related to values of system.osversion

The osversion property of the System object does not return the exact name of an operating system. osversion extracts its value from the navigator.useragent property. At this point, a string as a return value encompasses two or more OSes, making it impossible to identify the exact name of the relevant OS.

The below table presents the values that can be returned by the osversion property of the System.

Value fails to be set even if its data type is appropriate after value of type property of ColumnInfo changes.

You will fail to set a value whose data type matches the value of the type property of the ColumnInfo object. This bug occurs after you change the value of type. When a Dataset is created, Nexacro Platform defines a conversion function and links it to the type property of the ColumnInfo object. The foregoing problem occurs since the conversion function does not change even when the value of type changes.

For example, the below sample code causes such a bug. The below script is programmed to change the value of the type property of a ColumnInfo object from “BIGDECIMAL” to “STRING”. If the script is properly executed, the value "234%" should be set. However, the internal conversion function is still designed to process a BigDecimal object and thus produces an empty value.

var colInfo = this.Dataset00.getColumnInfo(0);
colInfo.set_type("STRING");
this.Dataset00.setColumn(2, 0, "234%");

Because fixing this bug solely may affect other functionalities of the Dataset object, it will be fixed after a consultation process. Therefore, this bug will be treated as a restriction until fixed.

Style editor fails to apply status to preview of component

If you choose a selector while editing a theme or XCSS file in the style editor of Nexacro Studio, a preview will be provided on the Component Preview pane. Such a preview reflects the status of the selector. However, the editor may fail to apply accurate statuses to the previews of some components like a Calendar and Grid, components that contain sub-controls to which the access is determined internally by the framework.

This bug does not cause any problem to the operation of the tool. Moreover, it is necessary to restructure the framework to fix this bug. Therefore, it has been decided that this restriction will remain.

In the below picture, for example, the style editor does not provide a preview where a component is under the “disabled” status. However, you can see an accurate preview if you set the enable property to “false” while working on the component in the design pane of Nexacro Studio and then launch the preview of your application.

DB Files to Be Used in LiteDBConnection Not Being Deployed

When deploying the iOS operating system app, if the Update Type is set to "Server", then the DB file to be used in the LiteDBConnection object cannot be deployed directly. This is a restriction on the permission processing of the iOS operating system, and if you need to use the LiteDBConnection object, then you can directly create and use the DB file with the script as shown below.

/**
 * When executing the open method, set the LiteDBConnection.openReadWriteCreate option.
 */
this.Button00_onclick = function(obj:Button, e:nexacro.ClickEventInfo)
{
	this.LiteDBConnection00.open("%USERAPP%t.s3db", LiteDBConnection.openReadWriteCreate);
}

/**
 * Create the DB file, create the data table while connected, and proceed with the necessary tasks.
 */
var CREATE_QUERY = "CREATE TABLE Persons ()";
this.LiteDBConnection00_onsuccess = function(obj:nexacro.LiteDBConnection,e:nexacro.LiteDBEventInfo)
{
    switch(e.reason)
    {
        case 5: // LiteDBConnection open()
            this.LiteDBStatement00.set_ldbconnection(this.LiteDBConnection00);
            this.LiteDBStatement00.executeUpdate(CREATE_QUERY);
            break;  
	}
}

Font with Same Name Beginning Not Being Applied

This occurs when the beginning of the font name is the same and when it is used at the same time.

If the font name applied to the first component created in Windows NRE includes the font name applied to the component created later as shown below, then there is a restriction that the first created component font is reflected in the component created later.

Arial Black
Arial

For example, if the font of the first Static component is "Arial Black" and the font of the second Button component is "Arial", then it is displayed as shown below. In the web browser, "Arial Black" and "Arial" are separated and processed, but in Windows NRE, it is only processed as "Arial Black".

Cancelled Restrictions

setFocus method fails to move caret

In Microsoft Edge, a caret will not move while the focus moves when the setFocus method is called. This problem occurs to a component with an editable field when setFocus is called within the handler of the onkillfocus event of the same component.

Let us assume that there are two Edit components. With focus in the first component (Edit00), its onkillfocus will occur if you click the editable field of the second component (Edit01). Afterward, the focus will go back to the first Edit while the caret will stay in the second Edit.

this.Edit00_onkillfocus = function(obj:nexacro.Edit,e:nexacro.KillFocusEventInfo)
{
	if(obj.value == null) obj.setFocus();
};