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.

Background image of Menu fails to be loaded

The background image of a Menu component will not be displayed when the application is loaded in Firefox. This problem occurs when you specify an image file as the value of image, a subproperty of the itembackground property of the Menu, while setting the repeat property to "stretch".

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:Edit, e:nexacro.KillFocusEventInfo) {
	if(obj.value == null) obj.setFocus();
}

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 Nexacro Browser. Consequently, your application will not perform as well as it is designed.

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_VFrameSet0_ChildFrame0_form_Div00" 
    style="left: 141px; top: 504px; width: 400px; height: 115px; 
    background-color: rgb(0, 0, 255); ">
    <div 
		style="position: absolute; 
		left: 20px; top: 20px; width: 300px; height: 73px; 
        background-color:red; ">Button00
    </div>
</div>

Restrictions related to WKWebView in iOS

As iOS adopts WKWebView, two restrictions have emerged in relation to cross-origin resource sharing, as described below.

• Restriction on the use of a cookie

  No cookie is permitted with the content file (Run.html) running in a local path (file://).

  You cannot even access cookies through a script (document.cookie) or set cookies by using the WKWebView API (WKHTTPCookieStore).

• Local files cannot be accessed through the url property of the WebBrowser.

  Restriction is imposed on the components using iFrame with the content file (Run.html) running in a local path (file://).

  You also cannot access an HTML file by using the callMethod method of the WebBrowser.

If you have to use cookies in iOS or call the callMethod method of the WebBrowser in iOS, you should follow the below procedure to call the Run.html file from the server.

Otherwise, delete the settings related to "resource" in the start_ios.json file, which is created through the menu Archive of Nexacro Studio.

"resource" :
{
}

Decompress the Run.zip file, which created through Archive of Nexacro Studio. Open the Run.html file with a text editor and then delete the lines intended to call the archivefiles.js file. Then, delete the project URL defined as an argument of the load function to make it as an empty value.

<script type="text/javascript" src="./archivefiles.js"></script>
>>
Deleted

application.load("TEST", "TEST.xadl.js", "http://localhost:8080");
>>
application.load("TEST", "TEST.xadl.js", "");

Files produced as a result of generation, Run.html and start_ios.json should be in the same location of the same server.

Add the isDirect option (isDirect=YES) to the AppDelegate.m, one of the files set in the process of building the app.

@implementation AppDelegate -(NexacroMainViewController*)initMainViewController:(NSInteger)nView
{
    [[NexacroResourceManager sharedResourceManager]setBootstrapURL:
		@"http://172.10.10.10:8080/nexacro/start_ios.json"
		isDirect=YES];
	return
	[[AppViewController alloc] initWithLoader:nView];
}
@end

Two types of scrollbars appear simultaneously in TextArea

Nexacro Platform applies its own scrollbars instead of default scrollbars of HTML. To this end, the platform not only disables HTML default scrollbars but also hides them.

When iOS improved its scrolling functionality in the version 13, it changed some properties related to scrolling. With such change causing the appearance of HTML default scrollbars, which used to be made invisible, now the two types of scrollbars are displayed simultaneously.

There are bypasses that prevent the two types of scrollbars from appearing at the same time. Since such circumvention affects features and actions related to scrolling, however, we have decided to maintain the current state and declare this issue to be a restriction.

Long-pressing is treated as touching-and-moving

iOS does not allow developers to handle the events related to long-press gesture. Accordingly, Nexacro Platform does not tap into iOS' events. Instead, it measures by itself the amount of time when a user touches the screen to distinguish between a simple touch and long-press gesture.

In the versions earlier than iOS 13, long-pressing on a component with an editable field (Input DOM) led to a magnifying glass UI. In iOS 13, however, the same action causes a cursor to get bigger. In this process, Nexacro Platform has become unable to differentiate between a simple touch and long-press. This is because the minimum duration required to recognize a long-press gesture is too short in iOS 13.

Therefore, applications can behave against users' intentions in iOS 13 or later. For example, a step layout moves when the user actually intends to long-press because iOS treats it as a touch-and-move action.

Long-pressing on Form with scrollbar makes screen shake

Assume that, in iOS 13 or later, you open a virtual keyboard by selecting a component with an editable field in a Form with a scrollbar. At this point, you will find the screen shake and then the caret disappear if you long-press the editable field.

This behavior is decided to be a restriction because it also occurs in an HTML page in the same conditions.

Component's value cannot be fetched within onclick before Japanese characters are fully combined

In iOS 13 or later, the process of combining characters cannot be completed by using a script when the input is in progress. The time when the combination is completed varies according to the versions of iOS.

In the versions earlier than 13, you can fetch the value of a component through the handler of the onclick event because the character combination is completed before onclick. In iOS 13 or later, however, the handler will return "undefined" as the value.

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 aligning text in Grid cell

With the halign property set to "center", the alignment of the text in a Grid cell will be different between the Runtime browser and web browsers.

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 will occur in Internet Explorer and thus a pop-up will fail to appear when you call the open method of an application object 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 Runtime browser and other 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 processes 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 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 Runtime environment, the frame area including a titlebar serves as the base while the contents area excluding a title bar serves as the base in the HTML5 environment. 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 Runtime browser
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.style.set_font("10 Arial");
var textSize = nexacro.getTextSize(this.Static00.text, this.Static00.style.font, null, "none", 0);
trace(textSize.nx, textSize.ny); // Results

Geolocation is replaced by browsers' own objects

Some browsers employ their own objects instead of a Geolocation, an object from the DeviceAPI object of Nexacro Platform. This problem occurs when you specify the ID of the object as "Geolocation" in the TypeDefinition.

This problem occurs because IE and Microsoft Edge have their own objects named "Geolocation". Therefore, your application will work properly if you change the ID of the object to something different like "NexacroGeolocation".

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

Text in Grid is Hidden Partially in Zoomed-in Browser Page

Text in a Grid cell is hidden partially when the browser page zoomed in. This error occurs when the align property of the cell is set to "right".

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 a Nexacro Platform-based application. 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 event

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

Failure to display displaynulltext property's value with enable property set to false

With the displaynulltext property set, the component will display the property's value if the component is not focused and has 'null' as a value. However, the behavior of the component varies according to browsers; particularly, when the enable property of the component is set to 'false' through the script while the component has focus. In some browsers in that case, the component cannot display the value of displaynulltext although the focus will move to the next component.

The blur event is fired by browsers under the following two conditions: first, a component loses focus due to the change in the value of the enable property. Second, the change is caused by the script rather than by pressing the tab key or clicking outside the component. The value of displaynulltext can be displayed as Nexacro Platform processes blur. However, some browsers do not trigger blur, thus failing to display the value of displaynulltext.

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' pseudo-class will apply to the component.

This is a browser-specific restriction. Nexacro Platform changes the pseudo-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.

Only caret moves without focus if you drag and drop mouse pointer between components

There is a restriction where a caret moves from an editable component to another editable component while the focus does not. This problem occurs when you press the right button of your mouse in the beginning component, move the mouse pointer to the other component with the button still pressed and then release the button.

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>

Style defined for mouseover remains after mouse cursor moves out

This restriction is related to Safari running in macOS and to a style defining the background color of the mouseover pseudo-class. When you hover a mouse cursor over the relevant object, the defined background color will be applied. However, the color will remain even after the mouse pointer leaves the object.

Caret appears at the beginning of next line in TextArea when clicking empty space at the end of text on certain line

This restriction involves a TextArea containing multiple lines of text with line feed characters. If you click the empty space that trails behind a certain line of text, a caret may be placed at the beginning of the next line instead of the end of the text on the relevant line. This behavior is mostly found in IE8 and sometimes in IE9, IE10 and IE11.

If you click the space 1 in the above picture, a caret should appear at 2, which is the end of the text on the third line. In IE browsers, however, a caret will sometime appear at 3, which is the beginning of the fourth line.

Varying sequence between onkeydown, onkeyup and ontextchanged events

As seen in the below table, the sequence of events varies according to browsers when you enter Korean characters in an Edit. If the onkeyup event includes a script to check a Korean language input and the event occurs in Microsoft Edge, the script may not work properly.

Contents are reloaded when Z-order of WebBrowser changes

You can change the stack order of a WebBrowser by calling the bringToFront or sendToBack method. In this case, the contents loaded on to the component will be reloaded. When a WebBrowser operates in a web browser, the component will be converted into an iframe tag. The web contents defined by the url property will be reloaded if the order of the iframe tag changes or the iframe’s parent node changes. This behavior is a basic design of web browsers.

If a WebBrowser is placed within a Div, the web contents of the WebBrowser will be reloaded if the bringToFront or sendToBack method of the Div is called.

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

Restrictions Inherent in Nexacro Platform

Form's background color fails to apply when the Form is connected to Div

Styles defined in a CSS file will not apply to a form if the form is specified as the value of the url property of a Div component.

For example, place two Div components in a Form (a.xfdl) and specify b.xfdl and c.xfdl as the values of each Div. As you apply the same background color to both Div components, specify the test.css file as the style of b.xfdl while specifying the background property of c.xfdl. As the result, only c.xfdl presents the background color while b.xfdl does not.

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.

Difference in mask property between MaskEdit and Grid

The mask property can apply to both a MaskEdit component and a Grid cell object. While most features are the same, some are different between the two objects.

Restriction on event bubbling from editable components

Events that occur in editable components does not bubble to the HTML documents unlike other types of components.

Events that occur in editable components are not delivered outward from a WebBrowser component if a Nexacro Platform-based application is the value of the url property of the WebBrowser. This is also true when the application comes within IFrame tags in an HTML document.

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 align property of TextArea

As for the align property of a TextArea component, Nexacro Platform only supports the "top" value for the vertical alignment. It supports only the "left" value for the horizontal alignment when a horizontal scrollbar is activated. The below property settings are the conditions for activating a horizontal scrollbar, which is also affected by the length of input text.

wordwrap: none
scrollbars: autoboth, alwayshorz, fixedboth, fixedhorz, autohorz

Styles for Grid's control button are not defined in default.xtheme

Styles for a Grid's control button are not defined in default.xtheme file, which is provided from the installation of Nexacro Studio.

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 Runtime environment, 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:Button,  e:nexacro.ClickEventInfo) {
	alert("TEST"); // javascript alert method
	this.alert("TEST"); // Form object alert method
	application.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, your application 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 Runtime environment, however, the delivered value has limits in the length of characters.

The Runtime version can process up to 512 characters maximum (256 characters in Korean and Japanese).

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"

WebBrowser is display on top in Android

You cannot place another component above a WebBrowser component in the Android Runtime environment. Even a pop-up component will be placed under a WebBrowser if the two component overlap.

Alert messages appear when application run on web browser

You will see the below alert messages if you run an application on Internet Explorer, open the developer tools and select the Console tab.

The above messages are caused by the faults in the conditional comments in the HTML files that are created as the result of generation. Since those are just alert messages, they will not pose any problem with the execution of an application. The reason for not fixing this syntax error is that such an attempt to change the conditional comments may have an impact on applications in operation.

(X) <!--[if gt IE 8]><!DOCTYPE html><!--<![endif]-->  
(O) <!--[if gt IE 8]><!--><!DOCTYPE html><!--<![endif]-->

Text can be selected by mouse actions even when the cell is not editable

The text in the Grid cells in the head and summary bands should not be selected with double-clicking or dragging because those cells do not have a control and thus cannot switch to the editable mode. The same will apply to the body band if the edittype property of the band is set to "none" and thus the relevant cells cannot switch to the editable mode.

When the editdisplay properties of cells are set to "display", moreover, the text should be unselectable regardless of edittype and bands since the relevant controls are not editable.

Even if a cell is not editable, however, text in the cell can be selected by mouse actions when the cell has the below-mentioned property values. Meanwhile, some users hope to keep this malfunctioning state since they are using it as it is. Therefore, it has been decided to maintain this bug.

- Head Band Cell
editdisplay=display
- Body Band Cell
editdisplay=display

Nexacro Studio makes it seem that cell’s style can be set through CSS file although such functionality is not developed yet

You cannot style a Grid cell by using a CSS file since such a functionality is not developed yet. Even if you write a CSS file as shown below, the style set in the CSS file will not be applied.

Cell
{
	padding : 3 3 3 3;
}

If you check the Grid Contents Editor after setting the above CSS code, however, the editor makes it seem that the cell style set in the CSS file has been applied. However, the foregoing style does not take any effect actually.

This anomaly—a functionality seems to apply to Nexacro Studio even if it is not developed yet—is a bug. However, it has been decided to maintain this bug since fixing the bug may affect other functionalities.

Restrictions on Right-to-Left (RTL) Feature

Caret's position in editable field when RTL is set

A caret is placed at the beginning of input text in an editable field when the text is English letters or numbers. This problem occurs in Google Chrome when the RTL feature is set.

Return value of getCaretPos method when RTL is set

In Google Chrome, the return value of the getCaretPos method differs from those produced in other browsers when the RTL feature is set. This problem occurs when a string is entered in an editable field in order from Arabic letters, English letters to numbers. Moreover, the caret is placed somewhere in the middle of the string.

With the RTL feature set, the return value of the getCaretPos can vary according to browsers and their versions.

Restriction on application of RTL to WebBrowser

The contents in a WebBrowser component is not affected by the RTL feature.

Direction of scrollbar and caret's movement when RTL is set

The positions of a scrollbar and caret vary according to browsers when the Home or End button on the keyboard is pressed in an editable field. This problem occurs when the RTL feature is set.

Image is broken when RTL is set

Some images formatted in PNG will be broken in IE8 with the rtldirection property set to "rtl". This problem occurs in the process of changing the directions of the images.

We advise you to use IE9 or later, or to use other image formats like JPG, BMP and GIF.

Cancelled Restrictions

Restriction on synchronous communications

iOS Runtime environment supports only asynchronous communications rather than synchronous one.

Caret fails to show properly in iOS when editing text in web page loaded onto WebBrowser

A caret may not be displayed at an exact point where you touch the screen if the web page loaded onto a WebBrowser component uses the contenteditable attribute. This error occurs when you touch an editable text area.

This restriction occurs only in the iOS Runtime environment, which uses UIWebView. That is, this restriction occurs only when UIWebView is used.