Part of the My-T-Soft® family, Build-A-Board is a suite of utilities that provide tools to create and operate on-screen keyboards, panels, and buttons for creating user interfaces that provide optimal interaction while offering secure levels of operator / user input control. These enhancements allow touchscreen, hand-held, wearable, wireless, ruggedized, tablet and pen-based computer users to operate these systems without the need for a physical keyboard. This results in space saving; reduced hardware costs; quick & low-cost user-training; cleaner machine interfaces; better security; allows enhanced enabling of legacy equipment retrofits; and provides a realization of new & innovative approaches for computer users.
With Build-A-Board, keys, buttons, and panels can be customized as desired, whether to control access, or sized to permit accurate entry even with large gloved hands. Unlike high-level environments and single purpose applications, the native, system-level run-time program can interoperate across all applications. Beyond keyboards, the potential is endless: A complete user interface can be built as a front end to legacy terminal based operations, as an augmentative solution for a disabled individual, or as a custom touchscreen based controller, etc., etc.
Build-A-Board is the evolving culmination of years of experience working with the needs of system providers & their use of IMG's successful My-T-Soft® family of on-screen keyboards. Developed to meet the needs of manufacturers, integrators, developers, and end-users of touchscreen & pen-based systems, it is the Ultimate Tool for anyone with a need for virtual on-screen keyboards & keypads.
Ready to get started? See this tech item: What do I need to do to get started?
Original ID: QC225140
Yes. Build-A-Board kbf's (keyboard files) can be used in IMG's OnScreen, My-T-Mouse, My-T-Pen, My-T-Soft, and My-T-Touch products. If you don't have any of these, you can also create a run-time (lite) version of My-T-Soft from within Build-A-Board for Win CE thru thru Windows 7 (including Embedded) to use your layouts.
Original ID: QC225141
The Run-Time files are used on the Target system, which is often different than the development system. For example, if you are developing several keyboard layouts for a Windows CE unit with a MIPS processor, your Run-Time files target would be Windows CE - MIPS. The Run-Time files are licensed separately from Build-A-Board (since they may be placed on 1 or 100 or 10,000 systems). The Build-A-Board Builder (development environment for the keyboard layouts) is the tool used to create, design, modify, and manage keyboard layout files & select different Run-Time targets based on your needs.
Typically a customer would need only 1 or 2 Build-A-Board licenses, since only the developer, integrator, or IT department would be customizing a board or boards. Once it comes to deployment, a license for each run-time system running the keyboard layouts is required.
With the release of the 2.20 version and support for Mac OS X and Linux, platform licenses are offered that address different deployment options based on locations, number of employees, and platforms needed. All of the platform license options do not have unit based licenses, as deployed run-times are already licensed and royalty-free. Refer to Build-A-Board Standard (Cat. #12402), Single-site (Cat. #12415), Multi-Site (Cat. #12416), Enterprise (Cat. #12417), and Global Enterprise (Cat. #12418). Contact IMG Sales for further details.
For small roll-outs, as an example, if you have 8 forklifts with panel mount touchscreen systems, and need numbers, tab, enter, and backspace, a large customized board might be ideal. In this case, the Build-A-Board Builder Tool + 10 Run-time Licenses, Catalog#: 12403 might be the best choice. If you are prototyping and testing, Build-A-Board Builder Tool, Catalog#: 12401 would be sufficient. If you already have licenses of IMG's My-T-Soft®, My-T-Pen®, or My-T-Touch® installed, and want a custom board, then Build-A-Board Builder Tool License, Catalog#: 12401 is all you need. Please note that there are different license options available based on customer needs, so if you can't find exactly what you want on the web site, please contact us.
Original ID: QC225142
To operate Build-A-Board you need: Windows10 / 8.1 / 8 / 7 / Vista / XP / 2000.
Run-Time Files will work on: Windows CE or Windows 95/98/Me/NT/2000/XP/Vista/7/8/8.1/10, Windows Server and Embedded versions. Mac OS X 10.4 and higher, Android 5.1 and higher, and Linux 32-bit/64-bit. For other platforms, or if you have more specifics, please feel free to contact us.
Original ID: QC225143
With the release of the 2.20 version, Mac OS X and Linux are now available. (Note: For Unix, pre-built run-times are not included, as these types of deployments tend to be customer specific - please contact IMG for further details)
Original ID: QC225144
With the 2.20 release, there are new licensing options. For 2.10 customers, we will be providing a free upgrade to the builder itself, which can still make ANSI 2.10 layouts. We are waiting, however, for the Release 4 update before formally doing this upgrade (the license manager needs to be created for Linux and Mac OS X). If desired, we can provide the BAB220 serial # at this time, so you can license and work with the current Release 3. Please note that you will still have to license individual run-times. Please contact IMG Customer Service with this request.
The new license options are what we refer to as Platform licensing, and it is based on company size, not # of units. Once you have a Platform license for Windows, Linux, Mac OS X, etc. you will be able to produce licensed versions for the licensed platform that can be imaged or deployed without any run-time/per unit licensing. The Build-A-Board standard upgrade (for 1 platform) from a 2.10 license is US$995 - Catalog # 12406 - this can be ordered on-line (with your BAB210 serial #) with this link:Upgrade to Build-A-Board 2.20 Standard Platform license
You can then select a platform (Windows/Linux/etc.) and then when you build Unicode 2.20 layouts, the license is automatically embedded in the built layouts, allowing you to deploy without any further license steps. Note that you cannot resell these licenses - these are for you/your company as the end-user. If you wish to distribute / resell licenses, you need an annual distribution license.
To summarize, and hopefully clarify the above, here is what will happen to 2.10 licensees:
1) Free Upgrade to Build-A-Board 2.20/builder - able to use upgraded builder tool, can still make ANSI 2.10 layouts, run-times still licensed separately - Option to license and run Unicode 2.20 layouts by licensing run-time versions
2) Or pay for Upgrade to Platform license (Cat #12406 for Standard - company less than 50 employees)
(There are additional options for site/multi-site/enterprise/global enterprise licenses - please contact IMG Customer Service)
3) for any distributor/reseller and annual distribution license is required.
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, Android, 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.
- Create or Modify a layout in the builder.
- Select Target in the Run-Time menu (e.g. Windows 32)
- Build (& execute to test)
- Install the Target (run-time) files on your deployment target
- Run My-T-Soft at a system level, or at application start (Shell/Exec/etc.)
- Use Developer's Kit Tools (or concepts) to move keyboard window on-screen when needed/off-screen when not
- Use an iterative approach to get the custom keyboard layout integrated into your application
Here is a more technical overview
- 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.
- 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)
- 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.
- 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.
- 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.
Congratulations and Welcome! IMG has been providing on-screen keyboards since 1995 and our software is in use throughout the world by everyone from individuals to global corporations.
My-T-Soft is the run-time software that displays the keyboards and is customized for the target device platform. There are versions for Windows, Windows CE, embedded Windows, Windows Server, Android, Linux, and Mac OS X. For more details on My-T-Soft options, see Understanding My-T-Soft Offerings
Build-A-Board is the custom keyboard designer, keyboard layout editor. You create or customize your layout in Build-A-Board, and then build for the target device. The Build-A-Board builder is a rich application and requires Windows.
You can get started by downloading Build-A-Board, then installing. You can license for free by creating a Build-A-Board.com account - just use the IMG License Manager (Licensing Information icon) and create a Free account. For step-by-step details, see this tech item: How to License Build-A-Board - QL0118120923
Once licensed, you can create boards (i.e. custom keyboard layouts) - either select an existing layout and modify, or start from a clean slate. There are many samples included, or check out the growing number of layouts at the Online Database of Layouts. To deploy (i.e. run on your target device), you can simply install My-T-Soft on the device, and copy in your board, or use your Build-A-Board.com account and tag your custom boards as Favorites.
For small numbers (less than 25 or so) it is easy to purchase licenses from your Build-A-Board.com account - there are discounts for 10+. For larger deployments, refer to Licensing options link below. For easiest stand-alone install on Windows devices, see My-T-Soft Basic. For Android, see My-T-Soft for Android. For other platforms, see Windows or Android links and scroll to bottom of page.
Typically this is an iterative process - test, then tweak, and modify until you are happy. By keeping boards in your Build-A-Board.com account, whenever you get a new device, you can install My-T-Soft and get your boards (Get My Boards)! For enterprise use, this also provides a centralized point for rolling in updates, or getting a production device back up and running quickly.
For a more detailed description of Build-A-Board, see the high-level / birds-eye view tech item: Build-A-Board overview - QC2010120648. For videos, Click here for the Introduction & Overview, along with the Build-A-Board How To Video Series. For individuals, you can purchase a single license through your Build-A-Board.com account. For commercial customers, when ready to deploy across the enterprise, there are various options - see this tech item for more details: Build-A-Board Licensing options - QL0105120441
As seen in ...