World: r3wp

This will show the pdf with console: call %"/C/Program Files/ACI32/PDFS/X11070003.pdf"

This will start acrobat with no cosole: call %"/C/Program Files/Adobe/Acrobat 
6.0/Acrobat/acrobat.exe"

But I can not combine them as I did with using windows file path 
notation

AFAIK there is no way to supress the console window in R2.

>> to-rebol-file "C:\Program Files\Adobe\Acrobat 6.0\Acrobat\acrobat.exe"
== %/C/Program Files/Adobe/Acrobat 6.0/Acrobat/acrobat.exe

if you have PRO license, you should use ShellExecuteA routine from 
shell32.dll

amacleod, try this:

    call [%"/C/Program Files/Adobe/Acrobat 6.0/Acrobat/acrobat.exe"  
    %"/C/Program Files/PDFS/file.pdf"]

If the application starts and returns immediately, the console will 
close before you get a chance to see it. I think acrobat is one of 
those programs. If you are opening this pdf in the free reader, I 
would seriously suggest upgrading to reader 8.1.1 for security reasons, 
and because it's better.

CALL will do the to-local-file translation for any REBOL files it 
is passed (even in that block above, though not in nested blocks), 
and even wrap the filenames in quotes just in case they have spaces 
in them.

BrianH, Your suggestion above works. I had tried the same thing but 
without the block...stupid me. Thanks!

Any binary parse wizards ever tried to tackle the on disk file format 
that postgresql uses to store row data?


I'm looking through the docs trying to get a handle on how tough 
it is.

http://www.postgresql.org/docs/8.1/static/storage.html
and

http://www.postgresql.org/docs/8.1/static/storage-page-layout.html


give a fairly detailed starting place, plus the source of course 
but my C is so rusty I think reviewing the raw data is going to be 
easier.


We are trying to recover some data that was deleted (marked for) 
by accident.  We basically need to find the serial key value and 
associate it with a text value for each row so we can rebuild the 
table and not lose the relationships that key off that serial numeric 
value in other tables.


There are some good examples of binary parsing in the rebol.org script 
library so I know rebol can help write out a text version of the 
two values if we can get a handle on the structures involved.


I'm open to suggestions or advice, this is not critical but would 
be a nice win to recover the key data.

I'm quite interested and I may give it a try... but I don't know 
when

but I have only Postgresql 8.0 I'm not sure how much it's different

the header is same

here is a basic... http://box.lebeda.ws/~hmm/rebol/pgsql-db.rthis 
reads the postrge's file per pages... but I'm not sure what to do 
with the data inside and have to do something else now

Oldes, thanks for getting us started on the postgresql data parsing!

Thanks, Rod.

is it possible to get the name of the script that was run with 'do?

from inside that script, that is

system/script/path gets the directory of the script, and you can 
put the name of the script in its header with the File field.

ah yes, but it doesn't work if you 'do other scripts inside that 
script. I guess I'll figure out some other method.

the goal is only to be able to relaunch the script.

If script %a calls script %b, b's system/script/path is set to its 
directory, and b's system/script/parent/path is set to a's directory.

perhaps a quick routine to find the root script?

If we set b's File field to %b in its header, we can get that value 
for relaunching or whatever.

x: system/script
while [x: x/parent] [root-dir: x/path]

does that work? x/parent keeps being an object here.

perhaps also ask if x = x/parent

The top parent is none.

x will never equal a/parent.

oh, I didn't get that before, but I do now. odd.

a/ -> x/

I see the problem now. Or at least a problem: If you 'do the same 
script multiple times in the console, the system/script object depth 
increases.

another note: parent equals none the same time as the script header 
does, so to properly check whether you really don't have a parent, 
if you want to see the header, you should check parent/header, not 
just parent.

No, the script object depth only increases if the script depth increases. 
When a script ends, system/script is set to system/script/parent.

ok, now I'm wondering why the script depth would increase.

Is the script calling itself, or does it return and have an outer 
trampoline script call it again?

Or is the script creating some functiona and objects and returning 
so the caller can use them, then being reloaded by the caller to 
do this all over again? I wrote a server application in 2000 that 
acted that way, with scripts migrating the data from the previous 
incarnation still in memory.

the script calls 4 other scripts once. one of these contains an object 
that must know the name of the launched script. that's basically 
all.

Does the object need to know the name of its own script, the calling 
script, or the script that is calling the code in the object?

it needs to know the name of the launched script. there can be any 
number of levels down to the script that was used to launch the script 
containing the object. but I have solved the problem now. I was just 
wondering why the script object depth increased on each run of the 
main script.

Any maths guys here?

I need to map a pair from one coordinate system to another.

So, I have two pairs initially, specifying a top left and bottom 
right.
eg. 4x26 => 38x729, and 234x355 => 600x62

So, I need a function that works like this

remap 4x26 38x729 234x355 600x62 n1xn2
=> n3xn4


that is, it takes the 2 sets of pairs as argument, and a new pair, 
and returns the value of the new pair mapped to the new coordinates.

I guess it's just linear algebra

What I am doing is taking two sets of pairs on a PNG image, and trying 
to map to the EPS image as postscript coordinates.

Probably not something as simple as this, though, eh?

remap: func [a-ul a-br b-ul b-br pt] [
	res-x: pt/x / (a-br/x - a-ul/x) * (b-br/x - b-ul/x) + b-ul/x
	res-y: pt/y / (a-br/y - a-ul/y) * (b-br/y - b-ul/y) + b-ul/y
	as-pair res-x res-y
]

(untested)

looks close , but not right though as if i feed it one of the first 
two pairs, it should display one of the second pairs

>> 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.