Cybele Software, Inc. is proud to announced the release of a new beta build of Thinfinity® VirtualUI™, which includes additional enhancements and bug fixes.

The most important enhancements and bug fixes since Beta 5 are:

* Added detection of ‘cachable’ images.

* Added ability to configure a custom page per application.

* Added browse button to find certificate files.

* Added hints and warnings when compiling VirtualUI_SDK.pas

* Added support for Delphi XE7.

* Added new parameters to DownloadFile

* Fixed cursor on editable field not showing in .NET

* Fixed caret displayed when not editing in development mode.

* Fixed progress bar not showing.

* Fixed ‘404 not found’ message when printing.

* Fixed ‘session ended’ message showing when running a new build.

* Fixed child window positioning when maximized.

* Fixed Access Violation with OpenFile dialog.

* Fixed ‘Connection attempt failed’ error when not setting Virtual Path.

* Fixed artefacts remaining after showing/hiding a TdxDockPanel.

* Fixed prompt for re-submit data message when clicking refresh on the application page.

* Fixed close button drawing error.

* Fixed closing docked-window hang with DevExpress.

* Fixed VirtualUI.OnBrowserResize event not firing when the form is displayed.

* Fixed incorrect color in-between docking windows in TdxDockSite in DevExpress.

* Fixed cursor disappearing when opening HTML pop-ups.

* Fixed icons showing on applications window that shouldn’t.

* Fixed SystemMenu not showing in server mode.

* Fixed right-click on caption bar hangs the application.

* Fixed backspace not working on Android.

* Fixed double click not working on the icon of the application in the caption.

* Enhanced dragging with maximized windows.

* Fixed “List Index out of Bound(0)” error.

* Fixed minimize-restore-close buttons disappearing when maximizing the window in mobile.

* Fixed persistent cache not working in Firefox.

* Fixed remote caption not being updated properly.

* Fixed drawing error with window borders.

* Fixed Upload dialog firing multiple upload of the same file.

* Fixed double cursors in server mode.

* Fixed character input error in Delphi7.

* Fixed non configurable clipboard format.

* Fixed edit caret appearing on the screen randomly.

This Thinfinity® VirtualUI™ Beta version is valid until November 30, 2014.

Note: make sure to uninstall the previous build before installing the new one.

Please report bugs, suggestions and any general feedback to support@cybelesoft.com. We appreciate your feedback and bug report!

Setup files for Windows 8/2012 64-bit:
Thinfinity_VirtualUI_Setup_x64.exe
Thinfinity_VirtualUI_Setup_x64.msi

Setup files for Windows 8/2012 32-bit:
Thinfinity_VirtualUI_Setup_x86.exe
Thinfinity_VirtualUI_Setup_x86.msi

Documentation:
Product Page: https://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui

Contact:
For more information about Thinfinity™ Virtual UI, contact Cybele Software, Inc.
3422 Old Capitol Trail, Suite 1125
Wilmington, DE – 19808, USA.
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: info@cybelesoft.com
Website: www.cybelesoft.com

The post Thinfinity VirtualUI beta 6 released appeared first on Cybele Software.

Cybele Software, Inc. announces the release of Thinfinity® VirtualUI™, which now becomes a natural upgrade for WebFMX v1.0.

Thinfinity® VirtualUI™, will open many doors for any FireMonkey developers that previously adopted WebFMX. Programmers can still create dual-platform Windows/HTML5 applications by adding only one line of code to their existing FireMonkey projects.

With Thinfinity® VirtualUI™, desktop-based applications can be run as usual on a Windows environment, or be installed on a Thinfinity® VirtualUI™ Server environment and accessed remotely from any HTML5-compliant Web browser.

Plus, Thinfinity® VirtualUI™ makes full web integration of desktop applications possible, giving endless possibilities of enhancement!

Read more about Thinfinity® VirtualUI™ by clicking here.

Having an old WebFMX license? Contact us to know more about your upgrade options.

The post WebFMX now becomes Thinfinity VirtualUI appeared first on Cybele Software.

Cybele Software, Inc.announces the release of its latest beta build of Thinfinity® VirtualUI™.

In this beta we introduce the new Javascript Remote Objects (jsRO), an amazing technology we devised here at Cybele Software to complement the user interface remoting capabilities provided by VirtualUI with an amazingly easy and powerful integration framework.

jsRO allows you to define server-side objects mirrored on the client-side as native javascript objects. It provides a two-way data binding, remote method calls and custom remote events.

Additionally, Thinfinity VirtualUI now comes with the new VirtualUI Development Lab, a web environment that lets you see and interact with the jsRO objects created in your application.

This Thinfinity® VirtualUI™ Beta version is valid until March 31, 2015.

Make sure to uninstall the previous build before installing the new one.

Please report suggestions and any general feedback to support@cybelesoft.com. We appreciate your feedback!

Thinfinity_VirtualUI_Setup_x64.exe
Thinfinity_VirtualUI_Setup_x64.msi

Setup files for Windows 8/2012 32-bit:
Thinfinity_VirtualUI_Setup_x86.exe
Thinfinity_VirtualUI_Setup_x86.msi

Documentation:
Product Page: https://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui

Contact:
For more information about Thinfinity™ Virtual UI, contact Cybele Software, Inc.
3422 Old Capitol Trail, Suite 1125
Wilmington, DE – 19808, USA.
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: info@cybelesoft.com
Website: www.cybelesoft.com

The post Thinfinity VirtualUI beta 7 appeared first on Cybele Software.

We prepared a tutorial to help you use Thinfinity® VirtualUI™ in your Delphi application.  It consists of a PDF document and 5 Delphi projects based on a Fishfacts demo.

In this tutorial we show you how you can take your application to the web, from the instant UI Remoting to a full windows-to-web integration using the new jsRO framework (Javascript Remote Objects).

Download the tutorial in PDF format from here, and the demo files from here.

Enjoy!
Gustavo Ricardi
CEO/CTO

The post Integrate your Delphi application with the Web – Tutorial appeared first on Cybele Software.

Cybele Software, Inc. is proud to announced the release of a new beta build of Thinfinity® VirtualUI™, which includes additional enhancements and bug fixes.

The most important bug fixes since Beta 7 are:

* Fixed screen cut off at the bottom in iPad

* Fixed error when configuring a Default Application

* Fixed drawing error in Firefox 27 and 30

* Fixed drawing errors with Delphi7 apps

* Fixed left border missing in Modal Form

* Fixed black background error in DevExpress SampleDocking.exe

* Fixed caption buttons not displayed in DevExpress’s RibbonNotepadDemo

* Fixed icon disappearing when deactivating Ribbon in DevExpress’s RiggonNotepadDemo

* Fixed drawing lower edge drawing error in DevExpress’s RibbonNotepadDemo

* Fixed caret not hiding in DevExpress’s RibbonNotepadDemo

* Fixed error when navigating between profile pages in the index.html

* Fixed delay showing the cursor in a.NET app in development mode when refreshing the browser

* Fixed error applying resolution configured in the profile in development mode

* Fixed profile icons overlapping with other elements

* Fixed zoom in touch devices which are not mobiles

* Fixed application not starting in a new tab in Windows Surface tablet

* Fixed double cursor displayed

* Fixed Alt Keydown in MAC not sent

* Fixed transparency error in form in Woll2Woll app

* Fixed tab not drawn in DevExpress’s MDIDemo

* Fixed Server hang, not establishing new connections

* Fixed caret not cleared when tab is closed in DevExpress’s MDIDemo

* Fixed zIndex error in MoneyManager demo

* Fixed server generating multiple logs

* Fixed applications not starting in Android native browser

This Thinfinity® VirtualUI™ Beta version is valid until March 31, 2015.

Note: make sure to uninstall the previous build before installing the new one.

Please report bugs, suggestions and any general feedback to support@cybelesoft.com. We appreciate your feedback and bug report!

Setup files for Windows 8/2012 64-bit:
Thinfinity_VirtualUI_Setup_x64.exe
Thinfinity_VirtualUI_Setup_x64.msi

Setup files for Windows 8/2012 32-bit:
Thinfinity_VirtualUI_Setup_x86.exe
Thinfinity_VirtualUI_Setup_x86.msi

Documentation:
Product Page: https://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui
Demo tutorial: http://cybelesoft.com/blog/integrate-your-delphi-application-with-the-web-tutorial/

Contact:
For more information about Thinfinity® VirtualUI™, contact Cybele Software, Inc.
3422 Old Capitol Trail, Suite 1125
Wilmington, DE – 19808, USA.
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: info@cybelesoft.com
Website: www.cybelesoft.com

The post Thinfinity® VirtualUI^™ Beta 8 released appeared first on Cybele Software.

The new Thinfinity® VirtualUI™ platform helps developers to effortlessly take to the web Windows applications developed with .Net, Delphi, Visual C++ and the like.

For Immediate Release

WILMINGTON, DE, December 16, 2014—Cybele Software, Inc. announced today the release of Thinfinity VirtualUI, a one-of-a-kind development solution offering both instant GUI remoting and full web integration for Windows apps.

Thinfinity VirtualUI  is aimed at developers who are looking for reusing their existing code base and convert their applications to muti-user, multi-instance web apps.

When it comes to GUI Virtualization, Thinfinity® VirtualUI™ offers developers an effortless solution to take their applications to the web, converting them in dual-platform Windows/HTML5 apps. These applications retain their standard Windows environment behavior and, additionally, can be hosted on a Thinfinity VirtualUI environment to be remotely accessed from any modern web browser in a multi-user, multi-instance manner.

Drawing on the expertise and innovation from Cybele’s Development team, Thinfinity® VirtualUI™ also makes full web integration of desktop applications possible.  It facilitates two-way integration between the Windows-based applications and web resources by blending them with the web-side environment. Thinfinity® VirtualUI™ allows Win32/64 apps to be reshaped into a completely tailor-made ones, combining them with available web and multimedia resources.

“Innovation is at the core of everything we do, and one way that we uphold this commitment is by constantly evolving and designing new solutions to developers’ changing needs,” said Gustavo Ricardi, Cybele Software, Inc. CEO.

 Instantly web-enables Windows desktop applications: works with popular Windows development environments and programming languages

 Real integration capabilities: Windows applications can now be integrated with other web resources or applications, providing not only GUI remoting but also functional and data integration

 New object remoting framework: the new jsRO (Javascript Remote Objects) framework facilitates the creation of remotable server objects, with their properties, methods and events mirrored to the web as native javascript objects

 Development Lab: web environment that lets developers see, test and interact with the jsRO objects created in their application.

 Dual-platform – Windows/Web: applications can keep their standard desktop environment behavior, or be accessed remotely from any HTML5-compliant Web browser, in a multi-user, multi-instance fashion

 Cross-browser and Cross-OS: works with any HTML5-compliant Web browser, automatically using HTTPS protocol on Android native browsers, Microsoft IE9, and others that still lack support for the WebSocket standard protocol

 Zero client setup: no plugin, add-on, or other kind of installation on the client side is required

 Secure, high-performance web-based Remote Access to applications hosted on a LAN, through a single published IP address, via http(s) and WebSocket protocols

* Development machine

- Operating Systems: Microsoft Windows 7 (32­bit/64­bit), Microsoft Windows 8 (32­bit/64­bit), or Microsoft Windows Server 2012 (32­bit/64­bit)

- A development environment: Microsoft Visual Studio, Delphi 5 to XE7, Microsoft Visual Basic, PowerBuilder, and others.

- The application can use .NET WPF, GDI, GDI+ and limited DirectX calls.

* Server machine

- Microsoft Windows 8 32­bit / 64­bit.

- Microsoft Windows Server 2012 32­bit / 64­bit.

* End-user machine

- Any operating system and/or device with a HTML5-compliant Web Browser.

- Any modern Web Browser (HTML5-­compliant) such as IE10/11, Chrome, Safari, Firefox, Opera, etc.

Documentation:

Product Page: https://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui
Demo tutorial: http://cybelesoft.com/blog/integrate-your-delphi-application-with-the-web-tutorial/

Contact:
For more information about Thinfinity® VirtualUI™, contact Cybele Software, Inc.
3422 Old Capitol Trail, Suite 1125
Wilmington, DE – 19808, USA.
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: info@cybelesoft.com
Website: www.cybelesoft.com

The post [Press Release] Windows apps reach a new level with GUI Virtualization and Web Integration: Meet Thinfinity VirtualUI appeared first on Cybele Software.

We’d like to invite you to check out our latest video “Getting Started with Thinfinity VirtualUI (.Net)” that can be found in our Thinfinity Google+ page.

How to add the VirtualUI library to a .Net application

In this new installment of our video tutorials we show how to add the Thinfinity® VirtualUI™ library to a .Net application and to publish it to be accessed from the Web.

Don’t forget! Check this blog and visit our Google+ page often to find tips, news and videos that will help you get the most out of Thinfinity VirtualUI!

More online content is yet to come!

Please feel free to send us comments or feedback and connect with us on your social network.

The post Thinfinity® VirtualUI^™ Video: Getting Started with Thinfinity VirtualUI (.Net) appeared first on Cybele Software.

We start with this lines a new series of small articles to offer some simple but useful tips to help provide a better end user experience with Thinfinity® VirtualUI™ extended applications.

When the application was originally designed, the underlying assumption was that it would be used in desktop devices. As a result, we did not spend too much time thinking about the characteristics of the device from where our application would be run.

But when using VirtualUI, it is often necessary to be aware of some features and capabilities of the device from which end users are accessing our application.

The VirtualUI class has a property called BrowserInfo, which contains data about the used browser to assist us in delivering the best possible user experience.

In the list below we will find a detail of the information that BrowserInfo will deliver us:

 
General information related to the current connected browser:

An important value to consider is the UserAgent property. When establishing a connection, the browser sends VirtualUI a string data indicating its brand and version, which OS it is running on, and the brand and model of the device that is being used. This value is known as the userAgent. Using this value we can infer, for example, if the user connects from a mobile device and then modify some specific feature, layout or functionality of our application to better suit that device.
 

Information related to the available screen space:

 
It is also worth mentioning that when using VirtualUI, the desktop size is dynamic. This means that the available space to display the application is correlated to the available space in the browser screen and it is not limited to a fixed desktop size —as it would  happen, for example, in an RDP connection, where the desktop size is defined when the connection is established.

The following example in C# shows how to center a window of our application on this virtual desktop as needed, previously controlling their size if it exceeds the available space:
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

using Cybele.Thinfinity;...
...
...
 
private VirtualUI vui; 
public Form1()
{
    InitializeComponent();
    vui = new VirtualUI();}
 
private void CenterThisWindow(object sender, EventArgs e)
{
    this.WindowState = FormWindowState.Normal;
 
    if (vui.BrowserInfo.ViewHeight < (this.Height + 20))    {
        this.Height = vui.BrowserInfo.ViewHeight - 20;
    }
    if (vui.BrowserInfo.ViewWidth < (this.Width + 20))
    {
        this.Width = vui.BrowserInfo.ViewWidth - 20;
    }
 
    this.Top = (vui.BrowserInfo.ViewHeight - this.Height) / 2;
    this.Left = (vui.BrowserInfo.ViewWidth - this.Width) / 2;
 
}

 
As we mentioned above, this new series of small technical notes will be aimed at providing simple tips to help you take advantage of the features added to your applications through the adoption of Thinfinity VirtualUI.

We invite you to share with us your concerns and/or experiences.

The post Recovering browser information using ‘BrowserInfo’ appeared first on Cybele Software.

In our last post we started with a new notes and tips series aimed at helping developers take full advantage of Thinfinity® VirtualUI™’s existing possibilities.

In the present note, we will focus on ClientSettings.

ClientSettings is an additional interface available at the Thinfinity VirtualUI Library that allows developers to remotely and programmatically configure particular browser settings. These settings are related to the cursor visibility and some specific touch action behaviors.

We can find, in the table below, a detailed explanation of the ClientSettings interface’s current properties:

These properties, as previously mentioned, were created to provide a better end-user experience when using touch devices.

When using a touch device, it is unusual for a mouse pointer to be displayed. Instead, finger gestures are interpreted by the device as different commands, acting on the element or elements that are located where the gesture is made.

But this is not always the best way, especially when our applications were not designed for these gestures. Oftentimes, the best solution to this issue is to show the pointer and simulate the mouse actions from the gestures captured.

The properties that we have presented above will help us define the ideal settings to enjoy the best possible and intuitive user experience for our application.

The following example shows how to recognize a touch or mobile device, and if detected, to change the pointer behavior. (Be careful! The detection list is incomplete):

1
2
3
4
5
6
7
8
9
10
11
12

 vui = new VirtualUI();
 userAgent = vui.BrowserInfo.UserAgent.ToLower();
 
 if ((userAgent.IndexOf("touch") != -1) || (userAgent.IndexOf("mobile") != -1) ||
     (userAgent.IndexOf("iphone") != -1) || (userAgent.IndexOf("ipod") != -1) ||
     (userAgent.IndexOf("ipad") != -1) || (userAgent.IndexOf("android") != -1) ||
     (userAgent.IndexOf(" cros ") != -1)) {
 
         vui.ClientSettings.MouseMoveGestureStyle = MouseMoveGestureStyle.MM_STYLE_ABSOLUTE;         vui.ClientSettings.MouseMoveGestureAction = MouseMoveGestureAction.MM_ACTION_WHEEL; 
 }

This would be the end of this week’s small technical note aimed at providing a simple tip to help you take advantage of the features added to your applications through the adoption of Thinfinity VirtualUI.

We invite you again to share with us your concerns and/or experiences.

The post Change browser behavior using ‘ClientSettings’ appeared first on Cybele Software.

Since its beta release back in May, 2014 we’ve been working nonstop to consolidate and enhance Thinfinity® VirtualUI™, our Instant GUI Remoting and Web Integration solution for Windows applications.

Created to help developers who are confronted with a need for deep modernization of existing Windows-based apps, Thinfinity VirtualUI has always integrated with almost all programming languages through ActiveX/COM and .NET interfaces. We also provided dedicated libraries with source code for popular languages like C#, VB.NET, Visual Basic 6 and Delphi. By adding a new C++ interface library we continue pursuing our goal of trying to make Thinfinity VirtualUI available to an ever increasing number of languages.

We are also continuously working on improving support for DirectX technologies. We currently have full support for Windows Presentation Foundation (WPF) and Delphi FireMonkey GUI frameworks, extending VirtualUI’s readiness to an always growing range of applications.

Fully convinced that you will greatly benefit from what Thinfinity VirtualUI brings to the table, we would like to invite you to take a look at our online live demos, or to visit the product landing page for more information. You will love it!

If you are interested in learning more about Thinfinity VirtualUI just send us an email to support@cybelesoft.com. We’ll be happy to help you!

The post Enhanced support for DirectX-based GUI frameworks (WPF, FireMonkey, etc) and new C++ native library appeared first on Cybele Software.

In the previous post we discussed the Thinfinity Remote Desktop Web service modules. In this article, we will show you how to set up the ThinRDPWS-Query web service demo for .Net.

The ThinRDPWS-Query demo

The ThinRDPWS-Query demo was developed in C# to present the many integration possibilities the Analytics Web Service provides you. This application shows Thinfinity Remote Desktop activity information concerning logins, sessions, connections and browsers used to access remote computers in several time intervals.

Checking the Web service status and port

Before running the application, please check the Services system dialog to see if the Thinfinity Remote Desktop WebService Admin Tool service is started.

Open the Thinfinity Remote Desktop WebService Admin Tool and verify the port the web service is listening on. In this case, the port is 8499. Also, you can see the service status message at the General tab bottom line.

Setting up the application

Look for the ThinRDPWS-Query solution in the Thinfinity Remote Desktop WebService Demos in the Windows Start menu.

Select the QuerySvc item from the Service References folder at the Solution Explorer and then select the Configure Service Reference… option from the contextual menu.

Please check the client address in the Service Reference Settings dialog, using the ip address (or the hostname) and port the web service is listening on.

Press OK to save the settings.

You are now ready to run the application and look into the statistical information provided by the web service.

Select one of time span options presented in the upper radio buttons to filter the statistic records. Click on any of the available tabs —Logins, Sessions, Connections or Browsers— and press the Refresh button. The analytics data will be displayed on the tab grid.

In a future post we will discuss the Profiles Web Service, completing the web services overview.

The post Using the Analytics Remote Desktop Web Service appeared first on Cybele Software.

An application can accept command line arguments when invoked. This allows the user to send additional information to the application when it is executed.

When an application is launched, the OS passes the command line arguments to the application as a collection of string values, using a white-space as separator.

Applications receive external arguments on a regular basis: when you open a document by clicking on its icon, the OS selects the associated executable program and calls it, sending the full document filename to the program as an argument.

Thinfinity VirtualUI allows you to send external arguments to applications in a transparent way, which works exactly like sending arguments from the command line.

Setting command line arguments in the application profile

Thinfinity VirtualUI enables external argument definition from the VirtualUI Server Manager. When you create an application profile, you can specify the execution arguments in the General tab panel of the Application Profiles editor.

These arguments will be received by the application as a list of string values, using the white-space character as argument delimiter.

In Delphi you can get command line arguments using the System.ParamCount and System.ParamStr methods. ParamCount returns the number of arguments, and ParamStr(index) returns each argument, with ParamStr(0) always being the path and name of the invoked program. Here is a way you can show the received arguments list:

1
2
3

  Writeln(Format(‘Arguments = %d’, [ParamCount]))
  for p := 1 to ParamCount do
    Writeln(Format(‘argument %d = “%s”’, [p, ParamStr(p)]);

In C++, both the argument counter and the argument list will be received in the two main() function arguments. Like in Delphi, the first argument in the string array is the path and name of the program itself:

1
2
3
4
5

void main(int argCounter, char* arguments[]) {
  cout << "Arguments = " << argCounter << endl;
  for(int i = 1; i < argCounter; i++)
  cout << "arguments[" << i << "] = " << arguments[i] << endl;
}

You can also write the main function header in this way:

1

void main(int argCounter, char** arguments) { … }

Unlike Delphi and C++, C# excludes the name and path of the program from the arguments collection. Also, C# offers two ways to get the arguments, by using a traditional for…

1
2
3
4
5
6
7
8

public static void Main(string[] arguments)
{
    Console.WriteLine("Arguments = {0}", args.Length);
    for(int i = 0; i < arguments.Length; i++)
    {
        Console.WriteLine("Arguments[{0}] = [{1}]", i, arguments[i]);
    }
}

or by using the foreach:

1
2
3
4

foreach(string s in arguments)
{
    Console.WriteLine(s);
}

Sending command line arguments to the application in the VirtualUI url

VirtualUI allows you to send external arguments in the url. Instead of passing static arguments from the application profile definition, using this feature you can send dynamic application arguments in a simple way. The only requirement to be met is that the arguments must be url encoded.

To build the url you need:

• The communication protocol (http or https).
• The Thinfinity VirtualUI server domain or IP address, and port.
• The application virtual path.

Build the url like this:

1

protocol://server.address:port/virtualpath/?arguments

As an example, we will send the “one”, “two” and “three” argument values to the TestArguments program:

1

http://192.168.0.229:6580/TestArguments/?one%20two%20three

The following image shows the submit result:

Building the URL in Javascript

When necessary, modern browsers encode URLs automatically, but it is convenient to do it by code. The Javascript lines below show how to build the URL used in the previous example:

1
2
3
4
5
6
7

var buildURL = function(server, virtualpath, arguments) {
  return server + “/” + virtualpath + “/?” + encodeURIComponent(arguments.join(‘ ‘));
}
var baseURL = “http://192.168.0.229:6580/”;
var applicationPath = “TestArguments”;
var arguments = [“one”, “two”, “tree”];
var url = buildURL(baseURL, applicationPath, arguments);

Combining both application profile and url command line arguments

If you have defined command line arguments in the application profile and need to send new arguments to the application by url, don’t worry. Thinfinity VirtualUI merges both argument lists, first adding the application profile arguments, and then the arguments that were passed in the url.

The post Passing command line arguments to VirtualUI apps appeared first on Cybele Software.

Thinfinity VirtualUI web-enabled applications allow you to programmatically send files to be downloaded in the browser. There are no secrets to that, but the VirtualUI.DownloadFile method has variations enough to deserve a short post in this blog.

There are three ways to call this method:

• Passing the local file name as an argument,
• Passing the local and remote file names as arguments,
• Passing both filenames and the MIME file type as arguments.

Each argument of the DownloadFile method defines more precisely how the file will be handled in the browser.

Sending a file to the browser

Sending a file to the browser is easy. Set the FileName argument —including the path, if necessary— to determine the local name of the file to be sent. This name will also be used as the remote file name in the browser. The file type will be resolved by the browser.

The following examples show how to send a file to the browser:

Delphi

VirtualUI.DownloadFile(‘c:\path\filename.ext’);

C#

private VirtualUI vui = new VirtualUI();
...
...
vui.DownloadFile(“c:\\path\\filename.ext”);

C++

VirtualUI* vui = new VirtualUI();
...
...
vui->DownloadFile(L"c:\\path\\filename.ext”);

Changing the remote file name

The two-argument call is used to specify a new remote name for the file. The RemoteFilename value doesn’t include the path, only the LocalFilename value can have a path reference.

Change the remote filename in a download as follows:

Delphi

VirtualUI.DownloadFile(‘c:\path\filename.ext’, ‘newname.ext’);

C#

private VirtualUI vui = new VirtualUI();
...
...
vui.DownloadFile(“c:\\path\\filename.ext”, “newname.ext”);

C++

VirtualUI* vui = new VirtualUI();
...
...
vui->DownloadFile(L"c:\\path\\filename.ext”, L“newname.ext”);

As in the previous case, the file type is resolved by the browser.

Why the MIME type?

MIME means “Multipurpose Internet Mail Extensions”. It’s a way of identifying file types on the Internet according to their nature and format. So, the third argument of the DownloadFile method defines the file type and format, which helps browsers select the appropriate handling of the downloaded file. If the value of this argument is blank, VirtualUI internally sets “application/binary” as the MIME type to force the remote download, preventing the browser to try to open it.

Here’s how to send a file to the browser defining its MIME type:

Delphi

VirtualUI.DownloadFile(‘c:\path\filename.ext’, ‘newname.ext’, ‘application/binary’);

C#

private VirtualUI vui = new VirtualUI();
...
...
vui.DownloadFile(“c:\\path\\filename.ext”, “newname.ext”, “application/binary”);

C++

VirtualUI* vui = new VirtualUI();
...
...
vui->DownloadFile(L"c:\\path\\filename.ext”, L“newname.ext”, L“application/binary”);

The OnDownloadEnd event

The file download is an asynchronous process. When you send a file to be downloaded, the program doesn’t stop functioning while it waits for the download to end.

When the file download has finished, VirtualUI triggers an event message that you can catch by attaching an event handler to VirtualUI.OnDownloadEnd. You can use it to inform when the file has been downloaded or, for example, to delete a temporary file that will nevermore be used.

Here’s how to attach a handler for the OnDownloadEnd event:

Delphi

procedure TMainForm.DownloadEndHandle(Sender: TObject; const filename: string);
begin
   ...
end;
...
...
VirtualUI.OnDownloadEnd := Mainform.DownloadEndHandle;

C#

private VirtualUI vui = new VirtualUI();
...
...
vui.OnDownloadEnd += DownloadEndHandle;
...
...
private void DownloadEndHandle(object sender, DownloadEndArgs e)
{
   ...
}

C++

void DownloadEndHandle(std::wstring &filename) {
  ...
}
VirtualUI* vui = new VirtualUI();
...
...
vui->OnDownloadEnd = DownloadEndHandle;

A Delphi example

The following example in Delphi shows how to process a file download, selecting the corresponding method call depending on the current options:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

uses
  ..., VirtualUI_SDK;
  ...
  ... 
 
procedure TMainForm.doDownload(localFilename: string; remoteFilename: string; mimeType: string; forceDownload: boolean);
var path: string;
begin
  if forceDownload then begin
    if remoteFilename = ‘’ then
       remoteFilename := localFilename;
    VirtualUI.DownloadFile(localFilename, remoteFilename, '');
  end else if mimeType <> '' then
    VirtualUI.DownloadFile(localFilename, remoteFilename, mimeType)
  else if remoteFilename <> '' then
    VirtualUI.DownloadFile(localFilename, remoteFilename)
  else
    VirtualUI.DownloadFile(localFilename);
end;
 
procedure TMainForm.ShowDownloadEnd(Sender: TObject; const filename: string);
begin
  ShowMessage(ExtractFilename(filename) + ' has been downloaded');
end;
 
procedure TMainForm.FormCreate(Sender: TObject);
begin
  if VirtualUI.Active
    VirtualUI.OnDownloadEnd := Mainform.ShowDownloadEnd;
end;

Conclusion

If you need to download files from your web-enabled application, Thinfinity VirtualUI offers you many options to do so. In upcoming articles we will review other exciting Thinfinity VirtualUI features, including the file upload. Stay tuned!

The post Download files from VirtualUI web-enabled apps appeared first on Cybele Software.

Coming soon, Thinfinity VirtualUI web-enabled applications will allow you to save application sessions and replay them later.

There are many scenarios for session recording: reproduction of issues, application demos and tutorials, technical support, audit monitoring, e-learning, etc.

In a previous post we explained how to record and play Thinfinity Remote Desktop Server sessions. In this opportunity, we will review a similar Thinfinity VirtualUI feature that helps developers record sessions of their own VirtualUI web-enabled applications.

To enable this feature, VirtualUI includes a new Recorder component, available for all its supported programming languages. Using this component in your application, you can save each application session totally or partially. Afterwards, you will be able to play this session in the browser within the VirtualUI web interface, or by implementing your own custom session player using the SDK.

Recording a Session

Set the Filename property of the VirtualUI.Recorder component and call its Rec() method to record an application session.

The Filename property value can include a full path, but must not include the file extension, as it will be stored automatically as .dat and .idx files.

Set the Filename property as follows:

Delphi code

1

VirtualUI.Recorder.Filename := 'C:\Sessions\VirtualUISession';

C++ code

1
2
3
4

VirtualUI m_VirtualUI = new VirtualUI();
...
...
m_VirtualUI->Recorder()->Filename(L"C:\\Sessions\\VirtualUISession");

C# code

1
2
3
4

private VirtualUI vui = new VirtualUI();
...
...
vui.Recorder.Filename = "C:\\Sessions\\VirtualUISession";

As with any recorder, you can start and stop recording any time you wish. You can specify more than one track for each session. These tracks are indicated in the session recording and allow you to, for example, store different application operations. Call the Rec() method and pass the track name as an argument:

Delphi code

1

VirtualUI.Recorder.Rec('Track 1');

C++ code

1

m_VirtualUI->Recorder()->Rec(L"Track 1");

C# code

1

vui.Recorder.Rec(“Track 1”);

In order to stop the recording, call the Stop method:

Delphi code

1

VirtualUI.Recorder.Stop();

C++ code

1

m_VirtualUI->Recorder()->Stop();

C# code

1

vui.Recorder.Stop();

Afterwards, you can start another recording with the Rec() method. If you keep the same track name, the recording will resume and the session will be stored after the previous session in the same file, in a new track. Change the track name to avoid ending up with two tracks that have the same name in the same session recording.

The OnRecorderChanged event

Use the VirtualUI.OnRecorderChanged event to listen for any change in the Recorder status.

These are the possible status values:

The following examples show how to assign an event handler to this event in the most used languages:

Delphi code

1
2
3
4
5
6
7
8
9
10
11
12
13

procedure TMainForm.RecorderChanged(Sender: TObject);
var msg: string;
begin
  msg := '';
  case VirtualUI.Recorder.State of
    Inactive: msg := 'Recorder is inactive';
    Playing: msg := 'Recorder is Playing';
    Recording: msg := 'Recording session';
  end;
  ShowMessage(msg);
end;
...
VirtualUI.OnRecorderChanged := Mainform.RecorderChanged;

C++ code

1
2
3
4
5
6
7
8
9
10
11

void RecorderChanged(void) {
  CString stateStr;
  switch (m_VirtualUI->Recorder()->State()) {
    case Inactive: stateStr = _T("Recorder is inactive"); break;
    case Playing: stateStr = _T("Recorder is Playing"); break;
    case Recording: stateStr = _T("Recording session"); break;
  }
  MessageBox(0, stateStr, L"OnRecorderChanged called", 0);
}
...
m_VirtualUI->OnRecorderChanged = RecorderChanged;

C# code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

private void RecorderChanged(object sender, RecorderChangedArgs e)
{
    string message = "";
    switch (vui.Recorder.State) {
        case RecorderState.Inactive:
            message = "Recorder is inactive";
            break;
        case RecorderState.Playing:
            message = "Recorder is playing";
            break;
        case RecorderState.Recording:
            message = "Recording session";
            break;
    }
    MessageBox.Show(message, "OnRecorderChanged called");
}
...
vui.OnRecorderChanged += RecorderChanged;

As you can see, with a few lines of code, you will be able to save sessions of a Thinfinity VirtualUI web-enabled application.

In an upcoming post we will explain how to play a Thinfinity VirtualUI session recording.

The post Preview: Thinfinity VirtualUI session recording appeared first on Cybele Software.

Thinfinity VirtualUI Tutorial: What it is? What does it do?

With Thinfinity VirtualUI, any developer can create dual-platform applications (Windows/HTML5) by adding only one line of code to their existing projects built in .Net, Delphi, Visual C++, Virtual Basic or others.

Thinfinity VirtualU allows these applications to be run normally on a Windows environment, or installed in a Thinfinity VirtualUI Server environment and be accessed remotely from any HTML5-compliant Web browser.

Check out these press releases:

• Comprehensive HTML5-Remoting Solution for .Net, Delphi, Visual C++ and ActiveX
• Windows apps reach a new level with GUI Virtualization and Web Integration
• Now Cybele Software Releases Thinfinity VirtualUI v1.1

Would you like to see some online demos?

Find them here.

What about jsRO?

Thinfinity VirtualUI relies on Javascript Remote Objects (jsRO), a brand new technology conceived by Cybele Software that enables the creation of remotable server objects, mirrored to the web as native Javascript objects.

jsRO provides full two-way data-binding and remote procedure calls using an easy and straight-forward methodology -making the integration of Windows desktop and web access as easy as pie!

Still thinking about why you should adopt VirtualUI?

You now have the opportunity to take your app to the web in a few minutes.

Thinfinity VirtualUI web-enables Windows Apps with just a single line of code. And it works with popular Windows development environments and programming languages!

When using VirtualUI there’s no need for costly virtualization or remoting environments such as Citrix XenApp® or Microsoft™ RemoteApp, hence slashing IT costs and simplifying maintenance and administration.

Read more about the many Thinfinity VirtualUI benefits.

Thinfinity VirtualUI Guide for a Smooth First Time User Experience

Thinfinity VirtualUI is designed to have a straightforward implementation.

Completing the whole Thinfinity VirtualUI installation and setup will only take a couple of minutes before you can enjoy access to your desktop application from a browser in a pure HTML5 interface.

We’ve prepared an article to tell you about some tips and tricks that can help you save time and ensure you have a smooth first time user experience.

###

Additional documentation:

Product Page: http://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui/

Contact:

For more information about Thinfinity VirtualUI, contact Cybele Software, Inc.
3422 Old Capitol Trail, Suite 1125
Wilmington, DE – 19808, USA.
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: info@cybelesoft.com
Website: www.cybelesoft.com

The post All about Thinfinity VirtualUI appeared first on Cybele Software.

In a previous post we explained how to add remote data persistence to your apps by saving cookies in the browser. In this opportunity we will take advantage of this feature to develop a small but useful demo that shows how to provide an extended sign-on for web users.

Thinfinity VirtualUI web enabled apps were born as desktop apps and most include their own login mechanism. In this opportunity, we will show you how to extend your own existing application’s sign-on process, getting the browser to identify the application’s user. In this way, users would only need to manually login when accessing the application for the first time, after logging out or when the login ID has expired.

Let’s do it

The present demo assumes this scenario:

• The application is accessed both from the web through a VirtualUI Server and from the Windows desktop.
• Users access the web-enabled application without authenticating against VirtualUI.
• The user identification (user authentication) is performed in the application by using a login form and any local validation (accessing a database, a file, an external service, etc.; in our demo users are stored in a collection).

In the following C# example (find the code here):

• On the first user access, we will show the application’s login form to get the end-user credentials, saving an identification token in the browser when the user authentication was successful.
• Subsequently, if the token exists and is not expired, we will use it to identify the current user, bypassing the application’s login form.
• Additionally, we will add a logout option to remotely delete the token in order to force a login for the next connection.
• When the application is run from the Windows desktop directly, this authentication scheme is disabled and the original login process is used.

The demo application is composed of two forms and two auxiliary classes to resolve the end-user authentication:

• The main application form.
• The login form.
• The UserValidator class, to provide the user validation.
• The secondary User class, to keep each user in a collection.

The Thinfinity VirtualUI library is added to web-enable the application.

The class diagram shows these elements, their public attributes and methods:

Are You Using the Application from the Web?

When you start a web-enabled application, VirtualUI checks whether you are accessing locally from the Windows desktop or from the Web. To know when the user is accessing from the web, check the VirtualUI.Active attribute value.

MainForm creates an instance of the VirtualUI class and attempts to connect to a VirtualUI Server; when it succeeds, the VirtualUI class instance is set to Active. As this is valid only when you run the application from the browser, if the VirtualUI.Active attribute is true, the application tries to read a cookie from the browser.

Cookies are small pieces of text sent from a website (in this case our application, using VirtualUI methods) and stored in the user’s web browser. Once stored, cookies can be read or deleted, and if we want to, they can have an expiration date.

We will use a cookie to store a user identification value, but for security reasons this value cannot be the username or the password. We will create a token for each successful login. This token is a unique ID, a long text value that will be saved along with the user credentials in the application side (e.g. in a database) and stored in the browser.

The application tries to recover the token to perform a user validation using the UserValidator class. If the token is valid, UserValidator will return the identified username and then we will bypass the login process.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

using System;
using System.Windows.Forms;
using Cybele.Thinfinity;
 
namespace LoginDemo
{
    public partial class MainForm : Form
    {
        const string COOKIE_NAME = "MYAPP_accesskey";
        UserValidator _uservalidator = null;
        VirtualUI _virtualUI = null;        LoginForm loginform = null;
        string _username = "";
 
        public MainForm()
        {
            InitializeComponent();
            _uservalidator = new UserValidator();
            _virtualUI = new VirtualUI();            _virtualUI.Start();        }
 
        private void MainForm_Load(object sender, EventArgs e)
        {
            // If you are accessing from the Windows desktop
            // or the browser authentication id doesn't exist
            // or the browser authentication id is invalid
            if (!_virtualUI.Active || !ValidateUser(_virtualUI.BrowserInfo.GetCookie(COOKIE_NAME)))            {
                // shows the login form
                loginform = new LoginForm();
                loginform.authenticationCallback = new AuthenticationHandler(ValidateUser);
                loginform.ShowDialog(this);
                // if the login dialog returns "" then the user cannot be identified
                if (_username.Equals(""))
                {
                    this.Close();
                }
                else
                {
                    // enabled only when accessed from the web
                    logOutToolStripMenuItem.Enabled = _virtualUI.Active;
                }
            }
        }
...
...
...

Saving and Deleting the Token

Storing the token in the user’s web browser is easy. The MainForm.UpdateUserToken method performs the token storage depending on the value parameter. If value is empty, that means we want to delete an existing token. But if value contains an existing username, it calls the UserValidator to obtain a new user token and defines the expiration date.

The cookie expiration date is set by using the expires=date format, where date is expressed in Greenwich Mean Time (GMT) format. If the expiration date is not set or if the format is wrong, the cookie expires when the web session ends. Otherwise, the cookie is persisted in the browser cache until the expiration date. To set the expiration date in GMT format (“DAY, DD-MMM-YYYY HH:MM:SS GMT”), add the “R” parameter in the date creation:

1
2

    token = _uservalidator.CreateUserToken(value);
    expirationDate = DateTime.UtcNow.AddDays(7).ToString("R");

If the expiration date is previous to the current time, the cookie will be deleted. To delete the token from the browser, we will set the expiration date to a past date:

1

    expirationDate = DateTime.UtcNow.AddDays(-1).ToString("R");

Finally, we perform the token storage by using the VirtualUI.BrowserInfo.SetCookie method:

1

    _virtualUI.BrowserInfo.SetCookie(COOKIE_NAME, token, expirationDate);

This is the complete MainForm.UpdateUserToken code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// in MainForm class:
 
        public void UpdateUserToken(string username)
        {
            string token = "";
            string expirationDate;
            if (!username.Equals(""))
            { // creates a cookie that expires after a week
                token = _uservalidator.CreateUserToken(username);
                expirationDate = DateTime.UtcNow.AddDays(7).ToString("R");
            }
            else
            { // forces the browser to delete the cookie
                expirationDate = DateTime.UtcNow.AddDays(-1).ToString("R"); // expired
            }
            _virtualUI.BrowserInfo.SetCookie(COOKIE_NAME, token, expirationDate);        }

And here you can see how to create the token:

1
2
3
4
5
6
7
8
9
10

// in UserValidator class:
public string CreateUserToken(string user) {
    string tkn = "";
    ...
    ...
    tkn = System.Guid.NewGuid().ToString();
    ...
    ...
    return tkn;
}

Two ways to exit

When opening the File application menu, you will find two options: “Log out” and “Exit Program”.

Why? Because only the “Log out” option will delete the token from the browser. When you choose “Exit program”, the browser will remember the user until the cookie expires. The code explains it better than words:

1
2
3
4
5
6
7
8
9
10

private void exitToolStripMenuItem_Click(object sender, EventArgs e)
{
    Application.Exit();
}
 
private void logOutToolStripMenuItem_Click(object sender, EventArgs e)
{
    RemoveUserToken();
    Application.Exit();
}

Voilà!

By adding a few lines of code, we adapted our web-enabled application login process to work with the browser in an integrated way, while keeping the previous desktop login functionality. We hope this demo can be useful for you.

There are other ways to resolve the end-user authentication with Thinfinity VirtualUI; it allows developers to integrate OAuth/2, RADIUS, Windows Logon and Custom Authentication, helping them to build single sign-on (SSO) mechanisms.

In an upcoming post we will show you how to implement a remote login by using SSO and external authentication methods.

The post Use Cookies to Extend a Web-enabled App’s Login appeared first on Cybele Software.

We already published a very popular article at CodeProject to discuss how the migration of PC desktop users to all kind of mobile devices affected the paradigm of software development.

The bring your own device (BYOD) era started more than a decade ago with Palms and the first smartphones, and now there are much more complex needs to solve. The exponential market growth of Chromebook, iPads and tablets demands a new approach to adapting applications to meet their users’ daily requirements.

How do we face the enormous challenge to migrate old but rock solid apps designed for Windows OS to this new mobile scenario where rules seem to change every day?

Now you can offer your Windows app to your customers as a pure HTML5 solution, opening the door to any mobile device they might work with. Give your users a fully featured, modernized, empowered web-based version of your well known software.

When a web-enabled app is the door, Thinfinity VirtualUI is the key.

With Thinfinity VirtualUI you can:

● Instantly transform applications built in .Net (Winforms and WPF), Delphi, Visual
C++, Visual Basic and others into dual ­platform Windows/HTML5 Apps.
● Enable full Windows­-to­-Web integration, by adding two-­way interaction between the
Windows application and the web page.
● Easily and instantly deliver applications as cross -browser, cross­-device web
apps.
● Publish all or only part of the Win32/Win64 app front end.
● Immediately upgrade and modernize Windows applications.
● Expand application availability to reach a wider user base.
● Deliver your software to customers as a managed service in the cloud.
● Dramatically reduce the Total cost of ownership (TCO), by slashing IT costs and
simplifying administration.

Want to know more? Check out the Product white paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf

Thinfinity VirtualUI delivers your Windows applications on any device, anywhere. All with a single line of code.

Windows Applications in the Web Instantly

As users are migrating from traditional desktop computers to mobile devices, transitioning your Windows application to the Web is the next logical step to increase your exposure. You can make your Windows applications accessible from the Web TODAY.

Furthermore, you may enhance your existing applications with online data, rejuvenate your older software, and deliver your application to anywhere in the world, all with Thinfinity VirtualUI.
 

Transform Your Application with No Effort

When publishing to the Web, sometimes data needs to be visually arranged in a new pattern, different  from the way it is presented to the user in the desktop application. Or maybe the interface needs to be replaced or enhanced to better accommodate the new devices it can now be accessed from, for a more adequate functionality and integration.

Usually, the urge of going beyond simple cosmetic changes also appears. One may wish to combine the application with native web resources, such as personalized web searches, multimedia resources, specialized information and data, and the like.

With small touches here and there, Thinfinity VirtualUI can transform the look and feel of your traditional application to offer your users a brand new experience.

Unlock the Power of jsRO!

Javascript Remote Objects (jsRO) is a framework designed to facilitate these and many other possible scenarios, by allowing a bidirectional communication between a web page or application and a Windows application. But, most importantly, to make that blending with the greatest possible transparency.

The key point is that jsRO enables the creation of objects in a Windows application that can be replicated in the browser as native Javascript objects. Every pair of objects is kept in sync with each other on both ends of the communication, and behaves as the same entity. This synchronization ensures bidirectional interaction, therefore immediately replicating changes in the jsRO objects’ properties, both on the browser and the Windows application.

We have prepared some tutorial articles for our fellow developers regarding Windows and Web integration through Thinfinity® jsRO:

• Introduction & Part 1
• Part 2
• Part 3
• Part 4

Need more insights? Take a look at our 12 tips to Adapt PC Desktop Applications to Mobile Devices article to discover how VirtualUI can transform your Windows applications.

Now You’re Ready to Start!

Thinfinity VirtualUI is designed to have a straightforward implementation. Installation and setup will only take a couple of minutes before you can enjoy access to your desktop application from a browser in a pure HTML5 interface.

Review our Thinfinity VirtualUI Guide for a Smooth First Time User Experience and contact us if you have any questions or need some guidance about the best way to take your application to the Web.

Documentation:

Product Page: https://www.cybelesoft.com/Thinfinity/VirtualUI/
White paper: http://www.cybelesoft.com/docs/thinfinity_virtualui_whitepaper.pdf
CodeProject Article: https://www.codeproject.com/Articles/1136872/Instantly-Increase-the-Value-of-your-Windows-Appli
Online manual: http://www.cybelesoft.com/helps/thinfinity/virtualui/

Contact us:
Phone: (302) 892-9625 or (866) 462-9768 (USA & Canada)
Email: support@cybelesoft.com

Did you know that Thinfinity VirtualUI has an easy way to customize the logo and web-styling characteristics?
There are several methods you could follow to change the logo, on the Thinfinity VirtualUI landing page.
You can accomplish this by replacing the image files in the directory “C:\Program Files\Thinfinity\VirtualUI\web\images” or just editing the source file in the ‘index.html’. But the best way is to use web aliases.
Web aliases allows you to leave the original files unaltered. This is very useful when updating Thinfinity VirtualUI, otherwise, when you make an update, the modified files will be replaced by the default ones losing all your customizations.

Customize the company logo

To get started you just need to create a file called “WebAliases.ini” in “C:\Program Files\Thinfinity\VirtualUI\bin64” (or “C:\Program Files (x86)\Thinfinity\VirtualUI\bin32” if you are using the 32-bit version).
In this file you will map the original file to a new one, like this:

[Alias]
/originalLogo.png=newLogo.png

The paths in the “WebAliases.ini” file is relative to the webroot (“C:\Program Files\Thinfinity\VirtualUI\web”). If you want to change the logo, for instance, it should look like this:

[Alias]
/images/Thinfinity_VirtualUI.png=C:\myWebAliasesItems\NewLogo.png

And this is the result when you reload the page:

 

Customize the Favicon

To change the favicon you simply have to update the file “web/favicon.ico” with your icon file. This will update the icon you see in the browser tab:

Customize the Styles

Updating the styles will require some CSS knowledge.
You will find all the CSS files in C:\Program Files\Thinfinity\VirtualUI\web\css.
Once you reach the file you just need to make the changes and save it.
If you don’t have any CSS knowledge we recommend to ask your Web designer for some assistance.

After you complete any of these changes you might need to refresh your browser cache for the updates to take effect.
If you have any questions regarding this blog entry, you can leave a comment below or send us an email at support@cybelesoft.com.
Cheers!

The post Customize Thinfinity VirtualUI’s Landing Pages appeared first on Cybele Software, Inc..

The post How to virtualize your applications appeared first on Cybele Software, Inc..