World: r3wp

yes. it's still main block only iirc

but i found it very useful with VID

MODULE instead scan sub-blocks as well and preserves globals by copying 
them.

I guess I was incorrect. 8 years of REBOLing is not enough.

how exactly do you use it?

layout vid-context [....]

it will make set-words in there local. i think i had a refinement 
to also get the context in case you need to access it...

ok, should work for rebgui too then

vid-context/to

yep, vid-context/to [...] 'word

(it's a small function so you can easily modify it to fit your needs, 
as well)

I have a screen ( VID) and a function that loads values into that 
screen.  I was hoping to reuse that screen elsewhere by enclosing 
into an anonymous context, and use the function that loads the data 
with the same.

so does it make sense to fix make object! to scan for set-words in 
the sub blocks?

You might end up with some rather large objects with lots of redundant 
words - perhaps not so useful for data modelling...

Well, instead then a context function that deep scans for all set 
words

I want to be able to reuse these screens I have defined elsewhere 
and the functions that operate on these screens without overwriting 
the original values ...

c: does [ f/text: "hello" show f ] view layout [ f: field button 
"New" [ context [ f: g: none bind [ c ] 'g view/new layout [ f: field 
button "test" [ c ]
] ]]]


this doesn't work ... pressing the test button sets the f field in 
the first window and not the second

c: does [
	f/text: "hello" show f
]
view layout [
	f: field
	button "New" [
		context [
			f: g: none
			bind [c] 'g
			view/new layout [
				f: field
				button "test" [c]
			]
		]
	]
]

should be 

bind [c] g

but still doesn't work

Probably I do not understand the real intention, but I woud do
c: func [f] [
	f/text: "hello" show f
]
and
button "test" [c f]

Very cool both Nick and Gabriele.

My 'c function references about 20 fields so I want to avoid passing 
the field name as parameter

If it can be solved thru binding .. .?

If it can't I'll just copy the function

Graham, you need to bind the function body.

c: does [
	f/text: "hello" show f
]
view layout [
	f: field
	button "New" [
		context [
			f: g: none
			bind second :c 'g
			view/new layout [
				f: field
				button "test" [c]
			]
		]
	]
]

thanks .. I'll give it a go

rebol []

c: does [
	f/text: copy "hello" 
	show f
]
view layout [
	f: field
	button "test - c" [ 
		bind second :c 'show
		c 
	]
	button "Clear" [ f/text: copy "" show f ]
	button "New" [
		context [
			f: g: none
			bind second :c 'g
			view/new center-face layout [
				f: field
				button "test" [
					bind second :c 'g
					c
				]
				button "Clear" [ f/text: copy "" show f ]
			]
		]
	]
]

And this works ....

I can open multiple new windows and the 'c function now works on 
its own instance of f field

( the first 'bind outside of the layout is not needed )

Graham, use the /to refinement of my VID-CONTEXT and pass the object 
to the function

Gregg, your solution either "breaks" C (in the sense that it will 
only work on the new context and not the others) or does not work 
(on versions of REBOL that copy the function code block - I think 
R3 does this)

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

view layout [
	f: field
	button "test - c" [	c ]
	button "Clear" [ f/text: copy "" show f ]

	button "New" [
		context [
			f: g: none
			view/new center-face layout vid-context/to [
				f: field
				button "test" [ c ]
				button "Clear" [ f/text: copy "" show f ]
			] 'c
		]
	]
]

Gabriele, this doesn't work for me ...

assuming that is what you meant :)

My assumption--never assume, I know--was that 'c would always be 
re-bound before each call. I was looking at the action, not the context 
*in* the action.

Gregg, that's what I did to get it working .. but I'm interested 
to see how Gab's solution would work

Agreed. Gabriele and others often point out holes in my naive code, 
for which I am always grateful.

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