App Build Erm Lui

8/14/2019 App Build Erm Lui

http://slidepdf.com/reader/full/app-build-erm-lui 1/34

BluePhoenix AppBuilder 2.1.0

Multi-Language User Interface Guide

http://www.bluephoenixsolutions.com/




BluePhoenix AppBuilder 2.1.0Multi-Language User Interface GuideApril, 2003

Corporate Headquarters

BluePhoenix Solutions

Vlierwerf 7B4704 SB RoosendaalThe Netherlands+31 (0) 165 399 401+31 (0) 165 396 308 fax

USA Headquarters

BluePhoenix Solutions USA, Inc.8000 Regency ParkwayCary, NC 27511United States+1 919.380.5100+1 919.380.5111 fax

www.bluephoenixsolutions.com

© 1992-2003 BluePhoenix Solutions

All rights reserved.

BluePhoenix is a trademark of BluePhoenix Solutions. All other product and company namesmentioned herein are for identification purposes only and are the property of, and may be trademarksof, their respective owners.

Portions of this product may be covered by U.S. Patent Numbers 5,495,222 and 5,495,610 and various

other non-U.S. patents.

The software supplied with this document is the property of BluePhoenix Solutions, and is furnishedunder a license agreement. Neither the software nor this document may be copied or transferred by anymeans, electronic or mechanical, except as provided in the licensing agreement.

BluePhoenix Solutions has made every effort to ensure that the information contained in this documentis accurate; however, there are no representations or warranties regarding this information, includingwarranties of merchantability or fitness for a particular purpose. BluePhoenix Solutions assumes noresponsibi li ty for errors or omissions that may occur in this document. The information in thisdocument is subject to change without prior notice and does not represent a commitment byBluePhoenix Solutions or its representatives.





i

TABLE OF

CONTENTS Table of Contents

Product Name Version Document Title

1 Introduction to MLUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-1

Overview of MLUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-1

Limitations of MLUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1-2

2 Developing M ulti-Language U ser Interface Applications . . . . . . . .2-1

Understanding MLUI options in Construction Workbench. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-1Construction Workbench MLUI design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-1MLUI Workbench Options settings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-2Construction Workbench menu behavior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-3

Convert ing existing applications to MLUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-3Understanding the Default Language setting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-4Understanding the Current Language setting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-4

Developing new MLUI applications with AppBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5Understanding the Default Language setting in new applications . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5Using the Current Language setting in new applications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5

Understanding migration issues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5

Populating the workgroup repository first . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-5Understanding language panel synchronizati on. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-6Migration to pre-MLUI AppBuilder repositories. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-7

Repository objects with MLUI capability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-7Window objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-8Set Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-9

HTML Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-10

Simulating the Window Flow Diagram in an MLUI environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . .2-11

Understanding MLUI application preparation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-11

Impact of MLUI on the application development cycle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-11

Code Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-11Client Runtime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-12Rebuild Facility. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2-12



ii

3 Installing MLUI Functionality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3-1

4 Using Construct ion Workbench to Develop an M LUI

Application

Working with language objects in the repository. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-1Defining the Default Language in the repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-1Defining a new language in the repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-2Modifying a language object in the repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-3Deleting a language object in the repository . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-3

Sett ing the Workbench Options for MLUI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-3

Creating windows for different languages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-4Editing attributes for a specific language panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-5Understanding the Language menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-7Deleting a language panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-8Viewing a specific language panel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-8Synchronizing language panels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-8

Creating sets in different languages. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4-9

A Language Groups. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A-1

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i



AppBuilder 2.1.0 Multi-Language User Interface Guide 1-1

CHAPTER

1

INTRODUCTION TO MLUI

AppBuilder 2.1.0 Multi-Language User Interface Guide



The purpose of this manual is to define the concepts and describe the functionality provided by the newMulti -Language User Interface (MLUI) feature introduced in AppBuilder 2.1.0. By using this manual,you will learn how to use the extensions of the AppBuilder tools to build multiple user interfaces for oneapplication. This manual does not address the problem of merging existing language-specific

applications already developed in AppBuilder.With MLUI, you can develop applications with language dependent user interfaces that can be targetedto different language environments within one language group. A language group is a set of languagesthat are based on the same codepage.

This introductory chapter covers information on the following topics:

Overview of MLUI

• Limitations of MLUI

Overview of M LUIMultiple Language Support (MLS) is the ability to develop an application for more than one language.The Appbuilder MLUI functionali ty offers MLS capabil it y by giving you the power to develop more thanone language-dependent user interface for a single application. With MLUI functionali ty in AppBuilder,the user can create applications that have user interfaces customized for different languages, preparingthem one at a time.

The MLUI functionali ty also gives the user the abil ity to convert an existing application into an MLSapplication, building a multi-language user interface from the existing base language.



1-2 Introduction to MLUI

Limitations of MLUI

The following AppBuilder products are enabled for MLUI:

• Window Painter

• Set Builder

• Turbocycler

• Window Flow Diagrammer

• HTML Generator

Limitations of M LUI

MLUI is limited to developing applications within a specifi c language group. A language group is a set oflanguages that are based on the same codepage. For a list of possible codepages and the languages thatcomprise them, see Appendix A, “ Language Groups”.




CHAPTER

2

DEVELOPING MULTI-LANGUAGE

USER INTERFACE APPLICATION S


This section is a discussion of concepts to consider and understand before developing a language-dependent application. The following topics are discussed in this section:

• Understanding MLUI options in Construction Workbench

• Converting existing applications to MLUI

• Developing new MLUI applications with AppBuilder

• Understanding migration issues• Repository objects with MLUI capabil it y

• HTML Generation

• Simulating the Window Flow Diagram in an MLUI environment

• Understanding MLUI application preparation

Understanding MLUI options in Construction

WorkbenchThis section discusses where you can find the Multi-Language User Interface (MLUI) options within theConstruction Workbench. The following topics are discussed in this section:

• Construction Workbench MLUI design

• MLUI Workbench Options sett ings

• Construction Workbench menu behavior

Construction Workbench MLUI design

In an MLUI environment, you must create a set of required languages using the MLUI Language Editor.The Construction Workbench doesn’t begin to function in MLUI mode until at least one language iscreated in the repository. In a non-MLUI mode, all language related options are invisible. WorkbenchOptions, Window Painter, and Set Builder appear as they do in a single-language environment.



2-2 Developing Multi-Language User Interface Applications

Understanding MLUI options in Construction Workbench

M LUI Workbench Options sett ings

There are MLUI options on the General tab of the Workbench Options window. Before you can set theseoptions you must populate the repository with language objects and define the Default Language for theapplication. Refer to Working with language objects in the repository for step-by-step instructions onpopulating the repository.

To access the Workbench Options window, from the Construction Workbench, click Tools >

Workbench Options > General.

Figure 2-1 Workbench Opt ions window

MLUI

Settings



Converting existing applications to MLUI


Construction Workbench menu behavior

AppBuilder in MLUI-mode creates additional menus based on the languages already define in therepository. When you create a language in the repository, AppBuilder automatically creates a menuoption for that language. Dynamic menu options make it easy for you to differentiate between thelanguages that are stored in the repository and the languages in which you have created your panels, andit makes it easy for you to toggle between di fferent language panels for a specific window or set.

Once you define the language objects that you will be using in the repository, AppBuilder displays thoselanguages in the MLUI menus. This makes switching between languages fast and easy.

Converting exist ing applications to M LUI

You can convert existing applications to multi-language applications. AppBuilder marks your pre-MLUIapplication object as a base object at the point when you create new MLUI window panels or set displayvalues for that object. AppBuilder provides a Default Language setting and aCurrent Language sett ing to

allow you to differentiate between the language of your existing application and the language of yournew MLUI application. The Default Language is intended for your base objects. The Current Languageis a specific Workbench Options setting that makes it easier for you to develop your new MLUIapplication. The following topics are discussed in this section:

• Understanding the Default Language setting

• Understanding the Current Language sett ing

Table 2-1 MLUI Workbench Options settings

Option Description

Current Language

Set the Current Language option from here to specify the language of

preparation and to dictate that windows or sets automatically open in this

language. This makes developing an application for one language at a time

easier. You do not have to specify the Current Language every time you opena new window or set. Before you can define your Current Language, you

must have created language objects in the repository.

Although, this option is used when you want to develop large parts of an

application one language at a time, AppBuilder gives you the flexibility to

develop a window or set in multiple languages before moving to the next

window or set.

Default Language

Used when converting an existing application to an MLUI application, the

Default Language is the language of your existing application. You must

define the Default Language in the repository using the Language Editor. See

Defining the Default Language in the repository. Once the Default Language

is defined, it is displayed here.

Note The MLUI menus can display up to 10 languages. To work with additional languages, selectthe menu option Languages... With a language panel active, clickEdit > Show Language Panel

> Languages... The Select Language window displays listing all the languages you haveavailable for that option.




Converting existing applications to MLUI

Understanding the Def ault Language sett ing

When you are creating an MLUI application from an existing AppBuilder application, specify theDefault Language as the language of your existing applicati on . Your Default Language can also beconsidered the language of your base objects. When you begin creating language panels and set displayvalues for an existing application, the original window or set objects are marked as the base objects. ForMLUI development, the base objects (windows and sets) are the initial source of the newly createdlanguage panels and display values. The base window or set objects refer to one of the following:

• The first window or set created in AppBuilder MLUI.

• For windows and sets init ially created in a pre-MLUI AppBuilder, the existing windows and sets aremarked as the base objects when a second language is added to that base window or set.

The Default Language is a repository-wide setting. In a group repository, the Default Language sett ing isshared by all users.

With the use of base objects, you can test your MLUI development before you complete the entireapplication in the Current Language. Although the Current Language is the language of preparation, ifyou have yet to develop all window panels or set display values in the Current Language, the DefaultLanguage is used where a Current Language panel does not exist. Refer to Understanding MLUIapplication preparation.

When developing a new MLUI application from scratch, it is not necessary to specify a DefaultLanguage. The first objects that are created in the repository automatically become your base objects andtheir language is considered the Default Language; therefore, i f the application is completely developedin the first language, the user can test subsequent languages using the Default Language design.

Understanding the Current Language setting

The Current Language is a Workbench Options setting whose purpose is two-fold:

• Your MLUI application is prepared using the Current Language sett ing, if language panels or displayvalues do not exists for the Current Language, the Default Language is used at preparation.

• AppBuilder opens each new window panel or set display value in the Current Language, allowing

you to easily develop large portions of your application for one language without having to specifythe language each time you open a new window or set.

The Current Language is a local setting. Each workbench can have its own setting. To define yourCurrent Language in the Workbench Options window, from the Construction Workbench, click Tools >

Workbench Options > General.

If the Current Language is set to “Not Defined” the base objects are used when editing windows or sets.

Note The Default Language setting on the Workbench Options window is for converting existing applications to

MLUI applications. When you are creating a new MLUI application, the Default Language setting on the

Workbench Options window is irrelevant, and for that reason, it is greyed out. For new MLUI applications,

the language of the initial window is considered the Default Language.

Note Before you can set a Current Language, you must define the language objects in the repository. Refer to

Working with language objects in the repository for information on creating the language objects in the

repository.



Developing new MLUI applications with AppBuilder


Developing new M LUI applications w ith

AppBuilder

The biggest difference between developing a new AppBuilder MLUI application and converting anexisting AppBuilder application to an MLUI application is the use of the Default Language setting. You

must specify a Default Language when converting a non-MLUI application to an MLUI application. But,when creating a new MLUI application, the first language you develop in automatically becomes theDefault Language. You do not have to take any specific action.

Understanding the D efault Language sett ing in new applications

When developing a new MLUI application with AppBuilder, it is not necessary to specify a DefaultLanguage. The first language that you develop the application in automatically becomes the DefaultLanguage; therefore, if the application is completely developed in the first language, the user can testsubsequent languages using the Default Language design. Refer to Understanding the Default Languagesetting for more information.

Using the Current Language setting in new applications

The way that you use the Current Language setting does not change regardless of whether you aredeveloping a new MLUI application or convert ing an existing AppBuilder application for mult iplelanguages. The Current Language is the language of preparation and the language in which your newMLUI panels wil l automatically open. Refer to Understanding the Current Language setting for moreinformation.

Understanding migration issues

When developers are working on separate pieces of an application in separate personal repositories, atone point , they must synchronize their work wi th the work of others. There are three distinct migrationissues that you must be aware of before you can successfully develop an MLUI application. This sectiondiscusses the fol lowing topics:

• Populating the workgroup repository fi rst

• Understanding language panel synchronization

• Migration to pre-MLUI AppBuilder repositories

Populating t he w orkgroup repository f irst

Your first step in working with AppBuilder MLUI is to create language objects in the repository. Theinternal system IDs of the language objects are unique for each repository. The unique IDs are preservedwhen the objects are migrated to other repositories. If a language object with the name SPAN ISH is




Understanding migration issues

created in two different Personal repositories, it will have two different system IDs. The windows or setsusing these two different language objects for SPAN ISH can not be merged without losing information.

For this reason, i f the same application is developed in two different Personal repositor ies and merged ina Workgroup repository, the language objects must be created in the group repositor y fi rst. Theselanguage objects can be migrated to the personal repositories ensuring that the same system IDs are ineach personal repository. Then, when the windows and sets using these language objects are merged, no

information is lost.

The practice of populating the group repository with objects and then migrating those objects down tothe various personal repositories is not a new concept in AppBuilder development. It is just that whenyou have many developers developing applications in the same language, the chance of creating languageobjects with conflicting system IDs is possible; therefore, it is worthwhile to mention the practice ofpopulating the group repository first here.

For detailed information about migrating objects from a group repository to your local repository, referto one of the following guides:

• If you are using the Enterprise Repository tool, refer to theEnterpr ise M igrati on Guide .

• If you are using the Freeway Repository tool, refer to theWorkgroup Repository Guide .

Follow these steps to migrate from an Enterprise Repository to a personal repository:

1. Create a function called LANGUAGE_FUNCTION.

2. Attach the language objects you created to the Function.

3. Download the LANGUAGE_FUNCTION with “Full hierarchy” scope.

Understanding language panel synchronization

In an MLUI environment, all the language panels of a given window are automatically synchronized.

When a GUI control is added to any one of the language panels, it is automatically added to otherlanguage panels for the same window. The same is true for deleting controls. Modifications to genericproperties of the GUI controls are also propagated to all language panels automatically. Refer toAttributes for a discussion on the difference of generic and visual attributes. In most cases, AppBuilderkeeps all the language panels synchronized throughout the changes you make to individual languagepanels.

There are situations, however, where the language panels can get out of sync:

• If each language panel has different user authority, propagation of updates between language panelswill fail . The failure is reported in an error message, but in spite of the error message, if the changedobjects are committed, the language panels could end up being different.

• If the language panels were created in two di fferent repositories using a pre-MLUI version ofAppBuilder, and the panels are merged into one repository using the AppBuilder TurboScripter.The HPSIDs within the language panels may be different because they came from different sources.

Because it is required that all language variants match the base window, AppBuilder’s MLUIfunctionality provides a synchronization option to ensure that the base windows and the languagevariant panels match. Use the synchronization option when you encounter the special cases listed above.With a language set display or window panel active, click Edit > Language > Synchronize Language

Panels. The synchronization tool considers the HPSIDs for each window control, comparing the



Repository objects with MLUI capability


HPSIDs on the base window to those on the corresponding language variant panels. Synchronizationthen adds or deletes controls from the language panel variants as necessary to ensure that they match theHPSIDs for the controls on the base window.

Verifying synchronization before you synchronize

The result of synchronization may have un-intended consequences. The base panel is used as a referencepoint; it is considered to be in the correct state. All other language panels are modified to match thecontents of the base panel; therefore, synchronizing window panels will change the display of yourlanguage panels. After synchronization, all language panels will have the same HPSIDs as the basewindow. AppBuilder gives you the opportunity to verify whether you need to synchronize your languagepanels before you run Synchronize.

The Verify Synchronization option does not tell you exactly which controls will be added or deletedduring synchronization, but it will tell you if you have conflicting HPSIDs in your window panels. Withthat information, you can further investigate which window controls do not match.

Figure 2-2 Sample Verify Synchronization Report

M igration to pre-M LUI AppBuilder repositoriesThe AppBuilder repository model has been modified to support MLUI functionali ty. These modelchanges are available in repositor ies released in AppBuilder 2.1.0 and later. The MLUI applications canbe migrated to another AppBuilder 2.1.0 or later versions of repositories without losing any data.However, AppBuilder does not support migration of MLUI applications to repositories that were createdbefore AppBuilder 2.1.0.


Both Window Painter and Set Builder are supported for MLUI. Using these tools, first create a windowor set object in your base language and then create subsequent window panels or set display values ineach language from that base. The newly created window or set has all the contents fi lled-in from thebase object. Once created, the language variants are separate window panels or sets whose visualattributes can be modified independently of the default, base object.

Note Once a window control is added or deleted, the change is reflected in all the window panels, regardless of

which panel the change occurred in.





Window objects

A window consists of panels, controls, and attributes. This section discusses how each item is handled inan MLUI environment.

Panels

The contents of a window are stored as panels in the repository, one panel per language. One of thesepanels is marked as the base panel. The base panel is used whenever the requested language panel doesnot exist.

Controls

GUI Controls are the objects within the panels. For example, fields, push buttons, and list boxes. Alllanguage panels for any given window are automatically updated if GUI controls are added or deletedfrom any one of the panels; however, you can manipulate what is displayed on each panel by using theVisible attribute. See Avoiding the global add and delete for more information about using the Visibleattribute.

Attributes

There are two types of attributes for GUI controls: generic attributes and visual attributes. The visualattributes are those attributes that affect what the user can see on your GUI. Some examples of visualattributes are Text, Size, Color, and Visible. Don’t confuse Visible and visual. Visible is an attribute oftype visual. Attributes of type visual can be altered for MLUI capability. The visual attributes are specificto each language panel; any change in a visual attribute on a language panel affects only that languagepanel.

The generic attributes, are those attributes that control object behavior under the covers of the userinterface. Some examples of a generic attribute are Editable, Enable, and Mandatory. Generic attributesremain unaffected by the language selection. When a generic attribute is updated in one language panel,it is automatically updated in all other language panels.

Note Deleting a language object from the repository can result in lost data for MLUI panels that use that

language. It is important that you do not carelessly delete language objects from an MLUI repository.





Figure 2-3 The hierarchy of repository objects associated with a window in an MLUI environment

Avoiding the global add and delete

When you add or delete a window control from one language panel, it is globally added or deleted fromall language panels for that window. In doing this, all language panels stay in sync. Refer toUnderstanding language panel synchronization. In order to manipulate this and provide the ability toshow controls on one panel and not on another, you can make window controls invisible using theVisible attribute. For example, if you need to add a control to the German variant, you must first add thecontrol to the base version, make it invisible under the Default Language, and make it visible for theGerman variant. The Visible attribute makes it possible to manipulate the global add or delete, allowingcontrols to appear on certain panels but not others. The result of a control being made invisible is onlyapparent at runtime.

Editing the window panels

Often customers who want an application tailored for their language will also want the windows to betailored for their unique needs. For instance, field names and field sizes must be manually adjusted tolook appropr iate for each language.

It is necessary for you to manually edit the attribute values for the visual attributes on a language-specific window panel. You must create all window text in the appropriate language, size the fields forthe language-specific data, and readjust the window display to accommodate different field sizes orinvisible/visible controls.

Also, after the window panels are synchronized i t may be necessary to manually edit the window panels

to accommodate for controls that may have been added or deleted dur ing the synchronization process.Refer to Understanding language panel synchronization for information on synchronization.

Set Objects

Lookup and Error set types are both supported for MLUI. You must manually edit the display values foreach language version of a specific set. These sets have Define, Encoding, and Display values. The Define

CUSTOMER_INFO_WINDOW

(WINDOW)

FRENCH

(LANGUAGE)(PANEL)

(PANEL)SPANISH

(LANGUAGE)

(PANEL)

Base

ENGLISH

(LANGUAGE)

Default Language




HTML Generation

and Encoding values are shared by all the languages. The Display values are specific to each language. Foran Error set, the error messages are also language specific. Create language variants for a set from thebase set object. Starting with the base set, create different display values for that set in the necessarylanguages. MLUI makes it possible to toggle between the different languages that you have created in therepository.

Figure 2-4 A Set with language variant display values

In Figure 2-4, The Default Language object or base object is directly associated with the Set objectDAYS_OF_WEEK. Its Set values are stored in the Symbol object. For language variants of this set, thelanguage objects are associated with the Symbol object, and the Display values for each Language objectare stored in the relationship between the Language object and the Symbol object.

HTML Generation

Your MLUI applications can be generated in HTML. The HTML generator picks the panels in theCurrent Language and generates the HTML for that language.

Note Deleting a language object from the repository can result in lost data for MLUI sets that use that language

object. It is important that you do not carelessly delete language objects from an MLUI repository.

DAYS_OF_WEEK

(SET)

(SYMBOL)Define value = Sun

Encoding = 0

Display = Sunday

ENGLISH

(LANGUAGE)

Default Language

(SYMBOL)Define value = Mon

Encoding = 1

Display value = Monday

FRENCH

(LANGUAGE)

SPANISH

(LANGUAGE)

Display value

(Dimanche)

Display value

(Domingo)

Display value

(Lunes)

Display value

(Lundi) FRENCH

(LANGUAGE)

SPANISH

(LANGUAGE)



Simulating the Window Flow Diagram in an MLUI environ-


Simulating the Window Flow Diagram in an M LUI

environment

A Window Flow Diagram for an MLUI application is simulated using panels in the Current Languagethat you have set. If no Current Language panels exist for the windows you are using in your flow

diagram, the base objects (in the Default Language) for those windows is used.

Understanding MLUI application preparation

An MLUI AppBuilder application is prepared using the Current Language. Refer to Understanding theCurrent Language setting. If there is no Current Language specified, Default Language is used. TheDefault Language is usually the language you specify for your base window or set objects. I f there is onlyone instance of a window panel or set display for any given window or set it will be used in preparation.Refer to Understanding the Default Language setting for more information on base objects.

Using the default makes it possible to prepare an MLUI application that has not yet been completelydeveloped in the new Current Language.

If you are developing the application for more than one language, you must prepare the applicationseparately for each language.

When preparing window panels only the window panels in the Current Language are prepared. Whengenerating an application in HTML, first the language panels for the Current Language are extractedand the HTML is generated from these panels. When preparing sets, the display values for the set areprepared based on the Current Language.

Impact of M LUI on the application development

cycle

Code Generation

The Appbuilder preparation generates code depending on the configuration settings. When preparing aMLUI enabled application, the following sett ings influence the output:

• Current Language is used to extract the appropr iate window panel and set display values.

• An AppBuilder Rule macro gets automatically defined. The macro can be used in the Rule'sLanguage to include any language specific Rules code. For instance, if English is the CurrentLanguage for preparation, a macro in the name of ENGLISH=TRUE gets defined. This macro canbe used in the Rule's language,

CG_IF(ENGLISH,TRUE)

map 'ENGLISH' to myText

CG_ELSE

map 'OTHER' to myText




Impact of MLUI on the application development cycle

CG_ENDIF

The name of the macro will be the same as the Current Language of Prepare. Refer to the Rules

Language Reference Guide for further information on using macros.

Client RuntimeThe execution environment has not changed in AppBuilder to accommodate MLUI in any of theplatforms. The preparation prepares for one language at a time, so the prepared objects are in onelanguage which is same as the previous versions of AppBuilder.

Rebuild Facility

AppBuilder 2.1.0 offers a Rebuild Facility that makes it possible for you to bui ld only portions of yourapplication, eliminating the need to build the entire application each time a change is made. This sectiondiscusses issues to consider when using the Rebuild Facility with MLUI applications. For a complete

discussion of the Rebuild Facility, refer to the Deploying Applications Guide .

When a developer rebuilds a language panel or set display, the entire partition is rebuilt; therefore, youshould consider developing a separate partition for each language.

Consider the scenario where you are developing an MLUI application. One developer is buildingwindow panels in one language (for example Spanish) and another developer is building windows in asecond language (for example French). Both developers are working on the same application within thesame partition. In this scenario, when either developer rebuilds the partition, all windows that werechanged, regardless of language, display in the rebuild list.

When the French developer does a rebuild, there will be windows included in the rebuild list that he didnot anticipate. The Spanish developer was working on those windows. But, more importantly, in this

scenario, when the Spanish developer rebuilds his changes, he will not see his work on the rebuild listbecause the base window’s “mark for rebuild” was cleared when the French developer rebuil t thepartition. And the Spanish developer cannot use the French developer’s build, because each developer isusing a different current language setting. In order for the Spanish developer to see his changes in hisrebuild list, he must make an additional change to the Spanish panel; then, rebuild the part ition wi th thecurrent language set to Spanish.

This type of scenario can get very confusing for the two developers who are working in the samepartition independently. The solution is to develop a separate partition for each language. For thisscenario, create two partitions, one for FRENCH and one for SPANISH. Attach the same applicationhierarchy to both partitions. When a change is made to a window, whether coming from FRENCH orSPANISH panels, the rebuild list on both part it ions is updated, but running a rebuild clears only the“mark for rebuild” flag of the part it ion you are building.

For information about partitions, refer to the Deploying Applications Guide .




CHAPTER

3

INSTALLING M LUI FUN CTIONALITY


The AppBuilder MLUI functionality is a separate installation option within the AppBuilder 2.1.0installation program. If you choose not to install MLUI , the MLS functionali ty is invisible. To makeMLUI ful ly functional within the Construction Workbench, you must install the functionali ty and createat least one additional language in the repository. Figure 3-1 shows the installation program panel thatdisplays MLUI as an installation option.

Figure 3-1 Selecting MLUI during AppBuilder 2.1.0 installation



3-2 Installing MLUI Functionality




CHAPTER

4

USING CONSTRUCTION

WORKBENCH TO DEVELOP AN MLUI

APPLICATION


This section shows you how to use the MLUI functionali ty within Construction Workbench to develop aMult i-Language User Interface. The following tasks are discussed in this section:

• Working with language objects in the repository

• Sett ing the Workbench Options for MLUI

• Creating windows for different languages

• Creating sets in different languages

Working w ith language objects in the repository

The first step in creating a Multi-Language User Interface (MLUI) is to create the languages in therepository. Once you have created at least one new language, the AppBuilder MLUI functionalitybecomes active in the Construction Workbench. This section shows you how to complete the followingtasks:

• Defining the Default Language in the repository

• Defining a new language in the repository

• Modifying a language object in the repository

Def ining the Def ault Language in the repository

Defining a Default Language in the repository can be handled one of two ways:

• Specifying a new language object as the default

• Specifying an existing language object as the default

Specifying a new language object as the default

If the Default Language is a new language object in the repository, do the following:

1. From the Construction Workbench, click Tools > Language Editor. The Language Editor windowdisplays (see Figure 4-1).



4-2 Using Construction Workbench to Develop an MLUI Application

Working with language objects in the repository

2. Click New Language.

3. Select a language for the Name list box.

4. Check theDefault Language check box to specify this new language as the Default Language.

5. Click Add. (Click Clear to clear the Name field and make another selection.)

The new language is listed to the left of the Language Editor window as the default .

Figure 4-1 Language Edi tor window

Specifying an existing language object as the default

If you are specifying an existing object in the repository as the Default Language, do the following:


2. Select the language from the li st on the left of the Language Editor window. The Name field i spopulated with the language you selected.

3. Select the Default Language check box to indicate that you want this language to be the default.

4. Click Apply. (Click Clear to clear the Name field and select another language.)

In Figure 4-1, the button displays Apply when working with existing languages, and Add whenadding new languages.

Def ining a new language in the repository

To create language objects in the repository, take the following steps:


2. Click New Language to activate the Add Language functionality.

3. Select a language from the Name list box.

New Language

Existing

Repository

Languages



Setting the Workbench Options for MLUI


4. Click Add.

In Figure 4-1, the button displays Apply when working with existing languages, and Add whenadding new languages.

The languages that are defined in the repositor y are listed on the left side of the Language Editorwindow.

M odifying a language object in t he repository

To modify the name of an object in the repository or to specify that an existing language object now bethe default, take the following steps:


2. Select the language from the list on the left of the Language Editor window. The Name field i spopulated with the language you selected.

3. Make the necessary modif ication to the language name or its default status.

4. Click Apply. (Click Clear to clear the Name field and remake your selection.)

Deleting a language object in the repository

The Construction Workbench and the Freeway Explorer do not provide explicit support for deletinglanguage objects. Language objects can be deleted using the Enterprise Repository when you are in anADM project. Refer to Chapter 3 in theEnterprise Administration Guide for information about the ADMproject type.

Sett ing the Workbench Options for M LUI

To set the MLUI Workbench Options settings, take the following steps:

1. From the Construction Workbench, click Tools > Workbench Options > General.

The Workbench Options window is displayed (seeFigure 4-2).

Note Before you can set MLUI options here, you must define the language objects in the

repository. See Working with language objects in the repository.




Creating windows for different languages

Figure 4-2 Workbench Opt ions window

• Current Language - When you specify the Current Language from the Workbench Optionswindow, AppBuilder automatically opens all window and set language panels in the CurrentLanguage. This makes it easier for you to develop large portions of an application in a singlelanguage.

• Default Language - If you have defined a language in the repository as your Default Language, thatDefault Language is displayed here.

2. Click OK to save your settings and close the window.

Creating w indow s for diff erent languagesA window panel can be created for any language in a specified language group or codepage. Once youhave a window object in the repository, you can create different language panels for that window.

To create window panels in different languages, take the following steps:

1. Create the window as you would in any AppBuilder application. Refer to theDevelopment Tools

Reference Gui de for information about using Window Painter to create windows.

2. Select the window in Window Painter.

MLUI

Settings





3. From the Construction Workbench, click Edit > Languages > Create Language. Only the definedrepository languages that have not yet been used for this window are displayed on the CreateLanguage menu.

The important thing to consider when creating different language panels for a window is that eachlanguage panel requires manual adjustments to the window. For instance, the text labels for the fieldsand windows have to be manually created in the new language; field sizes have to be adjusted for data ina different language; and certain window controls may be made visible or invisible. This section providesinstructions for completing the following tasks:

• Editing attributes for a specific language panel

• Understanding the Language menu

• Deleting a language panel

• Viewing a specific language panel

• Synchronizing language panels

Editing attributes for a specific language panel

At this point in the development, you have created your window following the general AppBuilder stepsoutlined in theDevelopment Tools Reference Guide , and you have opened the window with the CurrentLanguage setting of your choice. The Current Language can be set from the Workbench Opt ions window(seeSett ing the Workbench Options for MLUI).

This section discusses customizing the GUI interface for each panel:

• Edit ing window attributes

• Editing window control attributes

• Using the Visible attribute for a window control

Editing w indow attributes

To edit the window attributes, take the following steps:

1. Double-click on the face of the open window panel. Or, right-click on the window and selectProperties.

The Properties panel for that window is displayed (seeFigure 4-3).

Note Before you can create a language panel for a window, you must have that language object defined in the

repository. Refer to Defining a new language in the repository for steps on creating language objects in the

repository.





Figure 4-3 Window proper ties

2. At the very minimum, you must change the text label for the window ti tle bar. Highlight the Textfield and type the title bar text in the new language.

3. Edit the other att ributes as necessary.

Editing w indow control att ributes

To edit the window control att ributes, take the following steps:

1. Right-click on the window control and select Properties.

The Properties panel for that window control is displayed (see Figure 4-4).

2. At the very minimum, you must change the text label for the window control. Highlight the Textfield and type the text label in the new language.

3. Edit the other att ributes as necessary.

Using the Visible attribute for a window control

When you add a control to or delete a control from the base window object, AppBuilder automaticallyadds or deletes that control from all the language panels for that window. You may have an instancewhere you want the control to appear on certain language panels but not on others. To manipulate this,use the Visible attribute on the Properties panel for that window control (see Figure 4-4).





Figure 4-4 Window Control Properties panel

Highlight the Visible field and select from the drop-down list box. True makes the control visible atruntime, and False makes the control invisible at runt ime.

Understanding the Language menu

AppBuilder gives you the flexibi li ty to work with the different language panels for your window or set byusing the Language menu.

1. Highlight the window in the work area.

2. From the main menu, click Edit > Language. The fol lowing options are available from the Languagemenu:

Table 4-1 Language menu options for a window panel

Option Description

Show Default PanelDisplays the panel that is created in the Default Language. This is

your base panel from which the other language panels are created.

Show Current PanelDisplays the panel that is created in your Current Language, as it isdefined on the Workbench Options window. This option is only

visible if a window panel is created in the Current Language.

Show Language Panel

This option lists the languages in which this window or set is already

created. Select the language to display the panel for that language.

If there are languages in the repository that have not been used for

this window or set, they are not listed under this option.





Deleting a language panel

To delete a language panel, click Edit > Language > Delete Language Panel, and select the appropr iatelanguage for the language panel you are deleting.

Viewing a specific language panel

Once you have created window panels in different languages, you can easily display a specific languagefrom the Language menu. You must have already created the panel in that language. Click Edit >

Language, and do one of the following:

• To view the panel in the Default Language, click Show Default.

• To view the panel in the Current Language, click Show Current.

• To view a panel in any language that you have used, click Show Language and choose the language.Only the languages in which you have created panels display in this menu.

Synchronizing language panels

AppBuilder MLUI automatically synchronizes your language panels with the base object. Sometimes it isnecessary to synchronize the language panels that may have been created by different developers withindifferent repositories. During the synchronization process, window controls may be added, deleted, orsubstituted for other controls. To see whether or not changes will be made to the window before they are

Create Language Panel

This option lists the languages that are defined in the repository.

Select the language for which you want to create the next panel. No

more than 10 languages will display on this menu. If you want an

additional language, select the Languages... option.

Delete Language Panel This option deletes a selected language panel from the repository.

Set Language

This option gives you the ability to change the language for a

specific panel. Set Language has the same result as deleting a

language panel and creating another panel in a different language to

replace it. After using Set Language, you must edit the visual

attributes of the window panel. Set Language lists only the repository

languages that have not yet been used to create a window panel.

Verify Synchronization

(For window panels only) This option shows you what the

synchronization will do before it does it, so that you can verify

whether or not you want to synchronize at this time. See

Synchronizing language panels for more information.

Synchronize Language Panels

(For window panels only) This option synchronizes the language

panels. You should verify the synchronization before you actually

synchronize your panels. See Synchronizing language panels for

more information.

Note The MLUI menus can display up to 10 languages. To work with additional languages, selectthe menu option Languages... With a language panel active, clickEdit > Show Language Panel

> Languages... The Select Language window displays listing all the languages you haveavailable for that option.

Table 4-1 Language menu options for a window panel

Option Description



Creating sets in different languages


made, run the Veri fy Synchronization option before you run Synchronize. For more information onsynchronization, refer to Understanding language panel synchronization.

To veri fy whether or not windows will be changed during synchronization, click Edit > Language >

Verify Synchronization. A synchronization report displays indicating how many changes will be madeon each window panel.

To synchronize your window panels, click Edit > Language > Synchronize Language Panels. It isnecessary for you to review the language panels after synchronization so that you are aware of anychanges that have been made.

Creating sets in diff erent languages

You can create different display values for Lookup and Error set types for MLUI applications. You mustmanually edit the display values for each language version of a specific set. To create a set in differentlanguages, take the following steps:

1. Create the Lookup or Error set as you would in any AppBuilder application. Refer to theDevelopment Tools Reference Guide for this information.

2. Highlight the open set window in the Construction Workbench work area.

3. From the Construction Workbench, click Edit > Languages > Create Language. Only the definedrepository languages that have not yet been used for this set are displayed on the Create Languagemenu.

Table4-2 displays the menu options for a set.

Table 4-2 Language menu options for a set

Option Description

Show DefaultDisplays the set display that is created in the Default Language. This

is your base set from which the other language displays are created.

Show Current

Displays the set display that is created in your Current Language, as

it is defined on the Workbench Options window. This option is only

visible if a set display is created in the Current Language.

Show Language

This option lists the languages in which this window or set is already

created. Select the language to display the panel for that language.

If there are languages in the repository that have not been used for

this window or set, they are not listed under this option.

Create Language

This option lists the languages that are defined in the repository.

Select the language for which you want to create the next panel. No

more than 10 languages will display on this menu. If you want an

additional language, select the Languages... option.

Delete Language

This option deletes a selected language set display from the

repository.

Set Language

This option gives you the ability to change the language for a

specific set display. Set Language has the same result as deleting a

language set display and creating another set display in a different

language to replace it. After using Set Language, you must edit the

Visible attributes of the set display. Set Language lists only the

repository languages that have not yet been used to create a set

display.




Creating sets in different languages



A-1

APPENDIX

A

LANGUAGE GROUPS


This section l ists the languages that have been tested with AppBuilder MLUI. The following codepagesare listed sequentially with the languages that comprise them.

Codepage 932

• Japanese

Codepage 936

• Chinese (PRC and Singapore)

Codepage 949

• Korean

Codepage 950

• Chinese (Taiwan, Macau S.A.R., Hong Kong S.A.R.)

Codepage 1250

• Czech

• Polish

Codepage 1252

• Danish

• Dutch

• English

• French

• German

• Italian

• Portuguese• Spanish

Codepage 1253

• Greek



A-2 Language Groups



AppBuilder 2.1.0 Multi-Language User Interface Guide i

Index

INDEX


Aadd (global) 2-9attributes 2-8, 4-6

generic 2-8Visible 4-6visual 2-8, 4-5

C

client runtime2-12code generation 2-11codepage1-2, A-1Construction Workbench

menu behavior 2-3controls

editing attributes 4-6controls on an MLUI window 2-8creating language objects 4-1, 4-2creating language panels4-4creating sets in different languages 4-9Current Language 2-3, 2-4, 2-5, 2-10, 2-11, 4-4

DDefault Language 2-3, 2-4, 2-5, 2-11, 4-1, 4-2, 4-4delete (global) 2-9deleting a language panel 4-8deleting language objects 4-3developing MLUI applications2-1display values for sets 4-9dynamic menus 2-3

Eediting attributes 4-5, 4-6

editing window panels 2-9Error set 2-9

Ggeneration of code2-11generic attributes 2-8global

add 2-9, 4-6delete 2-9, 4-6

HHTML generation 2-10, 2-11

Iinstalling MLUI functionality 3-1

L

Language Editor 4-1, 4-2, 4-3language group 1-2, A-1Language menu 4-7language objects 4-5

creating 4-2defining default language 4-1, 4-2deleting 4-3modifying 4-3

language panel synchronization 2-6, 4-8Lookup set 2-9

M

menus for MLUI functionali ty 2-3migration issuespanels out of sync 2-6populate the group repository first 2-5pre-MLUI AppBuilder repositories 2-7

MLS 1-1MLUI 1-1

AppBuilder design 2-1Appbuilder products enabled for 1-2client runtime2-12code generation 2-11developing applications with 2-1installation option 3-1

menu behavior 2-3preparation 2-11Rebuild Facility 2-12window objects 2-8Workbench Options settings 2-2

modifying language objects4-3Multi-Language User Interface (MLUI) 1-1Mult iple Language Support (MLS) 1-1



O

Oobjects in the repository 4-1

Ppanel propert ies4-6panels 4-4

editing 2-9, 4-5panels for MLUI windows2-8preparation 2-11

RRebuild Facility and MLUI 2-12repositories

creating language objects 4-1, 4-2, 4-5deleting language objects 4-3migrating objects from a personal repository to a

Workgroup repository 2-5modifying language objects4-3

pre-MLUI AppBuilder 2-7runtime 2-12

SSet objects

Error 2-9Lookup 2-9

sets4-9synchronization

verifying 2-7synchronizing 2-6, 4-8

Vveri fying synchronization 2-7viewing a language panel 4-8Visible attribute4-6visual att ributes2-8, 4-6

editing 4-5, 4-6

Wwindow

attributes 2-8, 4-5controls 2-8, 4-6

manual edit of 2-9panels 2-8, 4-4

window control attributes 2-8Window Flow Diagram 2-11window objects in MLUI 2-8window properties4-6Workbench Options settings 2-2

Current Language 2-3, 2-4, 2-5, 4-4Default Language 2-3 2-4 2-5 4-4

Documents

App Build Erm Lui