RBEdit User Manual
QuartzWare
Created by Ben Leinweber and Chris Perluss
Edited by Susan Hunton, Albert Lee, John Pham, Tony Tomarchio, and Tony Johansen
Version 2.0
03/09/01
Overview.................................................................................................................................................................... 3
What is a Resource
Bundle?............................................................................................................................ 3
Java Limitations of
RBEdit.............................................................................................................................. 3
Managing Files....................................................................................................................................................... 4
A Project vs. a Loose
File.................................................................................................................................. 4
Starting a New Project.................................................................................................................................. 6
Starting from Scratch.......................................................................................................................................... 6
Starting with an
existing Root........................................................................................................................... 9
Loading Files......................................................................................................................................................... 13
Loading an existing
Project............................................................................................................................. 13
Loading a Loose File........................................................................................................................................ 15
Saving Files............................................................................................................................................................ 16
Saving the Project.............................................................................................................................................. 16
Saving the Project as a
different name........................................................................................................... 17
Saving a Loose File........................................................................................................................................... 18
Working with the files
of a Project......................................................................................................... 18
Adding a new Bundle
into the Project........................................................................................................... 18
Loading an existing
Bundle into the Project................................................................................................ 20
Removing a Bundle from
the Project.............................................................................................................. 21
Closing Files.......................................................................................................................................................... 23
Closing a Project............................................................................................................................................... 23
Closing a Loose File......................................................................................................................................... 24
Using the Application Window................................................................................................................. 24
The Toolbar.......................................................................................................................................................... 26
The Project Window......................................................................................................................................... 27
The Editor Windows.......................................................................................................................................... 28
Working with Entries........................................................................................................................................ 30
Searching............................................................................................................................................................ 37
Undoing and Redoing....................................................................................................................................... 38
Manipulating text.............................................................................................................................................. 38
Viewing/Hiding the
Fields............................................................................................................................... 39
The Easy Tabs........................................................................................................................................................ 40
The Data Types of a Key.................................................................................................................................. 40
StringVal ............................................................................................................................................................. 41
StringArray ....................................................................................................................................................... 41
BinaryPath .......................................................................................................................................................... 45
Message ................................................................................................................................................................. 45
BinaryVal ............................................................................................................................................................ 49
IntVal .................................................................................................................................................................... 49
IntArray .............................................................................................................................................................. 49
ObjectVal............................................................................................................................................................... 49
TaggedArray........................................................................................................................................................ 49
Miscellaneous Features............................................................................................................................... 50
Setting Preferences.......................................................................................................................................... 50
Working with the
Windows.......................................................................................................................... 52
Getting Help......................................................................................................................................................... 53
Overview
In today’s world of global commerce it is increasingly important to get a product out to as many people as possible. Limiting a product to just one language can severely limit the potential market for it. This is true even in the computer industry. While lots of people who work with computers are competent with English, users are much more likely to be comfortable with a program that is in their own language.
Java helps fix this problem by introducing the idea of internationalization. Internationalization uses resource bundles as an easy way for users to switch your software from one language to the next. A program detects which location, or “locale”, the user has set in their system settings and then loads the appropriate resource bundle that contains the proper strings and other types of data appropriate for that region. Unfortunately, creating and editing these huge resource bundles can be a huge problem, especially to a translator who has minimal programming skills. That’s where this program comes in.
QuartzWare RBEdit, the Java Resource Bundle Editor, makes creating and editing resource bundles simple by providing a simple user interface and creating the resource bundles for the user. It can manage all of the resource bundles together in one project so that a translator never has to actually look at a resource bundle. This means less time required for training translators, and also makes the job of anyone, including the programmer, who has to work with Java resource bundles a lot easier.
What is a Resource Bundle?
Please see the ISO-639 and ISO-3166 standards for further information on the naming conventions.
The Child Bundles Resource Bundles only contain the data that is different from their parents’ data. Once the root has been translated into the correct language, all a program has to do is figure out which country it’s in and make a call to the corresponding Resource Bundle.
The idea behind a Resource Bundle is that the program will request data from a Resource Bundle using a key. If that key does not exist in that specific Resource Bundle then the program will look at the Resource Bundle’s parent for the data. This way, a Bundle Resource Bundle only needs to save data that is different from its parent’s data.
Java Limitations of RBEdit
RBEdit works best when using version 1.3 of Java.
Managing Files
In this section, we will talk about what files are involved in a resource bundle project, and how QuartzWare RBEdit manages these files.
A Project vs. a Loose File
The idea behind resource bundles is that there is one file for every language and variation on a language. A project is a collection of all the files that make up the resource bundles for one particular program. A project file is created which contains a list of all of the other files in the project, as well as any preferences for that project. This way, when you load a project, the program automatically loads all of the other resource bundle files in. A project file has the same name as the root of the Resource Bundle, but it has an extension of ‘rbp’.
Sometimes an entire project is not available and you may wish to work with an
individual Resource Bundle. This is
what is known as a loose file, since
it isn’t attached with the project currently loaded. While loose files can be edited in QuartzWare RBEdit, severe
restrictions on editing will be in place.
For instance, you will not be able to add a new key or delete a key from
a loose file unless it is itself a root.
This is so any Bundle Resource Bundles will not become out of sync with
their parents. (Please refer to ‘Loading an existing Project’ on page 13 for a detailed list of restrictions.)
In this example, the current Project is named “RBEdit” and the Loose File is named “LooseFile”
Notice that the Loose File does not show up in the Project Window
Starting a New Project
A new project can be started in two ways:
- A new Root Resource Bundle must be created.
- A Root Resource Bundle is already present and is brought into the new project.
Below, we further describe these two options.
Starting from Scratch
To create a completely new project, you need to start the project from scratch.
To start a new
project from scratch:
1. Select ‘New Project…’ from the ‘File’ menu
2. Click on ‘Create New Root’
3. Name your root file whatever you wish by typing the name in File Name field.
4. Select the ‘File Type’ for your Resource Bundles*
5.
Click ‘OK’ to create the Project with the Root
A Project File is always given a “rbp” extension. The File Type is for the Resource Bundles that you add will be set by the File Name field. If you do not put an extension on your File Name it will default to a properties file. At this time property files and java files are the only two formats that are supported. The user should be aware that the files in a project don’t have to be the same file type.
The Project Window will now pop up in the Main Window with only an empty Root Resource Bundle.
Note: When opening a new Project, if there is a Project already loaded, then a dialogue box will pop up asking if you wish to save. Whatever name you choose in the Save project dialogue will be used as the base name for the Project File. The Child Bundles will use the names that you choose when you first imported or created them.
Starting with an existing Root
If you have already started the project outside of RBEdit, but would like to continue the project in RBEdit, you need to start a project and import your existing root.
To start a new
project based off of existing files:
1. Select ‘New Project…’ from the ‘File’ menu
2. Click on ‘Use Existing Root’
3. Find the Root you wish to import and click on ‘OK’
4.
A dialogue will appear asking to enter the root’s file name. Enter your desired name for the root and
click ‘OK’.
5. Load any previously created Child Bundles files that go with that Root (refer to Import Bundle)
The Project Window will now pop up in the Main Window with only an empty Root Resource Bundle.
Note: When opening a
new Project, if there is a Project already loaded, then a dialogue box will pop
up asking if you wish to save. Whatever
name you choose in the Save project dialogue will be used as the base name for
the Project File. The Child Bundles will use the names that you choose when you
first imported or created them.
Loading Files
Loading an existing Project
To load an existing
Project:
1. Select ‘Open Project’ from the’ File’ menu
2. Find the Project File for the Project that you wish to load. (Remember that Project files have the extension RBP)
3.
Click Open to load it into the Resource Editor
If there is a Project already loaded, then a dialogue box will pop up asking you if you wish to save. The program will automatically load all the Resource Bundles listed in the Project that you load. If any Resource Bundles are missing, a warning message will pop up telling you a file or files are missing and will ask if you wish to continue(Not Implemented).
If the Root is missing then the following restrictions are placed on the Project(Not Implemented)
- No Keys may be added or deleted or renamed.
- The parent value may not be displayed correctly in a Bundle if a parent is missing (an error message will be displayed instead)
- New Resource Bundles may not be added to the Project
If a Bundle is missing then the following restrictions are placed on the Project(Not Implemented)
· The parent value may not be displayed correctly in a Bundle if a parent is missing (an error message will be displayed instead)
· New Resource Bundles may not be added to the Project under the missing Bundle
· The files that are missing will be grayed out in the Project Window. You will not be able to open them.
This is done to keep the Child Bundles and the Root from becoming out of sync with each other. For instance, if you added a key to the Bundle when the root was missing, the root would not get that key, and they would become out of sync.
Loading a Loose File
See ‘A Project vs. a Loose File’ on page 3 for a description of a Loose File.
To load a Loose File:
1. Select ‘Open’ from the ‘File’ menu
2. Find the Loose File that you wish to load
3.
Click Open to load it
*NOTE: The following restrictions are in place on a Loose File:
- Does not show up in the project window (but does show up in the Easy Tabs)
- Cannot add or delete a Key
- Cannot see Parent Value
- Cannot modify Key names
Saving Files
Saving the Project
To save your project:
- Click on the Project Window or any Editor Window of a Bundle in the Project to bring it into focus (Don’t have a Loose File in focus)
-
Select ‘Save’ from the ‘File’ menu
Saving the Project as a different name
To save your project
using a different base name:
1. Click on the Project Window or any Editor Window of a Bundle in the Project to bring it into focus (Don’t have a Loose File in focus)
2. Select ‘Save Project As…’ from the ‘File’ menu
3. Type in a new name for the Project
4. Enter the name of the new project to be saved
5.
Click ‘Save’
The Project File using the new name for the Project. The names for the bundles however will remain the same however. The previously saved version of the Project File will not be changed. If this process will cause any files to be overwritten, a warning message will appear first. The only time this might happen is if you have two projects in the same directory and you try to save the first using the name of the second.
Saving a Loose File
See ‘A Project vs. a Loose File’ on page 3 for a description of a Loose File.
To save a Loose File:
1. Make sure that the Loose File you wish to save is in focus (click on it’s editor window to put it in focus)
2. Select ‘Save’ from the ‘File’ menu
Working with the files of a Project
Adding a new Bundle into the Project
To create a new
Bundle for the Project (Must have a project currently open):
1. Select the Bundle you would like to make the new Bundle a child of.
2. Select ‘New Bundle’ from the ‘Project menu’
3. The Local settings are taken from the Bundle you selected from step one. Set or change the Language, Country, and/or Variant if desired. The Language is required, but the Country and Variant are optional.
4.
Enter a File Name for the bundle, with extension.(Properties file is default)
5.
Click ‘OK’
Note: If the specified Language/Country/Variant combination already exists, an
error message will pop up.
The New Bundle will automatically be inserted into the Project Window under the appropriate parent.
The new Bundle will have the name the user specified and will be the one that the file is saved as when the project is saved.
You may type in your own values for the Language, but there is no error checking against known languages. So feel free to make up your own language, but be careful!
Loading an existing Bundle into the Project (Not Implemented)
To add an existing Bundle to the Project:
1. Select the Bundle you would like to make the new Bundle a child of.
2. Select ‘Import Bundle’ from the ‘Project’ menu
3. Find the existing file for the Resource Bundle you wish to add and click ‘Open’
4. The Local settings are taken from the Bundle you selected from step one. Set or change the Language, Country, and/or Variant if desired. The Language is required, but the Country and Variant are optional.
5. Click Ok.
As above when adding a New Bundle, adding and Existing Bundle will
automatically insert the new Bundle into the Project Window in the appropriate
place. The new Bundle’s file is not created until the next time the Project is
saved. If a Bundle has a key that the
root does not then a dialogue box will pop up with the following options:
Removing a Bundle From the Project
To remove a Bundle from the Project:
1. Select the Bundle in the Project Window that needs to be removed from the Project
2. Select ‘Remove Bundle’ from the ‘Project’ menu
3.
A warning message will pop up. Click
Yes
Warning! Removing a Bundle will also remove all of its Children. For example, removing “ResourceBundle_en” will also remove “ResourceBundle_en_US”. The files are not deleted, but they are removed from the project. Any changes made to them since the last time the project was saved will be lost. You may not remove the Root.
Closing Files
Closing a Project
To close a Project:
1. Make sure that any file in a project has focus (See Saving the Project)
2. Select ‘Close’ from the ‘File’ menu
A message will pop up asking if you wish to save the Project. Click ‘Yes’ to save it or ‘No’ to discard
changes.
Closing a Loose File
See ‘A Project vs. a Loose File’ on page 4 for a description of a Loose File.
To close a Loose File:
1. Make sure that the Loose file you wish to close has focus (See Saving a Loose File)
2. Select ‘Close’ from the ‘File’ menu
A message will pop up asking if you wish to save the Loose File. Click ‘Yes’ to save it or ‘No’ to discard changes.
Using the Application Window
The Application Window refers to the main window and all of its parts. This section basically describes how all of the windows in the program work. Below is a picture of the Application Window naming all of the parts that are described in this section:
The Toolbar
The Toolbar contains shortcuts to various functions that our program supports. The functions supported are explained here:
|
|
Create a new project. See ‘Starting a New Project’ on page 6. |
|
|
Open a project. See ‘Loading an existing Project’ on page 13. |
|
|
Save a project or Loose File. See on page 16. |
|
|
Cut selected text. Used when editing a simple data type. (Not Implemented) |
|
|
|
|
|
Paste text from the clipboard. Used when editing a simple data type. (Not Implemented) |
|
|
Bring up the help dialog. See Getting Help on page 53. |
The Project Window
The Project Window contains a listing of the files in your project in a tree format. Each icon in the Project Window represents one Resource Bundle file. Child Bundles are stored on a branch below their parents, and of course the Root is at the top. Double click on a file to display it in an Editor Window. Right click in the Project Window to bring up a Pop-Up menu (displayed below). To collapse a branch, single click on the ‘Opened Node’ sign next to it. To expand a collapsed branch, single click on the ‘Closed Node’ sign next to it.
Context Menu: (Not Implemented)
See ‘Adding a new Bundle into the Project’ and ‘
Removing a Bundle From the Project’ for Add Bundle and Remove Bundle. See ‘Working with Entries’ for Add Key.
NOTE: You may not close the Project Window, but you may minimize it. The Project Window is always accessible from the Easy Tabs bar.
Key, Value, ParentValue, and comments fields
The Editor
Windows
|
Key, Value, ParentValue, and comments fields |
An Editor Window allows both display and modification of a given resource bundle. The Editor Window has four columns: Key, Value, Parent Value, and Comments. One row in the editor window is called an Entry. Each entry, therefore, has one Key, one Value, one Parent Value (if it is not the Parent), and one block of comments. Right clicking brings up the following Pop-Up menu:
Rename Key (Not Implemented)
Explanations of these functions can be found in the sections following.
Working with Entries
In order to add a new
key, either:
· Select ‘New Key’ from the ‘Edit’ menu
· Right click on an Editor Window to bring up a Pop-Up menu, then select ‘New Key’
·
Click
the ‘New Key’ Icon on the Toolbar.
A dialogue box will pop up allowing the user to type in the name of the new key
and select the data type for the new key.
See ‘The Data Types
of a Key’ on page 41.
If working with a Loose File (See A Project vs. a Loose File on page 4) then you will not be able to add a new key.
In order to delete a
key, select an entry in an editor window, then either:
· Select ‘Delete Key’ from the ‘Edit’ menu
· Right click on the selected entry to bring up a Pop-Up menu, then select ‘Delete Key’
·
Click the ‘Delete Key’ Icon on the Toolbar.
When you try to delete a key, a dialogue box will pop up asking if you are sure. Click ‘Yes’ to delete the key, or ‘Cancel’ to keep the key. If working with a Loose File, you will not be able to delete a key. See A Project vs. a Loose File on page 4
In order to modify
the name of a Key, then either: (Not Implemented)
- Select ‘Rename Key’ from the ‘Edit’ menu
- Right click on the selected entry in an Editor Window to bring up a Pop-Up menu, then select ‘Rename Key’
You will be able to type the new key in like when you are editing a comment. A warning message will pop up asking if you are sure you wish to change the Key. Click ‘Yes’ to confirm the Change or ‘No’ to revert it back.
Renaming a Key should be done with great caution. This feature is included to allow the correction of typos in the name of a Key. Any time the Key is changed, it will be changed in ALL files, including the root and every Bundle in the project.
In order to modify a
value or comment, select an entry in an editor window, then either:
· Select ‘Edit Value’ or ‘Edit Comments’ from the ‘Edit’ menu
· Double click on the Value or Comments field in the Editor Window of the Entry you wish to edit.
·
Right
click on the selected entry to bring up a Pop-Up menu, then select ‘Edit Value’ or ‘Edit Comments’
·
Click the ‘Edit Value’ or ‘Edit Comments’
button on the toolbar
Normally, when you edit a value, you will just type in a new value right into the field in the editor window like a spreadsheet program. However, some Data Types have dialog boxes associated with them to help you edit the value. If this is the case then editing the value causes that dialog box to pop up. See ‘The Data Types of a Key’ on page 41 for a complete explanation of data types and their associated dialog boxes.
Searching (Not Implemented)
[Note: Find has not been implemented at this time]
Selecting ‘Find’ from the ‘Edit’ menu will bring up a Find Dialog. The Find Dialog has a number of options. ‘Search All Resource Bundles’ will search through all files in the current project. If this option is turned off, only the currently active window will be searched. You may select which columns (Keys, Values, and/or Comments) will be searched in a Resource Bundle. By default all columns will be searched, but simply de-select ‘Search Keys’, ‘Search Values’, or ‘Search Comments’ if you wish to narrow the scope of the search.
When a word matching the search parameters is found, that word will be highlighted in the Editor Window. The user may make any edits desired by clicking on the window that the word was found in. If the word found is not the specific word desired, then click on ‘Find Next’ to get the next match.
Undoing and Redoing (Not Implemented)
QuartzWare RBEdit supports one undo and redo function per editor window. Selecting Undo from the ‘Edit’ menu will change the last value modified to its previous value. Selecting Redo from the ‘Edit’ menu will change the value back (as if you had never pressed ‘Undo’ in the first place).
[Note: Undo and Redo have not been implemented at this time]
Manipulating text (Not Implemented)
The cut, copy, and paste features are available when editing the value of a Simple Data Type (See ‘The Data Types of a Key’ on page 41) or comment of any type of entry.
Viewing/Hiding the Fields (Not Implemented)
From time to time, you may want to only be looking at one or two of the Key, Value, Parent Value, or comments fields instead of all four. RBEdit makes this easy to do. Simply right click in the Editor Window and a Pop-up menu will appear. You can also find it in the ‘View’ menu. To hide a field that is showing, simply uncheck (by clicking on) the field that you wish to hide. To show that field again, bring up the menu and check it again.
NOTE: When working with the Root, the Parent Value field is never displayed.
The Easy Tabs
The Easy Tabs work similar to the Microsoft Windows’ Taskbar, and they are a simple way to keep track of your work. It contains a Tab for each Editor Window that is open (including the Loose Files) plus the Project Window. If a tab is selected, the associated window will become the active window. If the associated window is minimized, it will be restored, as well as placed on top of any windows that might have been covering it up.
Here’s a picture of the main window. Notice how the active window corresponds to the selected tab.
The Data Types of a Key
Every key has a specific Data Type associated with it. This Data Type can be a string, a picture or any of the several other data types explained in this section. The Data Type of an Entry is set upon the creation of a new key. See ‘Working with Entries’ on page 30. This section explains the available Data Types, and how to edit each Data Type. A Simple Data Type refers to a Data Type that does not need it’s own dialog box. A Complex Data Type refers to a Data Type that requires a dialog box to edit it’s value. With a Simple Data Type, the value that is displayed in the Editor Window is obvious, but the values displayed for Complex Data Types need a little explanation. This explanation is found below.
StringVal
This Data Type is a Simple Data Type and is probably the most common data type to use and will be selected by default in the ‘New Key’ dialog box. This type contains a normal string of text that is valid under Java’s String type.
To Edit a StringVal Type
·
Edit normally as described in ‘Working with Entries’ on page 30.
StringArray
(Not Implemented)
This is a Complex Data Type that allows you to store an array of Strings as described above. The number of entries is set by the Root. In the Root dialog box you may add or remove entries in the StringArray as well as modify existing values. When editing a StringArray in a Bundle ( with the exception of the root bundle) , you may only modify existing values, and the Add and Remove buttons will be disabled.
The Value that is displayed in the Editor Window is the elements of the array separated by a comma
[Show a picture of an array display]
NOTE: When editing the root, the parent String List will be empty.
To Add strings to a StringArray Type
1. Open up the Root file in an Editor Window. You may only add strings to the root.
2. Bring up the StringArray Dialog box by the various methods described in ‘Working with Entries’ on page 30.
3. Click on Add. This will add a new entry to the bottom of the list and will automatically be editing the new entry.
4. Edit the String much like you would in the normal Editor Window. Press ‘Enter’ or click outside of the text box to stop editing.
5. You may add as many strings as you wish or perform other actions in the dialog box.
6. Click ‘OK’ to save the changes to the list or ‘Cancel’ to disregard changes to the list.
To Remove strings from a StringArray
- Open up the Root file in an Editor Window. You may only remove strings from the Root.
- Bring up the StringArray Dialog box by the various methods described in ‘Working with Entries’ on page 30.
- Select an entry in the list by single clicking on it.
- Click ‘Remove’. A confirmation box will pop up. Click ‘Yes’ to confirm or ‘No’ to cancel.
- You may remove as many strings as you wish or perform other actions in the dialog box.
-
Click ‘OK’ to save the changes to the list or ‘Cancel’ to disregard changes to the list.
To Move a String Up or Down in the Array
- Open up the Root file in an Editor Window. You may only move a String in the Root.
- Bring up the StringArray Dialog box by the various methods described in ‘Working with Entries’ on page 30.
- Select an entry in the list by single clicking on it.
- Click the up arrow or the down arrow. This will swap the selected String with the String immediately above it or below it.
- You may move as many strings as you wish or perform other actions in the dialog box.
-
Click ‘OK’ to save the changes to the list or ‘Cancel’ to disregard changes to the list.
Note: Moving a String in the Root this way also moves all of the Strings in the Child Bundles so that none of the translations will get out of sync with each other. This is similar to not being able to add or remove a Key from a Loose File.
To Edit a string in a
StringArray Type
- Open up the Root file in an Editor Window. You may only remove strings from the root.
- Bring up the StringArray Dialog box by the various methods described in ‘Working with Entries’ on page 30.
- Select an Entry and click ‘Modify’ or double-click an entry. You will be able to edit entry much like you would in a spreadsheet or a normal Editor Window.
- Type in the new text for the string.
- You may modify as many strings as you wish.
- Click ‘OK’ to save the changes to the list or ‘Cancel’ to disregard changes to the list.
BinaryFile
This is a Complex Data Type that contains a special string that is a path to a binary file such as a JPEG, MOV, or any other binary data. For this Data Type to be used effectively, the user should only use one type of file per key (that is, if the root points to a JPEG, all of the other languages should also point to a JPEG). The programmer must know what kind of data it is, or be able to detect the type of data it is before it can be used. This information is not stored in the Resource Bundle.
The Value displayed in the Editor Window is the Path and Filename of the file that is selected.
To Edit a BinaryFile
Type
1. Bring up the BinaryFile Dialog box by the various methods described in ‘Working with Entries’ on page 30.
2.
The
BinaryFile Dialog box looks much like the normal Load File Dialog box. Select the file you wish to point to.
3. If the file does not yet exist, but will in the future, merely type in the path and file name in the File Name box.
4. Click ‘Open’. If the file that you selected does not exist, a warning message will pop up.
Message (Not Implemented)
The Message Type is a Complex Data Type and is the most complicated Data Type provided in RBEdit. Messages are a concatenation of Strings and other data (called Elements) in a language neutral way. Messages assemble a String from various fragments of data such as text, dates, numbers, etc.
The Value displayed in the Editor Window is the Full Message described below.
To Edit a Message Type
1. Bring up the Message Dialog box by the various methods described in ‘Working with Entries’ on page 30.
2. Enter text, dates, numbers, and choices into the ‘Full Message’ field (see below for specifics). Dates, numbers, and choices are collectively referred to as “Elements” in the succeeding paragraphs.
3. You may click the ‘Test’ button to see an example message using your formatting.
4. Click ‘OK’ to save the message or click ‘Cancel’ to discard changes to the message
To Add a New Time or Date to the ‘Full Message’ field
1. Click the ‘New Element’ button.
2. Type ‘{’ at the position in the ‘Full Message’ field where the date should appear.
3. After the ‘{‘, type in the number in the ‘Message Element Number’ drop down menu, followed by a comma. This number appeared in the ‘Message Element Number’ drop down menu after the ‘New Element’ button was pressed in step 1.
4. Type the word ‘time’ or the word ‘date’ followed by another comma.
5. Type either ‘short’, ‘medium’, ‘long’, or ‘full’ followed by ‘}’ to finish off the date or time element.
To Add a New Number to the ‘Full Message’ field
1. Click the ‘New Element’ button.
2. Type ‘{’ at the position in the ‘Full Message’ field where the date should appear.
3. After the ‘{‘, type in the number in the ‘Message Element Number’ drop down menu, followed by a comma. This number appeared in the ‘Message Element Number’ drop down menu after the ‘New Element’ button was pressed in step 1.
4. Type the word ‘number’ followed by another comma.
5. Type either ‘integer’, ‘currency’, or ‘percent’ followed by ‘}’ to finish off the number element.
To Add a New Choice to the ‘Full Message’ field
1. Click the ‘New Element’ button.
2. Check ‘Use Choice Format’.
3. Next, set the limits for your choice, as well as the value that goes within each limit.
4. For each limit, enter the upper bound into the "limit bound field", the value into the "Element Value" field, and select either "# Limit Value", "< Limit Value" or "> Limit Value". If you wish to use another choice instead of a string as the element value, click the 'Edit as Choice' button. Click the 'New Limit' button to add this limit to the list.
To Remove an Element from the Message
- Select the element in the 'Message Element Number' drop down menu.
- Click the 'Remove Element' button.
- Modify the text in the ‘Full Message’ field so that the message still makes sense. (Remove all of the elements of the number that you just deleted from Full Message)
BinaryVal (Not Implemented)
This is a Simple Data Type that contains a binary value entered in hex. This is implemented as an array of bytes of unspecified length.
To Load and Edit a Binary File into the Resource Bundle
·
Edit normally as described in ‘Working with Entries’ on page 30.
IntVal
This is a Simple Data Type that allows you to store an Integer as defined by Java.
To Edit a StringVal Type
·
Edit normally as described in ‘Working with Entries’ on page 30.
IntArray (Not Implemented)
This Complex Data Type works like a cross between IntVal and StringArray. You will only be able to enter in integers, but other than that, everything works exactly like a StringArray. Please see StringArray for details of how to edit.
ObjectVal
This is a Simple Data type that allows you to store the instantiation of a Java Object. In this type the user actually types in the line of code to instantiate a class. An example is provided in the picture below.
This example is the code to instantiate a new JFrame titled “Help Dialog”.
To Edit an ObjectVal Type
·
Edit normally as described in ‘Working with Entries’ on page 30.
TaggedArray (Not Implemented)
Miscellaneous Features
Setting Preferences (Not Implemented)
There are a few options that can be set in RBEdit. The preferences dialogue box allows you to set these options. [Note: Preferences have not been implemented at this time]
To display the
Preferences dialogue:
1.
Select Preferences from the ‘Project’ menu
Here are what the various options mean:
Unchanged Values/Changed Values: These options will allow you to select the colors for your changed and unchanged values. Background refers to the background color of an entry, and foreground refers to the text color of an entry. RBEdit allows you to have different colors for values that have been change from their parent values to easily locate what still needs to be completed. ‘Unchanged Values’ are those values which are the same as their parents and have yet to be edited/translated. ‘Changed Values’ are those that have been translated and changed from their parent. To change a color, simply click on the box and a color picker will appear.
Write escaped characters: Some systems cannot display all of the Unicode characters. This option outputs escaped characters instead of Unicode. An escaped character is just the two bytes that make up a Unicode character preceded by a ‘\U’. So it will look like this: ‘\U0032’
List Keys Alphabetically: Normally the keys are listed in the order that they are created in. This list the keys alphabetically.
Default Visible Fields: Whenever a new Editor Window is opened normally all the fields are visible. If you wish a specific field to not be visible when a new Editor Window is opened then uncheck the appropriate check box.
Working with the Windows
QuartzWare made the RBEdit interface as standard as possible. Merely clicking on the ‘X’ in the upper right hand corner can close editor Windows. They may also be minimized and maximized as normal.
The ‘Windows’ menu also adds these fairly standard features:
·
Cascade Windows – Cascades all of the open windows that
are not minimized with the window currently in focus on top . (Not
Implemented)
· Tile Horizontally – Uses all of the application space to tile all of the open windows that are not minimized on top of each other with the window currently in focus on top. (Not Implemented)
· Tile Vertically – Uses all of the application space to tile all of the open windows not minimized next to each other with the window currently in focus on the left. (Not Implemented)
·
Access to every Resource Bundle that is open in an Editor Window
QuartzWare RBEdit also has one other windows feature that is not quite so standard but can be very useful. See ‘The Easy Tabs’ on page 40.
Getting Help
There is online documentation available in the program. It is a HTML representation of this user manual.
To access the online
documentation:
1. Select Help Topics from the ‘Help’ menu.
Document Version
Control:
Tony Johansen made the following
changes to the document:
·
Read through
entire document and fixed any errors.
2. Start New Project with Existing Root jpeg
3. Load Loose File Menu jpeg
4. New Bundle Menu jpeg
5. Import Bundle Menu jpeg
6. Import Bundle Dialog jpeg
7. Remove bundle jpeg
8. Close Menu jpeg
9. Screenshots for edit value procedure
10. Find menu jpeg
11. Find Dialog Box jpeg
12. Easy Tabs Screenshot
13. Message Editor Dialog Box
14. Preference Dialog Box jpeg
15. Windows menu jpeg
1. Updated Project Window Section
2. Updated Closing File/ Closing Project Procedure
3. Changed all ‘Child’ to ‘Bundle’
·
Added ObjectVal section
·
Added TaggedArray section, but did not fill it in yet.
·
Gave the warning about Java 1.3 it’s own Subheading
·
Put in warning in ‘Create New Bundle’ that says that if
you type in your own locale name, there is no error checking.
·
Added icons next to each of the Data Type names.
11/28/00 Ver 1.4a
Ben made the following changes to the document:
· Added in warning about using lower versions than 1.3 of Java in 'Overview'
· Replaced as many pictures as posible with snapshots of the real working UI. The following is a list of pictures that have not been replaced due to conditions out of my control. Notes have been placed next to all of them:
· Pg. 8-10 ‘Save Project’, ‘Open Project’, ‘Open’, ‘Import Root’ are not to spec yet.
· Pg. 11 ‘New Bundle’ needs values coded into it.
· Pg. 14 Popup Window not yet implemented
· Did not do beyond page 14.
· Note that the UI was being worked on while this document was being edited, so that there are some buttons and other such things missing in the earlier pictures. The missing features have no effect on the explanation that accompanies the picture though.
· Added explanation of toolbar in the ‘Application Window’
Susan ran spell check on the document.
Ben and Susan worked together to thoroughly QA the document and found many errors. Susan started making changes to the document before Ben was finished checking his section of the manual.
Susan made the following changes to the document:
· Small edit in the ‘Overview’
· Added a cross-reference to list of restrictions in ‘A Project vs. a Loose File’
· Added short explanation under ‘Starting a New Project’
· Made some small changes to ‘Starting from Scratch’ and ‘Starting with an existing Root’ instructions
· Changed ‘Starting from an existing Root’ to ‘Starting with an existing Root’
· Copied explanation at the bottom of ‘Starting a new Project’ to in between ‘Starting from an existing Root’ and ‘Starting with an existing Root’
Ben made the following changes to the document:
· In ‘Loading an existing Project’ made separate lists of restrictions on a Project when a Bundle is missing and when a Root is missing
· Added list of restrictions to a ‘Loading a Loose File’
· Made the explanation of ‘Saving the Project’
· Rewrote instructions for ‘Adding a new Bundle into the Project’ to include explanation of Country and Variant.
· In ‘Loading an existing Bundle into the Project’ Clarified what happens in Add Bundle if the Resource Bundle loading in was not properly named. Also clarified the following explanation.
· In ‘The Project Window’ specified that the picture of the Pop-Up menu was the one described in the proceeding paragraph
· Moved ‘Undoing and Redoing’ and ‘Manipulating text’ into a better location in ‘The Editor Windows’ section.
· Specified that the parent value is not shown in the Root Editor Window in ‘Viewing/Hiding the Fields’
· Changed a spec according to George’s wishes. An Entry is gray (by default) until it has been changed.
· Changed ‘Search Dialog’ to ‘Find Dialog’ under ‘Searching’
· Defined the difference between Simple Data Types and Complex Data Types
· Explained what value is displayed in the Editor Window for each Complex Data Type
· Specified that when editing a StringArray in the Root, the Parent Value list will be empty
· Changed the BinaryVal back to a Simple Data Type as per George’s request.
· Finally updated the fact that the ‘Preferences’ dialog is in the ‘Project’ menu and not the non-existent ‘Tools’ menu.
Ben made the following changes to the document:
· Added in the rest of the pictures except for Toolbar, and icons for data types
· Added in the ‘Choice’ explanation that Chris wrote a long time ago but never got put into the manual
Ben made the following changes to the document:
·
Added in ‘Viewing/Hiding fields’ for the Editor Window
·
Added in more pictures. Just a few more to make and insert.
·
Added in preferences explanation (finally!)
Ben made the following changes to the document:
· Spent 5 hours adding all the pictures to this document and making the necessary changes to the text. There are far too many to list here.
Ben made the following changes (FTR Means that it was a suggestion received in our FTR):
· Minor grammatical changes to entire document
· FTR: Redid the “What is a Resource Bundle” section from the “2. Bundle” part on.
· FTR: Replaced all bullets that indicated steps in a process with numbers to distinguish them from a bulleted unordered list
·
FTR: Put in a
note under “A Project vs. a Loose File” that a diagram should be made in order
to further explain the difference between a Loose File and a Project.
·
Changed ‘project files’ to ‘Child Bundles files’ under
“Starting from an existing root.”
·
Updated “Loading an existing project” by specifying
what happens when the root or a Bundle is missing
·
Updated the restrictions placed on a Loose File
·
Added a new section titled “The Data Types of a Key”
·
Changed “Working with Entries” to reflect the previous
change.
·
Removed the “Testing” section from Misc. Features since
that will now be covered under “The Data Types of a Key”
·
FTR: Fixed
Cross Reference problem under “Working with the Windows”
·
FTR: Added
comment on “out of sync” in Loading a Project File
Ben made the following changes:
· Some minor grammatical changes to the Overview to make it less ambiguous
· Added a couple of sentences under “To Save Your Project:”
· Redid that intro to the Editor Windows
· Updated searching section to describe how the results of a find will be displayed