World: r3wp

>> remap  4x26 38x729 234x355 600x62 4x26
== 277x344
but that should be 234x355

>> remap  4x26 38x729 234x355 600x62 38x729
== 643x51
and it should be 38x729

Ah, I thought you would feed it 0x0 to get, e.g., the UL corner.

I mean 600x62

So the point is the coord in the first rect and returns the "equivalent" 
point in the second rect.

yes

but the second rectangle uses a different coordinate system.

ie. in the first, 0x0 is top left as in vid, but in the second, 0x0 
is bottom left as in postscript

Ahhhhh. I see now.

but I can't use 0x0 as the image is offset from there in both instances

so, I'm using the actual points where the top left of the image starts 
and the bottom right where the image ends ... surrounded by a little 
whitespace

; How about something like this:

remap: func [a-ul a-br b-ul b-br pt] [

 res-x: (b-br/x - b-ul/x) / (a-br/x - a-ul/x) * (pt/x - a-ul/x) + 
 b-ul/x

 res-y: (b-br/y - b-ul/y) / (a-br/y - a-ul/y) * (pt/y - a-ul/y) + 
 b-ul/y
	as-pair res-x res-y
]
remap 4x26 38x729 234x355 600x62 4x26
remap 4x26 38x729 234x355 600x62 38x729

Wow !

passes the first tests :)

I'll plug her in and see if it works ...

I think it's working :)  Thanks Gregg.

(don't forget to declare locals res-x and res-y)

Glad to hear it Graham. Thanks for catching that Anton; quick hack 
you know. :-\

I was wondering why this happens:


>> a: does [try [2 / 0]]
>> a

** Math Error: Attempt to divide by zero
** Where: a
** Near: 2 / 0
>> try a

** Math Error: Attempt to divide by zero
** Where: a
** Near: 2 / 0
>> error? a
** Math Error: Attempt to divide by zero
** Where: a
** Near: 2 / 0



Whereas when ERROR? is put inside the function, it catches the error 
properly.


>> a: does [error? try [2 / 0]]
>> a
== true



Is returning a value or an error considered an extra step that causes 
ERROR? not to catch the error in time?

sorry, couple of malformed lines in the above example. I hope you 
can read it.

'try returns "armed" error. That's why there is 'disarm function

>> a: does [try [2 / 0]]
>> disarm a

** Math Error: Attempt to divide by zero
** Where: a

** Near: 2 / 0

I'm just wondering what is happening at the moment of value return. 
There must be an extra step.

The armed error! value is very "hot". error? is the only function 
able to trap this error! value.

is it possible to embed/serialize binding information? I have a fairly 
complex object where functions in it are supposed to be bound to 
their parent context, but when loading, they are bound to 'system 
(or nothing). to solve this, I manually rebind every function, which 
seems rather clumsy. is there a more direct way?

; I'm not sure you can bind whole objects, but you can at least make 
short work of the manual process.  Here's a quickie I've used:

reconstitute: func [object [object!] /local bindings][
	append bindings: [] object
	foreach word next first object [
		switch type?/word word: get in object word [

   function! [foreach context bindings [bind second :word :context]]
			block! [foreach context bindings [bind :word :context]]
			object! [reconstitute :word]
		]
	]
	remove back tail bindings
	object
]

is there an in-memory version of save/header "" header-obj ?

save/header data: #{} "" [Title: "Data"]

probe to-string data

thanks

(still reviewing your previous answer, so I'm not just thanking you 
for that ;-))

On the previous answer, you could probably modify it to incorporate 
objects nested in blocks.  Also, it does not reconstitute some of 
the subtle uses of nested objects, such as the reusable 'feel objects 
in faces.  Sadly.

yes, that's why I wanted to make binding cues inside the object, 
so I can load it, and it will automatically bind to wherever is needed.

Yep, if you were to do -- context: [a: b: :an-object] -- while you 
could bind a reconstituted 'a and 'b to 'an-object, it would be clones. 
 Possibility: where you are working with faces, you could specifically 
change eg. the feel to lit-word/path before saving, then allow a 
'reconstitute-like function replace that value with the related object. 
 It's a little messy, but still such functions could still be nearly 
as short...

I think I'll keep my method for now. It's actually simpler for me 
to understand than the above. :-/

thanks for your work.

anyone know of a function to calculate the relative path between 
two branches in a file system?

I think I'm figuring it out. will post the function when I'm done.

I want to sync some files on a server. what is the usual method? 
This file will be a rebol script so I thought placing a "version:" 
in the rebol header would be logical. I tried to "load/header" but 
I get the whole script and its no evaluated so I can not just get 
the  version value.

Yes, you must write your own version parsing function which loads 
only a part of the file.

Alan;  You can try  var: load/header/next   first var will be the 
header as object, second var will be the rest of the script as a 
string.   var/1/version should be your tuple!  (assuming you use 
tuple).  In terms of the evaluation it is deemed "light", values 
but not code.  So   version: 3.2.1 ok,  version: to tuple! [3 2 1] 
 won't be a tuple, var/1/version will be 'to   So Anton is correct.


Another thing to check out the mezzanines (from View)  load-thru 
  read-thru  and the source for exists-thru?  These may have some 
hints for what you want.

Is there an opposite function to SUFFIX? like PREFIX? or so to get 
the filename without extension?

head clear find/last copy a #"."

to file! head clear find/last copy %prefix.suffix #"."

copy/part f -1 + index? find f "."

to file! first parse f "."

If it wasn't for that extra TO-FILE in SUFFIX?, you'd just use COPY/PART:


>> suffix?: func [path [any-string!] "Return the suffix (ext) of 
a filename or url, else NONE."] [if all [path: find/last path %. 
not find path #"/"] [path]]
>> file: %my.test.file.txt
== %my.test.file.txt
>> copy/part file suffix? file
== %my.test.file

AMacleod, I found my version? function in
http://anton.wildit.net.au/rebol/library/dir-utils.r
(after remembering where my website is)

I'm just curious if there is a way to make a function think an argument 
was passed to it even though an argument wasn't passed to it.

a: func [b [word! unset!]] []