AltME groups: search

I want a way to generate mp3 voice mail .. this does the mp3 encoding.

We use the same code to configure the unit. To generate the admin 
tools. To design the networks. And all uses the same code base. Everything 
runs of different OS.

I need a solution that can hold alot of content that might be generated 
in one day - far more than we generate in the REBOL world in one 
day.

What if you want to generate code, eg:
>> reduce ['return: [integer!]]

== [return [integer!]]   ;  I wanted this --->  [return: [integer!]]

Anton: What if you want to generate code, eg:
>> reduce ['return: [integer!]]

try reduce [first [return:] [integer!]]

test-address-import: func [

 {Returns true if pass, false if discrepency and none if failed with 
 error.}
	limit [integer!] "Number of TO address to generate."
	/quiet "Does not display error."
	/local to-list eml sep msg obj
] [
	to-list: copy {} sep: ""
	repeat i limit [
		eml: to-email join "test-" [i "@test.com"]
		repend to-list [sep {"'} eml {'" <} eml {>}]
		if empty? sep [sep: {,^/	}]
	]

	msg: replace copy {Date: Thu, 12 Feb 2004 11:41:49 +0100
From: test <[test-:-test-:-com]>
MIME-Version: 1.0
To: TO_LIST
Subject: [REBOL] test message - edited copy of real message
Content-type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 8bit
Sender: [rebol-bounce-:-rebol-:-com]
Reply-to: [testing-:-testing-:-com]
Status:   


Test message.
} {TO_LIST} to-list

	either error? set/any 'result try [
		obj: import-email msg
		limit = length? obj/to
	][if not quiet [print mold disarm result] none][result]

]

If this fonctionnality remains payant we at most need to rethink 
internally the way to work or build an intermediate library loading 
system script that allows people to load the library without the 
needs of wrtiting by their howns the bridge or a tools that take 
a makefile of a sample program and the include file and generate 
a rebol script bridge for any library that must be loaded to use 
the wanted libraries thos bridges script files must then be supplyed 
as the libraries and the program script in rebol that exploit those 
libraries

Gabriele, can you add an extra bit to the details here http://www.rebol.net/cgi-bin/rambo.r?id=3837&

A reason for wanting this is to be able to generate an image of what 
the style looks like without opening a window, eg. for documentation.

(It's good to see what the original reasons are for each bug report. 
Should make fixing them more satisfying too.)

I suspect that this nesting behavior was intended to better enable 
using REBOL to generate code in languages with C-like block structure. 
I know it is useful for putting Javascript in generated web pages. 
There may even be such generation of C code as part of the REBOL 
build process. For that matter, it can be useful when specifying 
REBOL source code in strings when that code also contains strings.

things like key-up, ability to generate events, etc., simply things 
which were planned, don't yoy remember, Kru ;-)

Is this a one fire mechanism?  When I do this, and get an error, 
and print it .. or whatever, and if I generate the same error again, 
it then drops to the standard error handler ignoring my error handler.

what does this mean?


   * Generate 64 bits of randomness from a good, well-seeded random 
   number generator;

ie. how large a seed do I need to get 64 bits ?

http://www.jwz.org/doc/mid.html
	

 In summary, one possible approach to generating a Message-ID would 
 be:

    * Append "<".


    * Get the current (wall-clock) time in the highest resolution to 
    which you have access 

    (most systems can give it to you in milliseconds, but seconds will 
    do);


    * Generate 64 bits of randomness from a good, well-seeded random 
    number generator;


    * Convert these two numbers to base 36 (0-9 and A-Z) and append the 
    first number, 

    a ".", the second number, and an "@". This makes the left hand side 
    of the message ID be only about 21 characters long.


    * Append the FQDN of the local host, or the host name in the user's 
    return address.

    * Append ">".

I used 1'000'000 here .. don't know if it's enough

    generate-messageid: does [

     rejoin [ "<" enbase form now/time/precise "." enbase form random 
     1000000  "@" server-name ">"]
	]

generate-messageid: does [

    rejoin ["<" enbase checksum/secure random/secure mold system/error 
    "@" server-name ">"]
]

generate-messageid: func [eml [string!] [

    rejoin ["<" enbase checksum/secure random/secure eml "@" server-name 
    ">"]
]

I just submitted to rebol.org a 4 line script  and it took me 1 hour 
is it normal to spend 1 hours on the header formating  for just a 
copy past ?   Can't we in 2011 get ride of it and have a form that 
you fill and generate the header for your script ? This is the numberone 
pain in the ass thing that makes me vomit each time i use rebol.org 
....

I just submitted to rebol.org a 4 line script  and it took me 1 hour 
is it normal to spend 1 hours on the header formating  for just a 
copy past ?   Can't we in 2011 get ride of it and have a form that 
you fill and generate the header for your script ? This is the numberone 
pain in the ass thing that makes me vomit each time i use rebol.org 
....

It is entirely possible to parse blocks into text markup, when you 
want to allow code to automatically generate its own document (that 
is a hierarchical source, source code)

More precise: 2-pass script. First parse, second generate.

as I said earlier, there are thousands of products which the core 
of make-doc from RT will generate.  It is pretty easy code to extend, 
once you get the hang of it.  Make-doc2 gives us a much better springboard 
to do things right, with a better user experience out of the box.

Exactly, which means each emitter then has to generate a TOC and 
number the section headings - this content manipulation should not 
be the concern of each and every emitter! ;)

nice examples, Geomol...curious the look of the markup needed to 
generate that.  I think you said you surround the text with nestible 
tags, using a heirarchical structure?

So, I have made some enhancements to MDP and put a beta online. You 
can find it at: http://www.robertmuench.de/download/make-doc-pro.r

The following changes have been made:
*Bugs fixed:*

#State tracking flags weren't correct, could lead to strange results 
when using tables where cell text used inline markup. Especially 
in site-mode.

*New Features:*

#Code can now be included via ~=include code <filename>~ where the 
included code will be automatically indented and hence handled like 
an example by the output format emitter.

*Programmatic changes:*
#Celeaned up the global word pollution (Thanks to Ahsley Truter)

#Renamed ~generate-files~ function to ~scan-doc~ to meet MD2 wording

nope :P and won't be for pdf maker 2 either. but you can use the 
code in the pdf maker to generate the objects and the xref

(the xref generator in the pdf maker only works for the main xref 
of the file, not the change xrefs, but it should be easy to change 
it to generate a change xref)

=image 
    file: images/a picture.gif 
    size: 200x300
    caption: some caption below the picture 
    desc: some description for the picture


I'm trying to extend Makedoc2 for a project to generate a xml dialect 
and I need much more information to certain elements - e.g. images 
- so I'm trying to make it as easy as possible for the user. The 
above is what I actually wanted to parse - but the order of the information 
is supposed to be free and I can't and don't want to use rebol datatypes 
which might be the first thought to make the parsing easier, because 
normal people don't want to learn too many rules for all these things. 
So the b and c in the example corresponded more to the caption and 
desc in the above example.

Ah, recursive rules. :) I pushed my variables onto a stack when recursing, 
then popped them off when returning.

That tends to bloat the code a fair bit. ( push-vars [a b c] recursive-rule 
pop-vars [a b c] )

so then you get to thinking to generate this code automatically with 
a make-recursive-rule function, which takes a 

parse rule, looks for recursion in it, then surrounds it with push-vars 
and pop-vars for you (kind of macro expansion).
Or I did something like that, anyway.

... but should not be simpler, so I wonder - so far, as you can see, 
mark-x is not finished, so it is ignored. How to catch this case 
properly and eventually generate error, send email, write to log, 
whatever?

the simplest way may be to just generate all the permutations.

We need the C code that they use to generate the checksum. That way 
we might see some comments or code which tell us how it is computed 
and if rebol's builtin checksum also does it.

If your server goes down, your remaining client connections will 
timeout and generate an error value.

But, it became clear to me that the package database does not appear 
specific enough to be able to generate a solid set of packages in 
that manner.

Ah, I see.  Still, it doesn't seem most elegant.  Another option 
would be to generate the permutations dynamically, but again, not 
so elegant...

tests: substitute [
		generate-test [
			set variable value
			eq variable 1
		] [value] [1 2]
		return "OK"
		label fail
		do discard [print ["test:" mold testing "failed"] halt]
	] [generate-test]

Thanks Chris, that's a handy little util. The only thing it can't 
do is change PNG color depth (useful if you generate your PNGs from 
REBOL). Any ideas on that score?

Henrik - most of the free utils of archivers allow you to generate 
so called "autoextracting archive"

First question: Have you considered using the preprocessor yourself 
to generate a script to interpret? See %prebol.r and %prerebol.r 
in the SDK. Second question: Try the -s parameter to the interpreter, 
it will turn security off.

tab-panel: make face [
		color:	none
		pane:	[]
		l-arw: none 
		r-arw: none
		dir-buttons: false
		feel:	make default-feel [
			redraw: function [face act pos] [test-size test-wid] [
				if act = 'show [face/pane/1/size: face/size - 0x20
; 					
; 				 	test-wid: face/pane/1
; 		    		test-size: test-wid/size/x
; 					if greater? test-size face/size/x  [
; 						either not dir-buttons [
; 				 			dir-buttons: true
; 		    				insert tail face/pane face/l-arw: make arrow [
; 	        					size: 20x20
; 		    					offset: as-pair (face/size/x - 40) 0
; 		    					data: 'left
; 		    					action: [print "you clicked left" ]
; 	     					] do face/l-arw/init
; 		    				insert tail face/pane face/r-arw: make arrow [
; 	        					size: 20x20
; 		    					offset: as-pair (face/size/x - 20) 0 
; 		    					action: [print "you clicked right" ]
; 		    					data: 'right
; 	     					] do face/r-arw/init
; 	 					][	
; 	 						face/r-arw/offset: as-pair (face/size/x - 20) 0 
; 	 						face/l-arw/offset: as-pair (face/size/x - 40) 0 
; 	 					]
; 	     			]

; 			    print "la liste des bouttn est plus grande  que ce que l'on 
voit!!!" 
		    	]
			]
		]
		
		init:	has [tab-offset last-tab] [
			;	create main display area
			insert pane make face [ offset: 0x20 edge: default-edge]
			;	add tabs
			tab-offset: 0x0

   insert tail pane make face [ offset: 0x0 pane: [] color: none ]
			container: last pane

   insert container/pane make face [ offset: 0x0 pane: [] color: none]
			foreach [title spec] data [
				insert tail container/pane/1/pane make face [
					offset:	tab-offset
					size:	1x20
					pane:	[]
					text:	title
					effect:	reduce ['round edge-color 5 'draw copy []]
					resize:	none
					font:	make default-font [align: 'center valign: 'bottom]
					para:	default-para
					feel:	make default-feel [
						over: func [face act pos] [
							either act [

        insert face/effect/draw compose [	; compose required for AGG betas
									pen over-color
									line 3x1 (as-pair face/size/x - 4 1)
									line 2x2 (as-pair face/size/x - 3 2)
									line 1x3 (as-pair face/size/x - 2 3)
								]
								show face
							][

        if face/parent-face/parent-face/parent-face/pane/1/pane <> face/data 
        [	; clear unless selected
									clear face/effect/draw
									show face
								]
							]
						]
						engage: function [face act event] [pf old-face] [
							if event/type = 'down [
								pf: face/parent-face
								pf3: pf/parent-face/parent-face

        if pf3/pane/1/pane = face/data [return]	; has a new tab been selected?
								clear face/effect/draw
								old-face: pick pf/pane pf3/data			; find previous tab
								old-face/resize: pf3/size				; remember last size
								old-face/size: old-face/size - 0x1		; deflag old
								clear old-face/effect/draw
								face/size: face/size + 0x1				; flag new
								face/feel/over face true 0x0
								pf3/data: index? find pf/pane face		; set new pane#
								pf3/pane/1/pane: face/data				; init tab panel
								if pf3/size <> face/resize [				; recursive resize
									span-resize pf3/pane/1 pf3/size - face/resize
									face/resize: pf3/size
								]
								show pf3
							]
						]
					]
				]
				last-tab: last container/pane/1/pane

    last-tab/size/x: 10 + first size-text last-tab	; set tab title width

    display/layout "" spec last-tab					; generate tab spec into tab 
    pane
				last-tab/data: last-tab/pane					; swap pane into data
				last-tab/pane: none								; clear pane
				last-tab/resize: size							; original panel size

    tab-offset/x: tab-offset/x + last-tab/size/x	; set offset for next 
    tab title
			]
			print "size et countainer a la con !!"
			probe size/x
			container/size: as-pair size/x 20
			probe container/size/x
			container/pane/1/size: container/size

   container/pane/1/pane/1/size: container/pane/1/pane/1/size + 0x1	; 
   flag 1st tab
			data: 1								; set pane#
			pane/1/pane: container/pane/1/pane/1/data			; init tab panel

   container/pane/1/pane/1/feel/over container/pane/1/pane/1 true 0x0	; 
   flag first as active
		]
	]

Ashley, I had also wrote a VID integer-edit style, then I decided 
to make a single function to generate pair, integer and decimal-edit 
styles. I could convert this in future. It kind of violates your 
"each widget self-contained" design feature, but the code shrinkage 
was too hard to resist, and the potential is there to support more 
datatypes...

That's just broad strokes, but it should give you an idea. You could 
even generate this kind of thing with the prebol preprocessor.

From the AGG Group: "Having our own SVG icons is a good idea as we 
don't have to worry about licence / distribution issues and we can 
tweak the generation to make it as AGG compatible as possible. To 
do that we need to settle on *one* tool so as we generate consistent 
SVG code, and we should generate SVG that uses a single unit of measure, 
preferably pixels, as it's a real pain trying to handle multiple 
units of measure within the same file."

Reasons:

	1) Solid authoring tools
	2) Access to a large number of existing SVG icons (if needed)
	3) The standard for vector graphics
	4) Interoperability

 5) Publicity ("we support SVG icons", as opposed to, "our icons are 
 just REBOL blocks")


If we generate our own content then there is nothing stopping us 
having icons in source form (SVG) *and* pre-compiled form (draw block).

SAX apis don't work like that. They generate a series of events, 
not a series of data.

in the moment i play a little bit with xml-parse.r, it has a lot 
of things done, some are still open (like  <!ENTITY ...> parsing) 
and it is like SAX - I try to implement some handlers to learn REBOL, 
but it's still in progess. A benefit of xml-parse is, that there 
would be only one parser and some kind of standard API and the handler 
could then generate rebxml or some other desired format

You can do some structural pattern matching with parse rules, but 
with how parse is currently implemented it can be a little awkward. 
The lack of arguments to parse rules make recursion quite difficult, 
and the lack of local variables make the rules difficult to use concurrently. 
It is difficult to examine both the data type and the value of elements 
in block parsing, to switch to string parsing mode for string elements, 
to parse lists, hashes or parens, to direct the parse flow based 
on semantic criteria (which is needed to work around any of these 
other problems).


And don't even get me started on the difficulties of structure rebuilding. 
The thing that is the most difficult to do in parse is the easiest 
thing to do with regexes: Search and replace. Didn't we make a web 
site years ago collecting suggestions for improving parse? Wasn't 
a replace operation one of those suggestions? What happened with 
that?


Structural pattern matching and rebuilding currently has to be done 
with a mix of parse and REBOL code that is tricky to write and debug. 
If parse doesn't get improved, I'd rather use a nice declarative 
dialect, preferably with before and after structures, and have the 
dialect processor generate the parse and REBOL code for me. If that 
dialect is powerful enough to be written in itself then we'll really 
be cooking.

RSP, I use it to generate RSS feeds from Cheyenne's blog.

<xs:complexType name="MessageType">
<xs:sequence>

<xs:element name="Header" minOccurs="1" maxOccurs="1" type="HeaderType" 
/>

<xs:element name="Body" minOccurs="1" maxOccurs="1" type="BodyType" 
/>
<xs:element name="Error">
<xs:complexType>
<xs:sequence>
<xs:element name="Code" minOccurs="1" maxOccurs="1">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:pattern value="600|601|602|900" />
</xs:restriction>
</xs:simpleType>
</xs:element>

<xs:element name="DescriptionCode" minOccurs="0" maxOccurs="1" type="an..3" 
/>

<xs:element name="Description" minOccurs="0" maxOccurs="1" type="an..70" 
/>
</xs:sequence>
</xs:complexType>
</xs:element>


If I have the schema looking like this ( no examples I'm afraid ), 
is something like this what I have to generate
<header> ... headertype .. </header>
<body>
<error>
<code> 600 </code>
<Descriptioncode />
<Description />
</error>
</body>

How are people creating large xml documents where there are large 
numbers of elements and where the data is being drawn from a database.

Model the document first as a Rebol object!, and then generate the 
xml from the object?

Some databases have the ability to generate XML directly. That approach 
can be faster, depending on how much data the database has to process. 
It all depends on what database you are using though.

Probably more a pure HTML question, and showing my complete lack 
of HTML knowledge these days, but how would I go about automatically 
updating a device (an IP Phone in my case) that has a page (http://10.1.1.7/admin.html) 
with a whole bunch of phone numbers in separate fields and a submit 
button that posts changes back? I can generate the page with the 
data I want submitted back, but I can't work out how to mimic pressing 
the submit button from a specific URL.

Do you really need the GNU make to generate all the .r scripts ??

print "Play a simple tone..." ; (init event system too)

; Generate a sine wave tone (1 cycle of the wave):
tone: #{}
for phase 1 360 6 [
	val: 32768 + to-integer 32767 * sine phase

 repend tone [to char! to integer! val / 256 to char! to integer! 
 val // 256]
]

; Set up the sound sample parameters:
sample: make sound [
	rate: 44100
	channels: 1
	bits: 16
	volume: 0.5
	data: #{}
]

; Repeat the sine wave for 1000 cycles:
loop 1000 [append sample/data tone]

; Play the tone now:
? sample
sound-port: open sound://
insert sound-port sample
? sample
wait sound-port
close sound-port

print "Play a ping sound..." ; (init event system too)

    ; Generate a ping waveform as a binary value:
    ping: #{}
    for amplitude 500 1 -1 [
        for phase 1 360 16 [
            val: 128 + to-integer 127 * sine phase
            val: amplitude * val / 500
            append ping to-char val
            ;append ping to-char 256 - val
        ]
    ]

    ; Set up the sound sample parameters:
    sample: make sound [
        rate: 44100 / 2
        channels: 1
        bits: 8
        volume: 0.5
        data: #{}
    ]

    ; Make the ping sound 10 times:
    loop 10 [append sample/data ping]

    ; Play the sound now:
    sound-port: open sound://
    insert sound-port sample
    wait sound-port
    close sound-port

print "Play a ping sound..." ; (init event system too)

    ; Generate a ping waveform as a binary value:
    ping: #{}
    for amplitude 500 1 -1 [
        for phase 1 360 16 [
            val: 128 + to-integer 127 * sine phase
            val: amplitude * val / 500
            append ping to-char val
            append ping to-char 256 - val
        ]
    ]

    ; Set up the sound sample parameters:
    sample: make sound [
        rate: 44100 / 2
        channels: 2
        bits: 8
        volume: 0.5
        data: #{}
    ]

    ; Make the ping sound 10 times:
    loop 10 [append sample/data ping]

    ; Play the sound now:
    sound-port: open sound://
    insert sound-port sample
    wait sound-port
    close sound-port

As you add together a larger number of waves, you will find the maximum 
amplitude is typically much less than the total of all the wave amplitudes. 
It might be easier to generate all the samples of the complex wave 
(using decimal!/float), keeping track of the maximum value, then 
scaling it to 8 or 16 bit integers afterwards. It would be nice to 
have a precise mathematical way of calculating the maximum peak values 
in advance, though...

I've seen people use a free SWF tool to generate flash movies of 
what's going on, on the desktop. is it something like that you want?

Reichart, you are working on defining the paradigm of the language. 
I think that is the right direction to follow to generate a faster 
learning map of Rebol.

I've been thinking about temporary variables generated by rewrite 
rules. I have a way to generate extremely unlikely variable names, 
but no way to bind them in the rebcode function after they've been 
added. Any ideas?

To use only one temporary variable may require a topological sort 
of the expression, if it is at all possible. I want to be able to 
generate anonymous temporaries if necessary.

shadwolf - the nice thing is, that for specific domain, you can create 
your own sub-language using parse and let it generate rebcode for 
you :-)

Fortunately, this kind of code is easy to generate as well. The rewriter 
can do some basic transforms to make the syntax that you write easier 
for you. For example, Volker's suggested alternate syntax (to my 
best guess of what he meant) could be implemented with something 
like this:

use [dest here rule r1 r2 r3 rs0 rs1 rs2 rs3] [

    foreach rule [r1 r2 r3 rs0 rs1 rs2 rs3] [set rule make block! 10]
    insert rs1 ['label word! | '?? word |]
    parse rebcode*/opcode-rule [
        some [here: lit-word! [
            '| (
                insert tail rs0 reduce [here/1 '|]
            ) |
            'word! '| (

                unless find rs1 here/1 [insert tail r1 reduce [here/1 '|]]
            ) |
            'word! [block! | word!] '| (

                unless find rs2 here/1 [insert tail r2 reduce [here/1 here/3 '|]]
            ) |
            'word! [block! | word!] [block! | word!] '| (

                unless find rs3 here/1 [insert tail r3 reduce [here/1 here/3 here/4 
                '|]]
            ) |
            into ['integer! '| 'word! | 'word! '| 'integer!] [
                '| (
                    insert tail r1 reduce [here/1 '|]
                    insert tail rs1 reduce [here/1 'integer! '|]
                ) |
                [block! | word!] '| (
                    insert tail r2 reduce [here/1 here/3 '|]

                    insert tail rs2 reduce [here/1 'integer! here/3 '|]
                )
            ]
            [block! | word!] [
                '| (
                    insert insert tail rs1 copy/part here 2 '|
                ) |
                [block! | word!] [
                    '| (

                        insert insert tail rs2 copy/part here 3 '|
                    ) |
                    [block! | word!] '| (

                        insert insert tail rs3 copy/part here 4 '|
                    )
                ]
            ]
        ]]
    ]

    foreach rule [r1 r2 r3 rs0 rs1 rs2 rs3] [clear back tail get rule]
    rule: [

        set dest set-word! here: r1  #==> (here/1) (to-word dest) (dest) 
        .

        set dest set-word! here: r2  #==> (here/1) (to-word dest) (here/3) 
        (dest) .

        set dest set-word! here: r3  #==> (here/1) (to-word dest) (here/3) 
        (here/4) (dest) .
        set dest set-word! here: rs0 #==> (here/1) (dest) .

        set dest set-word! here: rs1 #==> (here/1) (here/2) (dest) .

        set dest set-word! here: rs2 #==> (here/1) (here/2) (here/3) (dest) 
        .

        set dest set-word! here: rs3 #==> (here/1) (here/2) (here/3) (here/4) 
        (dest) .
        set dest set-word! #==> .
    ]
    rebcode-define rule
]

And, I not just need to generate XLS files I need to read data from 
XLS files as well that don't use an XML format.

Has anyone used these dialects to generate server side Excel spreadsheets 
and then returned them to the browser?

Volker compilation of rebol is due to context free grammars. If you 
take this restriction you could probably have a bootstrap of rebol. 
But you can not compile just any rebol program. So this is a problem.

We are talking about bootstrapping. There is no need to compile every 
program. Its only needed to have a subset to build the interpreter. 
And that one must be able to generate machine-code.

For inspiration, Wright looked to the 

demo scene," a group of (mostly European) coders who specialized 
in doing a whole lot with a little bit of code. Their procedural 
programming methods were able to, for example, fit an entire 3D game 
in 64K, using mathematics to generate textures and music, etc. "I 
just found this incredibly exciting," Wright confesses, describing 
the kinds of work that he saw come out of the demo scene."


So here's what he did: he recruited an elite strike team of coders 
(who, if you were to believe his slideshow, dressed like ninjas) 
and put them in a 

hidden facility" to experiment with new ways of giving the user powerful 
tools and generating tons of dynamic content without armies of content 
creators. Best of all, he fired up a demo and showed his audience 
the results... "

this is almost a REBOL like way to create games :-)

Jaime, just had a look at 'migrations' and it's not the same at all.. 
 here's the pseudo code just to change the db with rails..

    * Step 1: Create a migration with script/generate migration WhatImChanging
    * Step 2: Modify your generated migration file in db/migrate
    * Step 3: Run rake migrate

    * Step 4: Revel in the fact that your database is converted to the 
    newest schema!


With Framewerks you never alter the DB.. it's a black box where data 
goes in and out.

The new field OldID holds the former primary key.
You have to  join via the oldID instead of the primary key.

If you can not alter your select statement, maybe you can generate 
an adequate view.

PDF is also only a subset of postscript, created so you don't need 
to compile your docs everytime they need to be displayed. PDFs are 
static. You still need postscript to do the actual printing AFAIK. 
The trick would be not necesarily to generate a PS file, but the 
data that could be fed to the printer through LP.

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=ean13.r
<--- did this one a year ago. it uses PDF maker to generate barcodes

it can also generate bitmapped barcodes. works only with EAN13 format 
though

Adobe gives permission to anyone to:
Write drivers to generate output 
consisting of PostScript language commands.
It's from the ref manual.

louis, the one on rebol.org seems to be a bit old. the one I have 
locally can generate bitmaps as image! in 1x, 2x, 4x and 8x size 
and vectors for PDF Maker. it can generate an EAN13 code with the 
correct checksum. it doesn't save to file, but it's only a couple 
of lines of code to do that

I am previewing my draw doc, and when I generate the ps file, the 
coordinates are to the north-east in the ps file.

Need to generate bar codes in postscript ?  Here's some software 
on a MIT/X-Consortium license http://www.terryburton.co.uk/barcodewriter/

So, I can use it to generate graphs, and ordinary text for printing 
.. but fancy flowing text needs more work.

Henrik, yes we can add some 'options' for clockwise/anticlockwise 
etc. but keep in mind every such decission at runtime steals performance 
so sometime is better to generate the DRAW dialect with properly 
converted values.

geomol, I think that it should be kept at a low level. This way I 
or someone else can build a library of standard things on top of 
it to generate formatted pages, tables, formatted paragraphs and 
such.

So, generate the output as postscript, and then use gsprint to print 
the postscript file to the epson printer ( default windows printer 
).

A couple of useful PS links:

How to generate portable Postscript: http://alumni.media.mit.edu/~szummer/postscript/

What is the physical size of the page?: http://www.postscript.org/FAQs/language/node64.html

How to use Adobe PostScript language files properly.: http://www-cdf.fnal.gov/offline/PostScript/AdobePS.html

(Look under "Paper bin, tray, size, feed mode, etc. selection", where 
you also find a link to:)
PostScript Sins: http://www.byte.com/art/9508/sec13/art3.htm
Gripes: http://www.cs.wisc.edu/~ghost/doc/gripes.htm

wow, that took a long time to generate.

and that took less than 1 second to generate.

so I think there should be an option to leave that out, or by default 
not have it. I'm guessing most people want to generate and print 
PS file, rather than read and edit them by hand.

So, I'll have to dynamically generate the plugin code.  Sound right?

The poll results should generate a data flow...

so one (actually several)  machines can be a controler and synchronise 
to others which can also locally change their states... and whatever 
they data can generate can be sent to any other machine, including 
the controlers... so you have ONE kernel to handle all aspects of 
your systems.  and its dead easy... and would interface directly 
within any other liquified systems like liquid GL, elixir, globs, 
or eventually GLASS.

and actually generate other data from it  like diffs or comparison 
reports. :-)

Btw, the encapping system for Cheyenne is a little odd : to be able 
to run it in normal mode and encap mode without changing the source 
code, I wrote a special lib emulating the filesystem but in memory. 
I didn't had time yet to check if Ladislav's Include could do the 
job. My encapping system needs to generate a .encap-fs file, so it 
needs that Cheyenne be run in normal mode at least once. I'll document 
that in a few days.

If you want to try this method for windows.. here's what you do.. 


1) download the windows binary from openssl.. ->   http://www.slproweb.com/products/Win32OpenSSL.html

2) Unzip.. and pull out the openssl.exe file from the bin folder.. 
. drop that file into your cheyenne www folder
3) Create a self-signed cert....
3a) run openssl.exe

3b) enter this line: req -x509 -nodes -days 365 -newkey rsa:1024 
-keyout localhost.pem -out localhost.pem
(localhost is the cert name)

3c) answer the questions... when asked 'who are you?' enter your 
domain,  or 'localhost' as I did 

This will generate the cert in your www folder (this is just a demo... 
the openssl server uses it's location as root www folder)

4) Start up the server... enter this line into openssl:  s_server 
-accept 443 -cert localhost.pem -WWW


Now open any file in your Cheyenne www folder using the https:// 
 protocol

You'll want to use OpenSSL to generate a cert for Stunnel to replace 
the default

I've converted my site to https as well using the above howto .. 
only took 2 mins.  As you say, I have to generate a new certificate.

https://www.compkarori.co.nz/

I've haven't grokked modules yet ... using the above, how do I generate 
a standard 404 page?

Graham: maybe I've missed the meaning of your question, you were 
talking from the module perspective ? From within a module's callback, 
to generate a 404, just use : req/out/code: 404 return true

multiple web servers with sessions and database driven content. So 
based on the session ID i generate personalized content

What i did with Framewerks is when a client logs in, I generate a 
random hash, and store it as a cookie, as well as on the DB associated 
with that user.

my best approach is generate html page as much as you can then load 
dynamic stuff with ajax/js.. you need content for SEO so pulling 
everything with ajax isn't the best approach

henrik yess. we can generate the error which is generated from rebol 
using the error object.

generate-content: func [
        is-card content-generator cardid
        dimensions js-files dialog-arr args
        /local
        l_width l_height l_id l_src js-classname
    ] [
        l_src: none
        if not is-card [l_id: cardid]
        switch content-generator [
            "file.fileshare" [
                obj: make quilt/ret-obj [
                    src: build-fileshare
                    title: "Your files"
                    short-title: "Files"
                ]

                quilt/add-dialog dialog-arr "fileupload" "FileShareUpload" rejoi
n [
                    "<p>Please select a file to upload:</p>"
                    quilt/basic-molecule/class/id {

            <iframe src="about:blank" style="border: none; height: 60px; width: 
250px;">IFRAME not displayed!</iframe>

            <p style="display: none;">Uploading file... <img src="/images/Qtask-
Bar-64.gif" /></p>

Thanks but this isn't really such a great piece of code (Windows 
API is doing the real job), even if it fills a gap in REBOL (at least 
for Windows). Btw, in my company, we're using Gab's pdf-maker for 
years now to generate and print all our documents. I made this library 
only because I needed a direct printing solution for a customer and 
I must admit it was a fun work to do.

This is the "dialect" I am using to generate a multi-page letter. 
 Words like "consult-date" "provider" "My-name" are processed by 
a pre-processor to substitute the correct variables.