World: r3wp

I suggest to add an OLD-TYPE variable, and put something like this 
in the DRAW function:
	either all [type = 'free-hand type <> old-type][
		; add all the initialising stuff (PEN FILL-PEN, LINE start)
	][
		; otherwise compose in nothing
	]

So when you change from circle to free-hand, DRAW adds the initialising 
draw commands, but after that, just adds an offset.

Ooops, I should have checked for type = old-type so we can add the 
single offset. Anyway, you get the idea. Just move that condition 
inside the either true block.

hmm... how do I set the default entry in a CHOICE at layout time? 
I wanted to do something like this:

view layout [choice "1" "2" "3" with [data: next face/data]]

hallo, alls... i have a question regarding view events...  i am testing 
using the following code, which creates two text fields, one of which 
only accepts numerical input...

view/new layout [
    the-field: field feel [
        engage: func [face action event] [
        	if action = 'key [
			if all [ greater? (to-integer event/key) 47
				 lesser? (to-integer event/key) 58 ] [
				 append face/text event/key 
				 show face 
			]
		]    
        ]
    ]
    new-field: field
]
focus the-field
do-events

first question, is how can i get the first text field to accept mouse 
click events?  how then do i get it to recognize the tab key to switch 
focus to the next field?

also, can i update the position of the text curser in the number 
field so that it is the current position being typed at? (bad wording, 
i know... )

robert, what happens in the above code is that you replace the original 
feel functions with one ENGAGE function. that's why you loose normal 
field functionality

is there an alternate way i should be doing this?

you need to copy in the original feel from a generic field face into 
your new field along and then add your code to its existing engage 
function

it's a bit of a hassle...

try:

probe get in new-field/feel 'engage

that's the original code

that's the code you need to alter...

thank you, i will try that

you can copy it out into a separate function, which could be called 
ENGAGE-FUNC and make you alterations.


then you can initialize a normal field with a new ENGAGE function 
in your layout:

the-field: field with [feel/engage: :engage-func]

this will leave the remaining feel functions untouched

Henrik, your choice problem. I think, you have to redefine choice. 
The problem is in the multi/text function. You can do it at layout 
time this way:

view layout/size [choice "1" "2" "3" with [multi/text: func [face 
blk] [if pick blk 1 [face/texts: copy blk]] text: "2"]] 400x400

It's better to make your own choice with your own multi/text function.

using styles for example.

thanks, I'll give it a try...

http://polly.rebol.it/test/test/extend-engage.r

I want to save my draw commands to a text database field.

is this the only way

form compress mold data  ?

the question really is, is there a native way to compress blocks 
as a string value ( for saving into a text field )

by molding them

does molding save space though?

that's what I am doing above, molding and then using using compress

no, but then you have a string. then you can compress. then you can 
write/binary .

text field .. can't save as binary.

i overlooked text-field, only saw saving.

why do you want to do that, compressed in a field?

because the field is varchar(8192)

and data is being transmitted over tcp, so good to compress first

a sql-field, not a face-field?

you can use 'as-string instead of 'form. but i know no better way 
that "compress mold".

sql field

perhaps we native to compress rebol code and return as a string value, 
and not binary

you can convert a binary to a string in place, with 'as-string

I wonder if that will save okay though 


>> t: as-string compress mold [ font bold32 pen yellow red line-pattern 
5 5 line-width 2 ]

== {xœ‹NËÏ+QHÊÏI16R(HÍS¨LÍÉÉ/W(JMQÈÉÌKÕ-H,)I-ÊS0^EB°@yfJI†‚Q,^@\Z^T^T:^@^@^@}

with write/binary yes. dont know what the sql-protocol does.

>> t

== {xœ‹NËÏ+QHÊÏI16R(HÍS¨LÍÉÉ/W(JMQÈÉÌKÕ-H,)I-ÊS0^EB°@yfJI†‚Q,^@\Z^T^T:^@^@^@}

>> insert db-port [{update results set draw = (?) where rid = 174} 
t ]
>> insert db-port {select draw from results where rid = 174}
>> r: pick db-port 1

== [{xœ‹NËÏ+QHÊÏI16R(HÍS¨LÍÉÉ/W(JMQÈÉÌKÕ-H,)I-ÊS0^EB°@yfJI†‚Q,^@\Z^T^T:^@^@^@}]
>> decompress to-binary r/1
== {[font bold32 pen yellow red line-pattern 5 5 line-width 2]}
>>

seems to work ...

if you use the 'arrow command in Draw, everything else after that 
has an arrow on it. 
How to turn off arrows after that ?

Henrik, your advice is not exactly right: "robert, what happens in 
the above code is that you replace the original feel functions with 
one ENGAGE function. that's why you loose normal field functionality"

Robert has, in fact, only replaced the ENGAGE function in the feel. 
The FEEL keyword in the layout dialect actually MAKEs from the original 
feel, with the spec block you give. eg.

	feel [
		engage: func [...][...]
	]

actually causes something like:

	face/feel: make face/feel [
		engage: func [...][...]
	]


So the other functions which were in the original face/feel are also 
copied in the new feel, unmodified, eg. (DETECT, OVER, REDRAW).

Nevertheless, Robert does need to look at the original ENGAGE function.

Henrik, your second example actually does "damage" to the system.

You are modifying the default FEEL object that is MAKEd from every 
time FIELD styles are created by LAYOUT.
It's basically like the following example. Here we set the ENGAGE
function to NONE to disable user interaction to the field:

	view layout [
		field with [feel/engage: none] 
		field
	]


But the second field also does not respond to user activity, nor 
do fields created in new windows:

	view layout [field] ; <- this field also does not respond

It can be confusing.

You have to remember that the FEEL objects are shared by default, 
to save memory.
These two examples may look the same but they are not:


 layout [field feel [engage: none]] ; this one clones and modifies 
 the FEEL


 layout [field with [feel/engage: none]] ; this one modifies the original 
 FEEL


The LAYOUT dialect has a FEEL keyword, and that causes a MAKE of 
the feel (ie. it is cloned
before being modified by your spec block).

The LAYOUT dialect WITH keyword, however, gets you out of the LAYOUT 
dialect and back into "normal" rebol code, but also binding you inside 
the new face object (the field) that is being created by LAYOUT.

So the "feel" inside the LAYOUT spec block and the "feel" inside 
the WITH block are not the same.

Robert, towards a solution, we need to look in SYSTEM/VIEW/VID/VID-STYLES/FIELD/FEEL, 
eg, by doing this:

	print mold svv/vid-styles/field/feel


So the first attempt should look like this, just copying the code 
from the console:

view/new layout [
	the-field: field feel [

		;;;; 
		engage: func [face act event][
			switch act [
				down [

     either equal? face focal-face [unlight-text] [focus/no-show face]
					caret: offset-to-caret face event/offset
					show face
				]
				over [
					if not-equal? caret offset-to-caret face event/offset [
						if not highlight-start [highlight-start: caret]
						highlight-end: caret: offset-to-caret face event/offset
						show face
					]
				]
				key [
					edit-text face event get in face 'action
				]
			]
		]
		;;;;

	]
	new-field: field
]
focus the-field
do-events

Oh no! We get an error message! "edit-text has no value".
Where is EDIT-TEXT ? It is not defined in the global context.
If you go looking in the system you will eventually find it here:

	CTX-EDIT/EDIT-TEXT


What happened ? The original EDIT-TEXT word, as found in the FIELD/FEEL, 
is bound to CTX-EDIT 

(it's not found in the global context, open a new console and try 
it), but we only bound our new EDIT-TEXT 
word to a new function context (ie. our ENGAGE).


So how do we keep the original bindings of a function, when making 
a copy of it ?
SECOND gives you the body of a function.

	second get in svv/vid-styles/field/feel 'engage


We should COPY that, which keeps the bindings, then modify that copy. 
*Then* we can create the function:

	; copy the engage function body
	body: copy/deep second get in svv/vid-styles/field/feel 'engage

	; <-- modify the body here

	; make the new function
	engage: func [face act event] body

Let's test that to see which keys we want:

view/new layout [
	the-field: field feel [

		use [body at-key-block key-block][

			; copy the engage function body

   body: copy/deep second get in svv/vid-styles/field/feel 'engage


   ; modify the copy to move the block with the EDIT-TEXT word in it
			; to a new IF then-block
			at-key-block: next find select body [switch act] [key]
			key-block: at-key-block/1

   change/only at-key-block compose/only [probe event/key if true (key-block)]

			; make the new function
			engage: func [face act event] body

		]

	]
]
focus the-field
do-events

Now filter for the desired keys: