World: r3wp

Graham, you have misused the /TO refinement of VID-CONTEXT.

The function help states:  /to word [word!] "Set this word to the 
context created"
That's "set to", not "bind to", the context created.

So you've not bound C's body block as you intended. Instead, C loses 
its initial function value when it is set to the new context created 
by VID-CONTEXT.

Furthermore your context (created by CONTEXT above) ought to be no 
longer necessary since using VID-CONTEXT.

so how to use it correctly?

hang five

Ok, here's my first way. (untested)

hello: func [word][do bind [f/text: copy "hello" show f] word]

open-window: does [
	view/new center-face layout vid-context [
		f: field

  button "Hello" [hello 'f] ;  Pass to HELLO any one of the words in 
  this context (here 'f).
		button "Clear" [clear-face f]
	]
]

open-window
do-events

You can call OPEN-WINDOW several times before DO-EVENTS, or add a 
button which calls it.

untested??

I just tested it and it seems to work.

Here's another way, also tested:

Here's another way, also tested:

What about Gabriele's vid-context ?

window-functions: [
	hello: does [f/text: copy "hello" show f]
]

open-window: has [ctx] [
	view/new center-face layout bind vid-context/to [
		f: field
		button "Hello" [hello]
		button "Clear" [clear-face f]
		button "New window" [open-window]
	] 'ctx context bind window-functions ctx
]

open-window
do-events

Gabriele's vid-context is a pretty nice function.

So, how can I use it?

oops ...

Well... what do you need to do again?

Sorry ..didn't read your example with care

oh ok

What I want to do is the working example I posted above.

Your last example works

Your 'c function is my 'hello function.

why is it wrapped in a block?

Because I need to bind that code in open-window.

my functions already exist in the global context

It creates new copies of the functions in window-functions each time 
a new window is opened.

that's cheating!

I see.

Ok, in that case, go back to the first example I posted. I'll need 
to modify it a little bit..

the situation is that I have a lot of screens inside tabs.  now sometimes 
I want to re-use those screens outside the tabs ... so I just copy 
the code and put into a new window .. but then I want to be able 
to make the functions that operate on the original sceens work on 
my new ones.

I did actually try copying the functions but they still operated 
on the original windows and not the new ones ... :(

I got it all working using Gregg's suggestion .. but I'm open to 
others

Well, here's the modified code.

hello: does [f/text: copy "hello" show f]

bind-funcs: func [word] [

 foreach window-function [hello][bind second get window-function word]
]

open-window: does [
	view/new center-face layout vid-context [
		f: field

  button "Hello" [bind-funcs 'f hello] ;  Pass to BIND-FUNCS any one 
  of the words in this context (here 'f).
		button "Clear" [clear-face f]
	]
]

open-window
open-window
do-events

It's not brilliant; in each button action you have to call bind-funcs 
before calling any of the window functions (eg. hello).

which is what I am doing at present .. binding before calling the 
function

Yeah, so I've just made it more complex than necessary.

now if the functions could access the 'self of the object, it could 
bind automatically?

just rewrite every function ...

It's the same problem; how could the functions know which object 
to bind to?

so I would pass the context to each function as a parameter

so these would be self aware functions :)

Usually I just write functions and pass the face(s) that they need 
to work on. Passing the context could cut down the number of arguments 
passed to one. But usually I don't need to pass more than one face, 
so it doesn't seem of that much benefit.

So, rewrite the function to take a parameter word from the context 
it is to work in, and let it bind itself to that context ...

well, I have named fields ... and a bunch of data coming in which 
I need to fill the fields

either I fill by position, or by name

You can bind directly to a context now, you don't need to pass an 
example word, unless you are using a very old rebol version...

anonymous contexts ??

Alright, well, if you have a function which manipulates many faces, 
then there are arguments to be cut down, and there is a benefit.

Anonymous, yes.
ctx: context [a: 1]
bind [a] ctx

You no longer have to do:
bind [a] in ctx 'self
or
bind [a] in ctx 'a