We could create a modified VIEW.EXE program that uses a localization dictionary to do real-time conversion on words or phrases, allowing the original English version to be sent out, and then using that content as a key string which looks into the localization file for the translation.
A parsing tool could create the entire range of text for any target strings, and then they could be translated externally allowing the localization files to be plug-ins to VIEW.EXE to allow instant translations without having to reload any other versions. It would also allow the dictionary of words to be used in other help files that do not have an explicit translation provided for. It wouldn't be 100% accurate in those versions, but it might be better than nothing for un-translated files.
This would work for the help files.
It occurred to me on the way in to work today ... the way the Warp 4 voice / speech recognition system works, by hooking into windows and allowing input where possible, maybe using functions like WinBeginEnumWindow(), WinEndEnumWindow(), and WinQueryWindowProcess(), we could even create a translation matrix that sits on top of all existing windows, allowing a window to be created which has language controls off to the side, allowing for translation of text by pressing a button.
A window like this:
Standard Window:
+--+-----------------+--+--+--+
| | Window Title | | | |
+--+-----------------+--+--+--+
| |
| Hello, world! |
| |
| +--------------+ |
| | Close | |
| +--------------+ |
+-----------------------------+
Is augmented with a plugin that presents a window near it for translation controls:
+--+-----------------+--+--+--+
| | Window Title | | | |
+--+-----------------+--+--+--+
| |---+
| Hello, world! | X |
| | L |
| +--------------+ | A |
| | Close | | T |
| +--------------+ |---+
+-----------------------------+
And after the translation controls are clicked, it overlays each bit of English text with any translation it can find, and allows the text to be translated right there on-the-fly by an edit screen available in the translation control interface:
+--++--------------------+-+--+
| ||Título de escaparate| | |
+--++--------------------+-+--+
| +------------+ |---+
| |¡Hola Mundo!| | X |
| +------------+ | L |
| +---+------+---+ | A |
| | |Cerrar| | | T |
| +---+------+---+ |---+
+-----------------------------+
This would work for the presentation manager. And for console windows, we could either scrape the screens looking for words/phrases that are there and translating them, or if there's an API to intercept the Vio*() functions, we could capture them that way by hooking into the DLL's target address with a plugin, so it calls our function, which we then call the real DLL function, allowing us to intercept all reads/writes/operations.
But for the Presentation Manager, each of the overlay portions of text can be clicked on to see the full translation. A plugin web-based service can be installed to allow auto-translations to other languages based on the phrase or words at each point.
The only issue would be some words are longer and some are shorter, so we'd need to have them be overlays, with the ability to possibly change font, compress the width, center the text, etc., to make the new text in the other language fit in the space allocated for it by the original language.
We might also be able to use WinSetWindowULong() or WinSetWindowPtr() to point to a sub-classed function, so that we can intercept all drawing operations and maybe even do real-time augments by intercepting the WinDrawText() and related functions, to actually make something a permanent addition to the screen through the plugin augment.
It would allow the user to not only change the text, but define overrides for the font, size, color, etc. It would be like a combination translation + facelift for the window.
In my Visual FreePro project, I called these
mashes, as you could effectively take the skin of a form as it exists and is rendered by the window, then grab the bitmaps from that rendering and tweak them to a new display, or pipe the content into other controls, which tie back to the originals, leaving the original functionality there as per the original program design, but then allowing the overrides desired to change the thing when the source code was not available.
It doesn't change the actual operation of the program, but only puts a new skin over the top so that clicking here or dragging there on the skin translates to its real positions on the real form.
I have so many ideas I'd like to bring forth for people to use.