World: r3wp

although at some point it gets really slow because of the limits 
of R2... it just chugs along never *EVER* breaking about even though 
at some point I've got about 50000 nodes talking to each other.


actually, the only thing that does constantly break a part is everything 
which isn't representable as nodes... like events, and input data 
files which I must read and convert into nodes, which get connected 
directly to the interface.

anyhow... back to OpenGL in R3  ;-)

ok

i saw your first teapot picture any improvements since then ?

i will try to think this  more  i like the idea of  having a fast 
view uppon rebol script as a view boxed/noded in realation one to 
another. I like the idea of behing able to "enter" those box/nodes 
to adapt them enhance them or simply redefine them. I like the idea 
of sharing pre-sets box and having a synchronised / shared tool box 
.If i design a tool and make it available then in a short time that 
tool becomes part of the hudge collective tool box and then is shared 
to every one.

i like the idea of a splendid scenarised grphical overview ..

boxes aren't tools but they can become tools and tools can become 
boxes to be edited / modified

wrt teapot progress ...  in many ways its regressed  ;-)


The teapot was a test of how to integrate something into R3's view 
engine safely and without any side-effects.  hopefully some of that 
research will allow us to better hook into R3 with an eventual tiny 
expansion of the gob structure.


now I'm actually building the engine which interprets user data and 
sends that data to the integration I did earlier. 

though its pretty much empty right now.  I'm *just* about to add 
reading of a user built block of data which I convert to low-level 
C structs and then render in HW.

then can a recusiv process be the base of the tool creation/collection 
can then those basic bricks be assembled on more sofisticated tools 
 those sofisticated tools being then short cuts to create your own 
software

I'm also beginning to feel like a real C programmer... which is a 
welcome change...

pools become nodes.  so anything that can connect to a node can also 
connect to a pool (which means everything per the philosophy of elixir).

hahahaahaha  .... i hate to be forced to C program to do rebol i'm 
interrested in rebol the other languages juste bore me to the infinite 
point ...

yeah... but its nice to be able to count loops in millions rather 
than thousands  :-)

maxim the idea is that i don't want to do the box in the box in the 
box in the box  effect ... i want 2 kind of boxes tools and box mainly 
tools are scripted set of rebol function or rebol functions from 
teh rebol standard dictionary

to each of those tools there is a auto generated form that you will 
feel to set up your function arguments

and then you have the boxes with are "user function"  you put tools 
in them and you related them one to another to make them  cooperate

that's basically what i have in mind

this is known as a "process" in elixir... scripts which build up 
nodes and link them up in a specific way.


tools are processes which have a persisten interface (cli or graphical)

ok . It's interresting talk but it's been really late i need to go 
to bed ;)

have a good and smooth progression then maxim

in many ways elixir models the semantics of nature better than all 
this pseudo desktop and CS ideology.

yeah... there's still a long ahead of me... though I'm now running 
instead of crawling towards it.

long *road*

yeah but i'm a drunken idiot so most of it is too polished for my 
grasp ;)

now discussing undo/redo management. There is a small spec available 
here:

http://rebol.net/wiki/R3_GUI_Specs#Undo.2FRedo_Management

any input is welcome.

undo-redo must not be window based but application-wide.  it will 
be almost useless otherwise.

though it could have different undo/redo threads which are selected.

undo-threads, that was the thought, but perhaps coupling it to per 
window is wrong, if you have multi-window actions occuring.

forcing a 1:1 undo thread to window   relationship breaks up quickly 
when you consider that some windows operate on many threads and some 
threads will require many windows .

ok, then we would need a different method for coupling an undo context 
rather than in the face.

best is to have a simple block with named threads... and you force 
people to supply the thread name when using any of the undo/redo 
functionality.


also, undo/redo is best done when its not directly part of the gui. 
  


though its nice when the undo engine is able to speak to the gui 
directly.  the gui must not be the "brain" of the undo..

then perhaps this could be done:

undoer: make-undoer

view [panel [...bunch of fields...] options [undo: 'undoer]]

having written  a few, I recommend making it an external api which 
is fully "gui enabled"   this way, undo events can automatically 
call face accessors,  and you can put the undo stuff in the logic 
rather than the gui.   many times, the logic might generate a few 
undo, or none, based on things which the gui can't properly be aware.

although that specifically implies that you actively need to do some 
specific work to activate undo. I don't like that.

undo/redo is a pretty complex thing and unless you've got a non-destructive 
dataset, its almost imposible to make it a generic tool that is actually 
stable.

yes, the idea is also that it can be entirely decoupled from the 
GUI, so if you don't want it or want to use a different way to undo, 
that should be possible. the task for undo as I see it is to read 
actions and allow playing them back by taking control of the GUI.

non-destructive datasets: this also implies that the undo engine 
really stores all temporary data. it could be an issue with larger 
data sets, unless it's possible to compress them into changes.

take the case of a system where the undo crosses the lifespan of 
a window (or a few) how do you undo that?  re-open a new window which 
isn't connected to anything?

it basically has to be built with undo actions at the center.


each action has to be able to handle any gui issues gracefully... 
the gui itself cannot manage that unless its an uber simple gui.

might even be that the gui which manages the effect cannot be re-opened... 
ex photoshop.


and yes the data has to be stored somehow... another thing the undo 
"actions" are able to manage better/

they might know how to store things in diff mode, but only it can 
know based on current state, when its remembering.

also, there is a tricky thing to redoing in that its often more like 
a complement than an inverse of an undo... especially when storing 
diff data.

so the undo data and the redo-data aren't necessarily the same   
:-(  


my best system was using dataflow nodes.   but it requires a dataflow 
dataset.

I'm pleased with this discussion. Undo journaling is sorely lacking 
from many systems

The standard design pattern applied to undo/redo is the Command pattern, 
which implies that everything you want to undo or redo is a command 
that knows what it means to perform an action and apply its inverse, 
and the target of the action.

yep... what I call actions above.

also most undo/redo tie-in commands with macros and/or actual gui 
buttons and menus... sort of like the internal API for the lower-level 
stuff.


each of these commands/actions puts itself on the undo stack  and 
usually has a counter command...  add-text/remove-text, edit-record/restore-record, 
etc.

only  edit face needs the undo/redo stuff ... and mostly Area where 
you can input large text for text field it doesn't matter and could 
bring a security breach ... If you ca recall the previous password 
and user entrered in a login window for example.

efficient undo/redo have to be face based. The need for other face 
to access it is irrelevant as  it's a temporary buffer  and that 
this buffer main fonction is to keep tracks of the changes. Wider 
you keep the tracks heavier is the syttème. If that systeme could 
be arguments passed to configure and tune it that would be top.

where undo/redo starts to be challenging is when you don't deal with 
pure texte anymore but that you have to deal with formated text.

with only keeping full tracks for the "actions" into an Area type 
face the undo/redo statcks could be on big documents really heavy 
in memory.