IMG Home PageIMG ProductsProduct DownloadsOrdering InformationTechnical Support and Frequently Asked QuestionsDeveloper's Corner and UtilitiesAbout IMG
CustomersIMG ResellersMedia InformationIMG Events / Trade ShowsUseful LinksIMG Contact InformationIMG Information / Policies
Translate



IMG KnowledgeBase & Frequently Asked Questions

IMG Logo



Search FAQ's

Keyword Keyword Search Help
Category Type Product Version

Searching for ID: QC2010120648

QC2010120648
I'm new to IMG's Build-A-Board - what is the high-level / birds-eye view?
How do I implement a custom keyboard in my application [using Build-A-Board]?

You need the Build-A-Board Builder to create or modify layouts, change key properties/actions, and create/build the KBF (Data) file. For the Target (run-time) you need the My-T-Soft program (for the particular platform) on the run-time system. Drop in the KBF data (default KEYBOARD.KBF), and run the My-T-Soft program - the layout will be displayed to the user, and its operation will be defined by the layout properties / Key Actions (which, of course, are modifiable within Build-A-Board).

What is the Builder for?

The Build-A-Board Builder itself is just a front-end designer tool to allow you to drag & drop keys, resize, change properties, etc. It is a user-friendly front end to designing keyboard layouts. When you build, you are creating the single file KBF that can be dropped into a target system (which then contains the Keyboard layout/properties/etc.) The KBF layout is supported on Windows, Windows CE, Linux, Mac OS X, etc.

As much as possible, the implementation is a Program operating on Data concept. The Data (KBF) is created within Build-A-Board. The run-time software (deployed/implemented/installed/located) on the run-time target reads this data, displays the layout to the user, and then processes user actions based on what the user selects. The "Regular" Key Action is to create the down/up events as if a physical key was pressed. This is seen as a keystroke by the underlying application. There are other actions available, including opening a new layout (New KBF command) and running an arbitrary program (Exec command).

What are the project files? What should I open? What is PROJECT.TXT?

The project files are simple text files that describe in human readable form the layout & keyboard properties. They are an interim step towards a complete database of layouts. The zip format is just to compress & reduce disk space. If you see both a PROJECT.TXT and a zip, open the PROJECT.TXT, as this means the Project is "Open" (i.e. unzipped) and may have modifications that haven't been "zipped" up again (File | Close Project). We recommend you use the front-end display of layouts to get around the whole project file issue - just pick a layout, and go with it.

When I "F9 - Build" what am I creating? An EXE somewhere?
You are creating the KBF file (KeyBoard File). This is a singe file representation of the layout that can be used by the run-time software. Because it is now cross-platform, this is the "Data" part of the Program & Data concept (like a .DOC file contains the "document"). You "get" the keyboard you just created by loading the KBF in the run-time software. When you select a target platform, it also copies over install/run-time files - so theoretically you could take these over to the platform, install the run-time files, run the My-T-Soft binary/executable (e.g. MYTSOFT.EXE on windows) and then get the display / operation of the KEYBOARD.KBF (default KeyBoard File). For a Windows target, refer to the MSWIN32 folder (Shift-F11 to view) to see the "run-time" files - these are what gets deployed on a Windows system (and similarly for other platforms).
What is required for the target system? What does Run-time mean? How do I integrate it with my application?

Here is a quick run-down - refer below for further details, and use the Product Guide for even more details.

  1. Create or Modify a layout in the builder.
  2. Select Target in the Run-Time menu (e.g. Windows 32)
  3. Build (& execute to test)
  4. Install the Target (run-time) files on your deployment target
  5. Run My-T-Soft at a system level, or at application start (Shell/Exec/etc.)
  6. Use Developer's Kit Tools (or concepts) to move keyboard window on-screen when needed/off-screen when not
  7. Use an iterative approach to get the custom keyboard layout integrated into your application

Here is a more technical overview

  1. The approach to the user interface is to have the executable display a topmost window that presents a keyboard (or arbitrary button display) to the user. It handles input focus issues so any virtual keystrokes are seen as standard keystrokes to the application. This is the My-T-Soft program, sometimes referred to as the "Build-A-Board run-time". For example, on windows, when you run MYTSOFT.EXE it reads the KBF (KeyBoard File - KEYBOARD.KBF) and displays the layout as designed and built in Build-A-Board.
  2. The run-time software is an EXE (or program/binary process based). As such, it should be running at a system level, or at application startup (see more below)
  3. The user interface aspect is separated from the actions. All external Key Actions are handled by the MacroBat process (Macro Batch Processor). This is implemented as a separate process. So the 2 processes (My-T-Soft and MacroBat) must both be on the run-time target to read the Data (KBF file), display the layout to the user, and process the actions when a button is pressed. Note that with the CMD:EXEC any arbitrary process can be launched when the user initiates this action by pressing a button on the layout. New layouts can be opened with the CMD:NKBF command - a common approach for user control is to have a single button layout that opens the full layout, and then a minimize button that returns to the single button layout.
  4. In general, we recommend you run the keyboard (e.g. MYTSOFT.EXE in Windows) at system start, or application start - then during the life of your application, you can control access with the "MoveWindowMTS" function/concept - move it off-screen to remove it from the user, move it on-screen to display it for the user at the X/Y location you want. This keeps the process running, and you don't have any shut-down or startup delays. If done at the system level, StartUp group is typical, and if handled in the application, a Shell or Exec type function is typical.
  5. The most effective way to handle "on/off" is to move on-screen/off-screen. Using the New KBF (CMD:NKBF) the user can select different layouts. Refer to the MoveWindowMTS function (MOVEWMTS.EXE for windows, etc.) See the DEVKTDOC folder to open the Developer's Kit Documentation.

For a more detailed view & terminology, refer the Quick Usage Notes in the Product Guide.

Category: CommonType: Question/Answer Product: Build-A-BoardVersion: 2.20

Notes:



IMG Home PageIMG ProductsProduct DownloadsOrdering InformationTechnical Support and Frequently Asked QuestionsDeveloper's Corner and UtilitiesAbout IMG
CustomersIMG ResellersMedia InformationIMG Events / Trade ShowsUseful LinksIMG Contact InformationIMG Information / Policies