Web Design

Visual WebGui 6.2.3 SDK Released

Gizmox announces the release of version 6.2.3 of its SDK. This is a further stabilization and enhancement of the revolutionary 6.2 SDK which introduced the Visual WebGui Developer Experience with full Visual Studio integrationin, consolidate installation, incorporation of both the DHTML and the Silverlight in one package, and the ASP.NET wrapper wizard.

The new 6.2.3 SDK solves some issues that contribute to a smoother development experience. These are some of the issues solved in this version:

Issue Summary
VWG-3493 - Theme registration and selection was changed. The developer can select one theme or none. An error provider was added to indicate theme rows with errors. These rows will be saved and can be selected as the current theme.
VWG-3484 - Silverlight theme registration bug fixed.
VWG-3483 - TextBox Max length property bug fixed. Now you can edit part of the text by selecting it after it reached the max length size.
VWG-3402 - RibbonBar - DropDownBox showing a js alert popup with the menu item name fixed.
VWG-3385 - Control drag image was added to all the themes.
VWG-3383 - WGLables.GetLocalizedMonthString null value protection on CurrentUICulture added.
VWG-3389 - ASP.NET Control Wrapper menu item missing problem fixed.
VWG-3481 - DataGridViewComboBoxColumn populates items when it is data binded problem fix.
VWG-3464 - Accessing the scalable service was separated to a different method.
VWG-3359 - DataGridView population problem on form load fixed.
VWG-3460 - DataGridView vertical scrollbar where shown even if not required.
VWG-3463 - Web_OnClick.objSource was not cleaned after click is being raised.
VWG-3378 - Form Box result was null even when value added.
VWG-3367 - FormBox Form property was not saved in Viewstate.
VWG-3348 - SearchTextBox Text property was not shown when set by code.
VWG-3366 - FormBox Form property can now handel string.empty.
VWG-3327 - Crystal report after wrapping had no properties in design time.
VWG-3466 - Double click and click events on datagridview fixed.

The new SDK is available for Download.

Visual WebGui RAD AJAX Framework

Migration of desktop applications to the web using Visual WebGui

The following is the first part of a 3 parts series of articles ppublished on VisualWebGui website describing the various available migration options of desktop/smart client applications to the web using Visual WebGui migration tool.

In order to discuss the migration process of legacy desktop applications to the web, we should first agree on 3 different types of desktop applications:

  1. WinForms based desktop application (C#/VB.NET). The UI layer is coded using .NET languages – the business can be .NET, COM+ or any other interop.
  2. VB 6.0 based applications. The UI layer is coded with VB 6.0.
  3. Other desktop or smart client technologies (C++ MFC/ATL, Delphi, Java etc). Any other smart client technology based applications.

WinForms based desktop applications to Web
Background
Normally, without Visual WebGui the migration process of a WinForms desktop application to the web will require a full re-engineering of the UI layer to fit the web architecture and capabilities.

If we take WinForms migration to ASP.NET for example using any AJAX 3rd party controls in order to provide a rich UI experience, we will have to consider:

  • Entirely new API.
  • Entirely new update approach.
  • Entirely new look & feel – or work hard to customize the UI to look the same.
  • Lighten the amount of data transferred to the client and presented at any given time to avoid severe latency.
  • Compromise on features list due to the web limitations.
  • Handling security holes created as a result of opening services consumed by client side AJAX and transferring business logics to the client.

Visual WebGui SDK is fully integrated with Visual Studio and provides the exact same API and set of tools/capabilities which are provided out-of-the-box with WinForms 1.0 and 2.0. This fact enables the native capability of simply copying any existing WinForms source code to a VWG project and providing a fully functional equivalent web application.

The Process
The basic 3 steps of migration (view a walkthrough tutorial):

  1. Open a new Visual WebGui application.
  2. Copy the code from your WinForms project into this new web application.
  3. Replace any reference to WinForms API namespace (“System.Windows.Forms”) within the code to Visual WebGui API reference (“Gizmox.WebGUI.Forms”).

Any standard WinForms application which is using the 58 WinForms out-of-the-box controls will then compile and execute as a plain web application.

The outcome of this short process is an ASP.NET based solution in terms of deployment and runtime and has the following properties:

  • Deployment is copy & paste equivalent to an ASP.NET web site.
  • Server infrastructure requires an IIS and .NET CLR only.
  • The application can be consumed from any plain browser - no installation is made on the client.
  • Minor static and cached footprint on the client ~200kb of plain JS and HTML code due to the Empty Client concept.
  • Support for multiple presentation layers with the same code base (DHTML/Silverlight or Smart Client).
  • Maintain a single layer of code – no need to write or maintain JavaScript, HTML and services.
  • Highly secured due to the Empty Client concept.

Considerations & Exceptions
There are 3 major setbacks you might have on the process which you can quantify in advance and estimate the amount of work that has to be done in order to migrate your application:

  1. Minor differences between the VWG API and WinForms which are mainly caused by architecture differences.
  2. The amount of 3rd party controls that are used in your application. This section describes a situation of using some non-WinForms out-of-the-box controls (for example Infragistics or DevExpress controls etc). In those cases you can select the most suitable solution from the following 3 options:
    • Choose a similar control from the WinForms out-of-the-box, adjust your code to use it and then perform the migration process.
    • Select an equivalent 3rd party ASP.NET control (Infragistics, Telerik, DevExpress etc.) which provides the same functionality, wrap it by a click of a button in VWG and adjust your code to use it.
    • Write your own VWG custom control which will perfectly suit your needs and then adjust your code after the migration process to use this control.
  3. Adjustments of a single user desktop application to a multiuser web environment. This section summarizes some of the major issues of transforming a single user application to a multiuser application sharing the same CPU, Memory space and other resources.
    • Thread safety – since a WinForms application can contain static members which are accessible to a single user, you should now consider one of the following:
      • Replacing those static members to a synchronized multi-thread safe data structures.
      • Lock critical read/write sections to protect concurrent multi user access.
      • Remove the statics and find instance or DB based solutions.
    • Memory load – in a desktop application, there might be places when the original consideration of the amount of memory in use was based on the assumption that the executing machine is local. therefore, many items are loaded to memory simultaneously without limitation.

Now, on a shared memory environment, when the server does the heavy lifting, the amount of memory consumed by each user will set the number of concurrent users that can be served by each server.

The following steps are recommended:

  • Consider loading items to memory on demand (keep only the headers and the identifiers in memory).
  • Remove any large objects read to memory – for example, don’t save binary objects to memory, instead write the binary to the response stream directly to the client.
  • Prefer DB based paging on entire prefaces and memory based paging. Visual WebGui provides mechanisms to enable it easily.

Summery
Migration of any WinForms application to the web using Visual WebGui has the following advantages:

  1. In 3 simple steps you will be able to get very close to a working web application.
  2. The effort you have to make in order to accomplish a fully functional web application is measurable.
  3. The application can keep using the existing BL and DL layers, and only the UI is either migrated automatically or adjusted.

Click to read the remaining articles:
VB 6.0 to Web
Smart Client and other Technologies to Web

or to view the tutorial:
How to Migrate WinForms to the Web

Visual WebGui 6.2.2 SDK Released

The 6.2.2 release provides compatibility to MS Silverlight RC0/RTW, and now supports development & deployment of web applications with the latest Silverlight technology. As stated before, Microsoft has released Silverlight 2 with weak backwards compatibility to previous Silverlight versions, which resulted in some presentation issues with the Silverlight layer that are now solved.

The new release also includes the Visual WebGui WinForms-like designer allowing simple and cost-effective Web development, and the new ASP.NET Control wrapper wizard introduced earlier this month.

Version 6.2.2 provides further stabilization to 6.2 which brought new standards in developer experience. for more information please read the official announcement.

The new Visual WebGui SDK is now available for download.

Full Silverlight compatibility with the upcoming VWG 6.2.2

Hi,

As announced before on Visual WebGui.com, the 6.2.2 release which is expected to be released later this week will provide compatibility to MS Silverlight RC0/RTW.

As you probably know, Microsoft recently released a new version of Silverlight which provides almost no compatibility backwards to older Silverlight versions. This means that all the released VWG Silverlight applications will not work with this new MS Silverlight version.

Furthermore, Microsoft triggered an automatic update mechanism inside Internet Explorer to have the Silverlight ActiveX update without asking. As a result, all computers with MS Silverlight client installed on it have the new version, unless the user manually removed it.

Since Microsoft released this incompatible version, our Silverlight development team has been working very hard on modifying Visual WebGui to get in line with those changes and support the new MS version once again. We were also promised by Microsoft director in Silverlight group that this was the last back compatibility breaking.

Learn more about developing Silverlight Applications with Visual WebGui

The new Visual Studio integration demonstrated on Webcast

On Nov 24 at 9am PT, Visual WebGui will be presenting another Webcast as part of the MSDN Webcast series:
Integrating Visual WebGui into Visual Studio Simplifies Development and Saves Time and Money

In this webcast, we will demonstrate the new integration, usability & compatibility features introduced with version 6.2.

Attend this webcast to learn how the Visual WebGui platform increases productivity when developing AJAX DHTML and Microsoft Silverlight applications, saving time and money. And learn about Visual WebGui's complete integration into the Microsoft Visual Studio development system, a consolidated installation process, and the opportunity to use Microsoft Visual Studio Express Editions for software evaluation and trials.

Register online

Visual WebGui 6.2.1 SDK released

I would like to share with you the release announcement of Visual WebGui 6.2.1 SDK made last week by Gizmox.
The Visual Webgui SDK now incorporates both the DHTML and the Silverlight and enables to work with both .NET 2.0 and 3.5 on the same machine. In addition, the new release includes the new wrapper feature announced earlier.

Version 6.2 presented some important enhancements mainly to the developer experience as it introduced a complete integration into Visual Studio, a consolidated installation process and compatibility with Visual Studio Express edition and DharpDevelop.

Here is a more detailed about this version description:

New feature Summary
ASP.NET Control Wrapper wizard Asp.Net Wrapper wizard added to Visual WebGui infrastructure.
This wizard enhances Visual WebGui abilities and allows you to use any ASP.NET thirdparty control that you have and add it to you Visual WebGui application as an out ofthe box control. Making Visual WebGui applications even richer than before.

Issue Summary
VWG-2721 Tabbing between controls bug solved
VWG-3097 Problems with Flow Layout Panel bug solved
VWG-3140 Integration package and source control problems solved
VWG-3189 Installation prerequisites warnings & errors issues fixed
VWG-3143 DateTimePicker in Time Format with ShowUpDown set to true AM/PM problem fixed
VWG-2363 TextBoxValidation IntegerMaskValidator fixed and dosent allows non-numeric characters
VWG-3139 Now you can install 2.0 and 3.5 at the same time
VWG-3178 Unnecessary padding was removed from bottom RibbonBarGroup
VWG-3130 EnterKeydown event Problem was fixed and is now fired
VWG-2460 TreeView events issues solved
VWG-3077 DataGridView border fixed
VWG-2699 Anchor in HtmlBox fix
VWG-3078 Session state serialization under IIS fixed
VWG-3076 Charting in catalog fixed
VWG-3033 Theme registration in VS2005 solved
VWG-3061 Problem with controls events in FlowLayoutPanel solved

The Visual WebGui framework is available as a free download here

Develop Web with WinForms

Visual WebGui is an innovative framework for developing data intensive web applications based on its revolutionary 'empty client' platform.

The VWG framework empowers developers to build & deploy AJAX / Silverlight applications atop its platform using WinForms desktop methodologies and still allowing full flexibility, scalability, performance, security or complexity.

While conventional AJAX requires developers to program using a number of different client-side and server-side languages in multi level architecture, the 'empty client' platform enables the use of a single model with one layer. This allows developers to focus on what they want to achieve rather than on how to do so.

The reason is because the 'empty client' approach could supply well known desktop methodologies for web development. This leads to a much simpler design patterns and lets developers design highly interactive, data rich applications with basically the same productivity of designing desktop applications by dragging and dropping controls.

In addition, it is possible to provide pre-defined application blocks with the 'empty client' approach as most of the processing is done on the server. This drives up even more the efficiency and productivity of developing AJAX and enables the customization and extension of .NET components.

Merb 1.0 Released

After two years of development, the first serious contender to challenge Ruby on Rails in the area of Ruby web application frameworks has reached 1.0 status: Merb. Created by Ezra Zugmuntowicz, Merb is built to be lightweight, less monolithic than Rails--i.e., you have your own choice of ORM, JavaScript, and templating frameworks--as well as thread-safe (which Rails, prior to the upcoming version 2.2 at least, was not).

You can get the gem from RubyForge with (something like) the following :

$ sudo gem install merb --include-dependencies

(Alternative site: —source http://edge.merbivore.com)

You can then generate your first Merb project and run it with the following:

$ merb-gen app my_application
$ cd my_application
$ merb

Then, of course, you'll want to read the documentation.

Auto Resize iFrames - Part 2

Tagged:  

In part 1 of this 2 part series on auto re-sizing iFrames I explained the basic principal of how it would work (you can read part1 here). Today I will give code examples to better demonstrate how you would accomplish this in the real word.

Below is an example of the server side proxy that would be used (this example is written in classic asp [as I needed to use this scripting language for the server that this script was to run on] but this could easily be re-written in your favorite language).

<%@ LANGUAGE=VBScript%>
<% 
            Response.Buffer=True

            Dim MyConnection
            Dim TheURL  

            ' Specifying the URL
            TheURL = Request("url")

            Set MyConnection = Server.CreateObject("Microsoft.XMLHTTP")

            ' Connecting to the URL
            MyConnection.Open "GET", TheURL, False

            ' Sending and getting data
            MyConnection.Send 

            TheData = MyConnection.responseText
            'Set the appropriate content type

            Dim MoreData, MoreData2

            MoreData2 = "<script type='text/javascript'>function Loadcontent(){var iframes = window.parent.document.getElementsByTagName('iframe'); for(var a=0; a</head>"
>"

             MoreData = TheData
           

            MoreData = Replace(TheData,"</head>",MoreData2)

            Response.Write (MoreData)

            Set MyConnection = Nothing     

%>

The below JavaScript is the most important part of the above code (I've formatted it to make it easier to read). In the proxy script it adds this code to the head tag of a page to accomplish the resizing. This code has been tested in IE6 and IE7, but needs a bit of tweaking to work cross browser (it re-sizes the iFrame incorrectly in FireFox, but this is easily fixed and I will post this code when I finish it).

<script type='text/javascript'>
	function Loadcontent()
	{
	var iframes = window.parent.document.getElementsByTagName('iframe');
		for(var a=0; a

So, in order to have an iFrame that re-sizes you would simple call the proxy url from the iFrames src property and set the url parameter (that us passed into the proxy) to the url of the page that you would like to display in the iFrame.

While this iFrame method accomplishes loading content from a different site you could accomplish the same thing using a div element and the XMLHTTPRequest object in JavaScript. Both methods would require the use of a cross-domain proxy (if loading content from a different site). I would probably use the div XMLHTTPRequest element if I am making a new application (as the div element re-sizes very well on it's own). However, if you have an application that already uses iFrames, then this script would be an easy way to make them re-size.

Auto Resize iFrames - Part 1

Tagged:  

At times you may need to load content from other domains or websites into a web application that you are creating. One of the most common ways to accomplish this is to use an iFrame to load the content (this is assuming that you just want to display a web page in your application). In some cases you will want to load content and have the iFrame re-size based on the content that is being loaded into the iFrame.

The interesting thing is that there is no easy way to do this. You can't set the iFrame's width and height properties to 100% as this will have the iFrame take over the screen and not just re-size based on content. The solution that I came up with is the use of a server side proxy (which gets around cross-domain issues) and some javascript that is added from the server side proxy code to re-size the iFrame.

This first post will give you an idea on how this would be accomplished. In my next post I'll talk about the code that would be used and discuss the pros and cons (as well as other methods that could be used to accomplish the same effect). So make sure to check your feed reader for the next post...

Syndicate content