[colorforth] My ideal colorForth user interface:

["Robert Patten" <pattenre@xxxxxxxxxxx>]

This text reformatted, one phrase per line.
with additions and  corrections.

ON Robert's  wish list.
Some ideas have been tested
but have not been integrated into one source.
Some ideas are still not compatible with each other.


 Assign the   center keys  " t y  g h  and b n "  to forth words
 for connivance. Allow all keys to be assigned words.
 The data stack is displayed light yellow for decimal  and
darker yellow for hexadecimal.
( a yellow word is medium yellow same for green numbers.)
 The "b key"  does  "drop".
 The editor leaves the last  block on stack  to use
with words like "edit load copy".
I will press "b key" to drop stack data I don't need .
When  keys are   appended to the top of data stack
the top of data stack and the key map are displayed
in the current tag color.
If I can append  " key top characters"
the key map will  not be displayed.

The keyboard icon (lower right) will be displayed
in the current  tag color with a four quadrant  square icon
displaying the current 4  tag bits.
The " t key" will change upper 2 bits of current tag
stepping through  the four classes of word
(comment, label, literal, state ).
The "y key" will change lower two bits of the current tag
( extenuation text Cap CAPS,
name make use build,
use27Bit make27bit  use32bit  make32bit,
variable user1 user2 key).
The "g key" will repeat the last word.
The "h key" will put h on the stack.

 The key board map,
 "board"  uses a pointer into source and  displays
next 24 cells on three rows of eight cells each.
Any extensions of word displayed in white.
 "left hand words" on dark gray background and
"right hand words" on black background"
Taping a key will place corresponding cell on  data stack.
Words with extensions will need more than one key taped.
Holding down the key will display the words definition,
then words description as the keyboard map.
Releasing key will make displayed  keyboard map the current map.
Taping the " space bar"  will execute word on top of stack
and/or insert at  the cursor if editing source.
Holding down the spacebar  will display the stack and
the root  keyboard map.
Taping a key while the space bar is held down  will select
that  keyboard map as current and immediately show it .
While the "space  bar"  is down the   "n  and  alt key"
will move the keyboard pointer  24 cells  - or +.
This will allow any source to be a keyboard map,
 just store a source address in the board pointer.
When the " spacebar is released
the current keymap is redisplayed.
If  no  keyboard is selected while the spacebar was down
the current keyboard will be the last selected keyboard.
Taping "any unassigned key" on the keyboard will hide
the keyboard map  and data stack.
If the space bar is taped while holding down a key
that key number is placed on the stack.
Allowing it to be used as an index into a keyboard map
for editing the definition of the word or
assigning a word to the key.
When  the keyboard is inactive for a preset time
execute " screensaver load ".
When the space bar is up the "n  and  alt key"
delete and insert words to and from the
designated "clipboard"   block.
The "clipboard"  is  a root  keyboard map allowing
access to any deleted word for
execution or insertion at the cursor.
The clipboard keyboard first displays the last 24 deleted cells.

Make the "f color tag "  a key definition tag
that will display the   icon  in its position in the key map
and when executed append icon id bits to cell below
leaving it top of stack.
 When leaving the icon editor leave
the text form of this icon "key definition tag" on the stack,
for other words to modify.
For example: change to being a digit
in a selected number base.
Or machine instruction  or other icon to
be append to next  of stack.
The "space bar"  will  execute key definition tag
for verification or insert it in source  for later execution
as a keyboard map or in definitions building instructions.

Source is displayed on a black background.
Text to be moved when the "space bar "
inserts the word on top of stack,
or when word is deleted  or inserted,
is displayed on a dark gray background.
This  eliminates the need for a cursor.
"list" just changes background color
when the word count of the inset pointer is reached.
This will also eliminate special handling for
start of line cursor handling and
when cursor is  within a  musty cell word.
This will allow any kind of cell to be placed
 anywhere in the source.
More freedom, more responsibility, simpler.

The word  " list "  takes a cell count and address
from  stack and displays source from  address until
screen is full or count is reached.
Null cells  are displayed with icon,with a single
dot in center,  in the current tag color.
This will allow complete inspection of  block or
display counted source strings  like keyboard maps.
"fore"  "ground"  "xy"  "font"   are variables
that  a "show" definition  can save and restore,
allowing the keyboard task to control the
areas of the screen not used by  the "show" definition.
This will allow  words executed from the keyboard
to display on portions of the screen not overwritten by
the show definition.
This is  desirable  for  teaching,  interactive testing  and
learning how graphics words work.


 Word lists are consecutive blocks with
 the first cell  red word   "name of list"
 "make" or "use"  or   "need"     kind of list.
Their definition changes  when editing  loading
or other activity needing  access to labels.
The next cell  is  the number of words  in the list.
Words in the list are shown in  red with
their  extensions missing and
can be used as keyboard map for selecting words
to execute or insert into  source or to
view their definition and description.
The reaming words are displayed in orange
indicating that they were trimmed by "empt"

 The word "edit"   does empty
then loads the editor and displays the block .
Then  does a modified  load on the block
building "make" and  "use"  wordlists with
associated  source addresses  and
makes them available  in the root keyboard map.
 Also " edit "  makes a undefined label list "need"
 that is included in the root keyboard map.
The associated address is the first usage of
the undefined label.
The "need"  list can be used  for creating
source blocks to support  the current edit blocks.
when a word list is displayed as a keyboard map
 the most resent 24 words  is displayed first.

On the first comment block of a group of blocks,
first cell  "red name of group"
second cell " yellow number of blocks in group"
third cell " yellow word  'blocks'
example: edit 6 blocks
"blocks" would  be defined for particular need.

One example:
 "blocks" would display this  block for me to read.
If I  tap the "space bar"
the name is  defined as a load word
to load the first source block and the blocks
of the group are  placed in local source memory.
If I tap "any other key" the "name of group"
is removed from list and the source blocks
of the group removed from local memory.
The  first source block of next group of blocks
is loaded if  the number of blocks is zero then exit.
This will  allow conviniate  customization
of my colorforth by me.
Also allow coping source from or to
other colorforths over the internet.
All of this is convenient,
just by putting three words of source
on the first comment block of each group of blocks.
This structure is also nestable
allowing only the current branch of the tree
in the wordlist but allowing access to the hole tree
of words one branch at a time.

 Please post your ideal colorForth user interface
integrating the  features from others
you like for discussion.

Robert


---------------------------------------------------------------------
To unsubscribe, e-mail: colorforth-unsubscribe@xxxxxxxxxxxxxxxxxx
For additional commands, e-mail: colorforth-help@xxxxxxxxxxxxxxxxxx
Main web page - http://www.colorforth.com