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".

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.

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 is programmed to display the default keyboard in such a case.

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-based app fails due in Windows.

Upon the execution of the installation file of a Nexacro-based app running in Windows (nexacroN_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 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 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.

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.

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.

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.

Restrictions on controlling the pinch-zoom gestures for content loaded from the WebBrowser component

In iOS/iPadOS WRE and NRE, HTML meta tag properties and scripts are used to control the pinch-zoom gestures. Unlike the other components, the WebBrowser component’s property information of the contents loaded in the IFRAME tag area cannot be known in the Nexacro app, and the pinch-zoom gestures cannot be controlled.

Even if the pinch-zoom is disabled in the Nexacro app, if the content loaded in the WebBrowser component allows the pinch-zoom, the pinch-zoom operating within the WebBrowser component area may affect the entire app.

Restrictions on using Japanese IME in certain environments

This is an issue in which a value different from the value the user wants to input is entered in the components (Calendar, Grid component, etc.) including the Edit, TextArea component, MaskEdit component, and MaskEditControl where the properties that limit the input (maxlength, inputtype, etc.) are set.

Depending on the execution environment, the following input errors may occur when using Japanese IME.

• When a key is entered, the characters are typed multiple times

• Previously entered characters are deleted

• A different value is typed when a number key is presed

An issue in which the text alignment status of the calendaredit area of the calendar component varies depending on the device.

If the popuptype property value of the Calendar component is set to "system", the text alignment status of the calendaredit area varies depending on the execution environment.

If the popuptype attribute value is set to "system", the generated code is used by reflecting the type attribute value of the HTML input element as "date" depending on the execution environment, and the behavior of that attribute varies depending on the execution environment.

Single quotation marks are not reflected when entered on iOS devices

Provided the option to display the text entered using single quotes when setting the type attribute value if the type attribute value of the MaskEdit component is “string”. For example, if the property value is set as shown below, the characters enclosed in single quotation marks are left intact and displayed in the form of "_A_" in the MaskEdit component.

this.MaskEdit00.format = "@'A'@";

If the Smart Function function is enabled on iOS devices and the format attribute value is set to the value entered by the user on the screen, the user enters the single quotation mark (U+0027) by converting it to the left quotation mark (U+2018) and the right quotation mark (U+2019) as shown below. And it is recognized as a character other than a single quotation mark, so the MaskEdit component is displayed in the form of "_'_'_'.

this.MaskEdit00.format = "@‘A’@";

Since it is not possible to check whether the Smart Punctuation function is activated on iOS devices, be aware when using the function that receives input of single quotation marks from the user. The same applies to all features that compare and process text entered by users, as well as MaskEdit components.

Inability to use Grid component tree expansion/collapse shortcut keys when using SenseReader

If the treeuseexpandkey attribute value of the Grid component is true, regardless of whether accessibility is set, you can use the left and right keys to expand or shrink the tree area cells.

However, when using SenseReader, the left and right arrow keys are given priority as SenseReader shortcut keys, and the tree area cells cannot be controlled with the left and right arrow keys.

Change the virtual cursor to browser mode to use the left and right arrow keys.

If the treeuseexpandkey property value of the Grid component is true and you are using a sense reader, when you move to the Grid component by pressing the Tab key, the virtual cursor changes to browser mode and runs. In this mode, the tree area cells of the Grid component can be controlled using the left and right arrow keys. The feature can be enabled by prompting the user to press the Tab key before accessing the Grid component.

Values deleted when attempting to input Korean characters into the Calendar component input window

If the autoselect property value of the Calendar component is set to true, the existing value will be deleted when Korean characters are entered into the calendaredit area in Windows 11 Korean input mode.

For example, when the focus moves to the Calendar component and the text in the calendaredit area is selected, entering "ㄱ" will delete the existing value.

This issue occurs when an event (deleteContentBackward) is sent with an incorrect value when entering Korean characters while the text in the editing area is selected in Windows 11 Korean IME. This is the error of Korean IME, the product cannot receive appropriate information when entering Korean, and this error cannot be corrected.

Inability to enter values in other components while the system pop-up calendar is displayed in the Calendar component

If the popuptype property value of the Calendar component is set to “system,” depending on the operating system, you may not be able to enter values into other input components while the system popup calendar is displayed.

In some operating systems, abnormal termination occurs when the focus is moved to another input node while the system pop-up calendar is displayed. To prevent abnormal termination, actions are restricted on some operating systems.

Difference between Browsers

Restriction on style-related properties

The below table is a list of style-related properties that are not supported by Nexacro 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 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");
}

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

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.

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

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 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 cannot correct this problem since Safari successfully delivers the event to Nexacro although it fails to move the focus.

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”.

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 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.

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.

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.

Differences in the IME action when the focus is on the MaskEdit component text editing area

The MaskEdit component can only input limited ASCII characters according to the type and format property settings.

For user convenience, some browsers that can control the use of the IME disables the IME (English character input mode) when the focus is placed on the text editing area of the MaskEdit component. With the IME disabled, only the input of ASCII characters are allowed. When the IME is enabled (Korean, Japanese, Chinese input mode) in Chrome and Edge browsers where the IME use cannot be controlled, text input is not allowed or only some characters are allowed.

If the IME is disabled when using the Korean or Japanese IME, the input mode display icon is displayed with the 'X' as follows. Depending on the execution environment, the 'X' mark may not be displayed. The Chinese IME does not change the input mode display icon.

When NRE is running, the Korean, Japanese, and Chinese IME input mode display icons are forcibly changed to English character input mode and cannot be changed.

Restrictions on using SVG files

SVG files can be used in any property or method that allows you to specify an image file. Nexacro Studio can also use SVG files as image resource files.

Restrictions on using NRE SVG files

Restrictions on using WRE SVG files

Basically, WRE follows each browser's scope of supportation and limitations.

However, there are restrictions on using SVG files as image-related property values of components in the following cases.

• When the component's fittocontents property value is set to a value other than 'none'

• When a property that automatically adjusts the width or height of a component is set

Restrictions on using Nexacro Studio SVG files

• [Theme > image editor] and [ImageResource] in Resource Explorer do not provide image preview. When selecting an SVG file, it will be displayed as alternative text and images.

• When an SVG file is selected as a property value in the Properties window, if there are no viewBox, width, or height properties within the SVG element, a warning message is displayed in the Output window indicating that it is not supported.

Unsupported properties and methods

SVG files cannot be used if the property or method description states that only certain file extensions can be used.

An issue in which the window is closed when the focus is moved to the address bar of the pop-up window opened by executing the open method and the F5 key or the Enter key is pressed.

In a pop-up window opened by executing the open method, if the user moves the focus to the address bar and attempts to refresh it by pressing F5 or pressing Enter, the window is closed.

When the user performs this action, the event information transmitted from the browser does not include the accurate information, and it can’t be determined whether the user intends to close the window or refresh the window. Therefore, this action is processed by closing the pop-up window.

Restrictions Inherent in Nexacro

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 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.

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 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 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 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 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".

Scroll action is restricted when the contenteditable property value in the HTML body tag is true.

If the contenteditable property is included in the body tag of the HTML content loaded by the WebBrowser component and the propety value is true, scrolling is disabled with the keypad displayed.

<html>
<head>
	<meta http-equiv="content-type" content="text/html; charset=UTF-8">
</head>
<body contenteditable="true">

This is no issue when the same content is executed in a web browser, and the scrolling action is restricted only when executed in the Android operating system NRE.

This is a limitation caused by a structural issue of Nexacro NRE.

Restrictions on emoji character output in Nexacro Studio

Some characters are garbled when using emoji characters in the editing window, properties window, and output window in Nexacro Studio. This issue is a restriction of the Windows OS program, and the same issue can be found in Notepad, a basic app of Windows.

Windows Notepad

Nexacro Studio > Property Window, Edit Window

It is displayed normally when the app is running. The format displayed on the screen may vary depending on the operating system, browser, and running device, and some characters may not be displayed.

WRE

Restriction on emoji character when running NRE

When running NRE, emoji characters and other characters are overlapped and displayed in the following cases.

Windows NRE

• Among the family emoji characters, emoji characters with child images (girl, boy, baby) placed on the outside are displayed overlapping if entered together with other characters.

macOS NRE

• All emoji characters are overlapped if entered with other characters.

An issue in which when you double-tap the status bar area, it does not scroll to the top at once.

The iOS OS supports a feature that scrolls to the top at once by double-tapping the status bar area. However, when running Nexacro Platform WRE in the Safari browser, this feature is not supported for the following reasons.

• When a tap event occurs in the status bar area, its information cannot be checked in HTML environments and not the native apps.

• Nexacro Platform uses the self-implemented scroll feature in Form or container components for stable operation.

Restrictions that change behavior when the alert and confirm methods are executed within the event handler functions

Depending on the value of the selectchangetype property of the Grid component, the order of events occurred when the mouse is clicked varies. If the selectchangetype property value is 'down', with the mouse click, events occur in the following order, starting with the Grid component's onlbuttondown event.

(1) Grid.onlbuttondown

(2) Dataset.canrowposchange

(3) Dataset.onrowposchanged

(4) Grid.oncellposchanged

(5) Grid.onselectchanged

(6) Grid.onlbuttonup

(7) Grid.oncellclick

When the alert and confirm methods in the first (onlbuttondown) to fifth (onselectchanged) event handler functions in the event list above are executed, there may be additional actions such as the user clicking the open window or pressing the Enter key to close the window, and this affects the order of the events.

If you need to execute the alert and confirm methods, change the order of event occurrence by setting the selectchangetype property value to 'up'. Changing the selectchangetype property value may affect other operations, so review it carefully before reflecting.

An issue in which the value is different depending on the data sorting method when the getSum method of the Dataset object is executed.

When the keystring method is executed on the Dataset object to sort the data and the getSum method is executed, the data may be different from before arranging. This occurs when the column type is "STRING" and the data contains decimal values.

This happens because the floating-point operations in JavaScript may not guarantee exact results. Because numbers are expressed in binary floating-point format according to the IEEE 754 standard, sum values may be processed differently depending on how they are arranged (order of operations). Even if the same number is calculated, the resulting value is different depending on the order of operation, as in the following example.

var a = nexacro.toNumber("0.1");
var b = nexacro.toNumber("0.2");
var c = nexacro.toNumber("0.3");

trace(a + b + c); // 0.6000000000000001
trace(c + b + a); // 0.6

To compensate for this, set the column Type to "BIGDECIMAL" instead of "STRING" or use the toFixed method to limit the number of decimal places.

var a = nexacro.toNumber("0.1");
var b = nexacro.toNumber("0.2");
var c = nexacro.toNumber("0.3");

trace((a + b + c).toFixed(1)); // 0.6
trace((c + b + a).toFixed(1)); // 0.6

An issue in which a value that does not match the type is set in Const Column value.

Column values of Dataset objects are checked for validity according to type. If the Column type is "INT", setting a string value will process it as an invalid value.

trace(this.Dataset01.setColumn(0, 0, "TEST")); // false

However, Const Column is not checked for validity based on type. If Const Column type is "INT" and a string value is set, the value is set without validation.

trace(this.Dataset01.setConstColumn(0, "TEST")); // true

The same applies if it is set directly in the Nexacro Studio Dataset editor. When a string value is entered into Const Column and Column whose type is "INT" and run the application, Const Column processes the string value as is, but since it is an invalid value in Column, the value entered in Nexacro Studio is invalidated.