if you want to write in real japanese, you would want to get kanji and katakana out as well, not only hiragana. for this aim you would need an ime anyway - or program your own equivalent to it, which would be be extremely laborious.
Yes, of course. I think I wasn't clear enough.
My idea is quite simple : all computers can produce japanese text using an IME (even without installing anything, I sometimes use programs like JWPCE which has its own IME included, although not as efficient as Mozc e.g.). Using a normal keyboard, you can do this by typing Hepburn sequences with alphanumeric characters.
But I want my keyboard to act as an kana keyboard (kana nyûryoku) WITHOUT requiring to installing a japanese keyboard driver. A key on the keyboard corresponds to a kana (when the kana layer is active), and when you press it, the *keyboard* translate the key into a Hepburn sequence of ASCII keys. So you can use the IME by typing kanas (and still using the IME for kana>kanji translation) but you don't need to type 'k' then 'a' for 'ka', but directly 'ka'. Still, the IME believes you're entering alphanumeric characters on a normal QWERTY keyboard.
Two reasons for typing kanas instead of Hepburns sequences: a lower number of presses are needed (nearly half less) and with an ergonomic layout, 'w', 'k' and 'y' are not the easiest to reach (at least in french) so typing japanese would become more difficult (and I don't want a layer per-language for alphanumeric keys).
Most japanese people use QWERTY to enter kana/kanjis, but that's mostly because (according to japanese people I know):
- the placement of kana keys is awful and inconvenient (and there's not enough reachable keys on a QWERTY keyboard to change this), and some of the most useful kanas are really far from the home row
- the placement itself seems as random as QWERTY (would be interested to know a reason for this placement if there's one besides "historical placement on typewriters"), so it's very difficult to memorize two layouts, especially if there's twice as many keys as A-Z
I knew about TRON keyboards, they're really nice, I even considered buying one (although it's not easy to import them, and even in Japan, they're nowhere to be found in normal shops). But they're usually not cut in half, not (enough) tented to my taste, usually seriously lack keys for a programmer, and most importantly aren't as customizable as keyboards with microcontrollers.
Most probably those ergonomics keyboards have a clever layout (a kana-dvorak of sorts) for kanas I could copy, but I won't try... I don't enter enough japanese, currently, to warrant learning a complex layout. I'll rather have a finger per vowel (i-u-a-e-o) and a row per sound (t, r, n, -, r, s, h, m) plus keys for y*, w*, n and other special keys (henkan, muhenkan, IME control, hiragana/katakana switch, etc.). And a modifier for ° and " (or deadkey, but with thumb clusters, I prefer a modifier). So, easily remembered layout... I've just chosen the position of each vowel/sound depending on the frequency of each kana, so it's already far better than 'normal' kana keyboards in Japan (tried it on AZERTY keyboard, it's efficient, but I lacks some keys on AZERTY so I lack some kanas, and the lack of programmability makes transforming ka + small-ya in kya tricky, although definitively possible).
i would also like to make an additional (7th) layer for character strings per key (like sending "i n t Space m a i n ( ) Return { Return Return } Uparrow" to speed up programming) in the adjusted flux1.01 layout.
will it be possible to make such a character code string layer - and also create a layout switch key?
Definitively. That's macro keys for you (if it's not in the standard configuration program, it'll definitively be possible in the one I'll try to develop). The only issue could be memory, but there should be plently of memory.
I also considered this (I actually have the layer for this ready for C++, Python and even for TeX). But I'm not sure I'll actually do it, since my editor do mostly the same by using a key then a shortcut (two presses, the same as a layer change). The shortcut would be a direct key on the keyboard. The editor seems a better option to me because it's content-aware. Of course, it's less portable, but I travel with my editor on a key anyway (I can't use an editor with different colors, different shortcuts, etc.)
And by the way, I think you can do far more than that with programmable keyboards (in-keyboard copy-paste, keylogging, cryptography, one-time passwords, etc.). I've far more ideas than I have time for those ^_^ AcidFire, I sure have great hopes for firmware hacking with the Atmega
The first one I'll do, though, is creating a "clever close" key: the keyboard remember your last ( [ { and " using a stack, and when you press the "close" key, it types ), ], } or " based on the stack.
So :
fun(table["key"])
can be entered by
f u n ( t a b l e [ " k e y CLOSE CLOSE CLOSE
(I'd like, if possible, to add a small screen displaying the stack state, too, so that I know how many things I still need to close and which one)
Yes, I've done some LISP in the past, maybe that's where I get this idea ^_^
