Wirt writes:

(long clip)

> >  How about the ALT key?  That's precisely what it's for!
>
> A surprising number of people have written me privately and suggested the same
> thing. Unfortunately, it's not true -- and you can demonstrate to yourself
> that it's not in just an instant.

Unfortunately, the various implementations of the ALT key
don't hide one important fact that Wirt didn't, and can't, contradict:
it *IS* used as a command key.  I.e., it in some manner triggers a
command.  Thus, pressing <ALT> c  is almost always interpreted as
some kind of command.  The commadn may VARY from program to program,
or even mode to mode ... but it's a command, not data.  In this
respect, it's the same as the Mac's COMMAND key.

> The ALT key is by Windows default associated with the pull-down menuing
> structure.

I.e., commands.

> More importantly yet, it takes on its various definitions in a
> hierarchical fashion. ALT+T may mean one thing at the base menu level,
> something completely different once you're in the ALT+T-invoked menu, and then
> something different yet again in the next layer's submenu.

But...*all commands*.

> The CNTL key is handled significantly differently by Windows. It is not
> hierarchically menu dependent. It means the same thing everywhere within the
> window where it has been defined. In that regard, it's much more similar to
> the Mac's command key than it is to the PC's ALT key -- and I'm sure that that
> is the reason why everyone from Bill Gates on down has adopted the CNTL key as
> the new modifier of choice.

You can write software to misuse the Control key just as badly as
the ALT key is misused ... that's not an excuse for *doing* that!

> However, the collective comments have convinced me to allow a mode where the
> alphabetic keys, when modified with a CNTL key, can be either be (by user
> setting) transmitted on to the host or (by default) take on the new standard
> definitions that occur in Excel, Word, Netscape, IE, and a thousand other
> programs nowadays.
>

Great!

>  Again, I believe that it is important to design the product for the people who
> are most likely to be using it. In this case, our target audience is the
> business user.

And what percentage of the beta testers fall into that category? 10? 5?
:)

onetheless, since yesterday's posting, I asked five more
> people, all of whom populate this list and thus can't truly be considered to
> be our primary target, how many of their applications programs that they run
> utilize control-code keys to activate any portion of their applications'
> behavior. The answer was -- as well as anybody could come up with on the spur
> of the moment -- is the same answer that we got in our first survey: none.

That's a poorly defined qustion.  If asked of me, I wouldn't know
if you're asking about Reflection, or about the programs I interact
with on the 300 or 9000 via Reflection. ..and the answers would be
completely different!  Reflection generally doesn't react to contorl
keys, so I'd say "none".  MPE CI, OTOH, does interact...control-H,
control-X, and control-Y for example, so I'd say "all" (I run no
block-mode-only programs, generally,m which are just about the only
3000 programs that react to no control characters)


> It's the old-style, host-based editors that tend to use control-codes as
> behavior controllers. If you're not a developer or a code-stitcher, you're

control-Y, control-X, control-H  QED.

(and control-S/control-Q, even if there's a STOP key)

> Windows handles it, but especially so now that all other programs have chosen
> the CNTL key.

Nope.  Clearly, not *all* other programs.  For one, every terminal
emulator I've used (other than QCTerm) has not "chosen the CNTL key".

--
Stan Sieler                                          [log in to unmask]
                                     http://www.allegro.com/sieler.html