AltME groups: search

Version > 1.2.48
 does it mean "version upper than 1.2.48" ?
It mean AGG inside so!! It's alpha, with many bugs arround.

Try with a tupple of 4 value with max alpha value :
pen 0.0.0.255

Yes, but should work with AGG ones

With 1.2.106.3.1 and 1.2.107.3.1 : bug with pen color setting in 
draw block:
view layout [box white effect [draw [
	pen none box 10x10 70x20 ; invisible box
	pen black                                ; pen to black
	pen none box 10x30 70x50 ; invisible box
]]]
is ok,  but not
view layout [box white effect [draw [
	pen none box 10x10 70x20 ; invisible box
	pen black text 12x32 "hello" ; pen to black, some text

 pen none box 10x30 70x50 ; without AGG (->1.2.48), invisible box, 
 with AGG (alpha & 1.2.106+), visible box
]]]
Drawing something with a visible pen breaks invisible pen usage.

Another problem with AGG : draw text does not render foreign chars 
:

I wonder what font AGG use ? None of the ASCII 128+ char are displayed, 
 except 251 that show "OBJ" in a box !!

I believe that text rendering will not be included in View1.3 version 
of AGG/Draw. It will come a bit later.

DideC: here is result of the test on my machine: http://www.rebol.cz/~cyphre/agg-ansi.png
It looks normal here imo. But Rebol is not unicode yet so this is 
problematic area. Which version of Windows are you using? What default 
codepage/keyboard/national settings?

Here is what I get with 1.2.48 (standard draw) and 1.2.107 (AGG draw) 
:
http://membres.lycos.fr/didec/images/draw-text-48.jpg
http://membres.lycos.fr/didec/images/draw-text-107.jpg

I have tested on Win2k and WinXP with French Regional settings : 
"French (France)" with "French (France)" keyboard layout.

I don't know the exact code page, 1252 or 850 ? Where can I get it 
?

Vincent, DideC: thanks for the report. I'll try to investigate more. 
But remember the current font handling in Rebol/AGG will be removed 
 for the 1.3 version. (AA and vectorial fonts will be added once 
we found good crossplatform solution for it)

I noticed a crash with rebol 1.2.107.3.1 on win2k with the script 
logo.r (tet program for AGG)  when I resize the windows ...

request : to really test new AGG/draw, we needs a command list. The 
examples helps, but there is now way to tell the presence and purpose 
of optional parameters. Not a full doc, just a simple one line per 
command list, ie : 'line 1st-point [pair!] 2nd-point [pair!] ... 
n-point [pair!]

You can probably figure most of them out with the help of the existing 
AGG docs.

thanks for the draw command list - (time to experiment and crash-test 
draw/agg :-)

This looks like a bug in the AGG compositing engine:

I used succesfully such arrays of floats as argument in my interface 
to AGG...this is no problem IMO

Cyphre do you have documentation on AGG anywhere?

in the current way to handle you need to be very sharp to can interact 
with it from rebol and that why Cyphre you have all my admiration 
for your quick made AGG external exploitation script ...

I presume AGG makes it easier to distort text for a visual Captcha 
...

Why not base REBOL/view widgets on GUI4CLI widgets maybe to save 
time it will be easyier to make the same kind of integration in this 
topic that it has been done for AGG integration

Interesting question -what will trigger it? We now will have - newer 
GC, async core, AGG beta soon ... so what will come next? Maybe something 
from following stuff? - rif, rebin, plug-ins, rebservices? But only 
Carl knows his priorities ....

in front of vi of windows notepad for example it's oriented  Make 
doc Pro (Robert Version) and the look and feel is not has nice that 
if I could include in it the whole widget AGG based set of Cyphre

I like your idea of combining AGG text in there.  I want my console 
to be better than the console in a Peugot car.

hehehe yes but it's a hard stuff to do actually many ppl are interrested 
in maling widgets based or exploiting AGG capability but we are all 
work un linked so the think are not to be release tomorrow ;)

Kaj, why AGG nor Cairo were found as insufficient for Syllable purposes? 
IIRC it is Cairo, which will be used by Mozilla platform or even 
OS-X to render, no?

I'm interested in that, too. :-) What I know is that Arno is making 
deep changes to the video driver framework to add backbuffering in 
the memory of the video cards. We think about AGG as a crossplatform 
rendering library, but Arno is considering the few simple drawing 
functions in Syllable. Things like line drawing are passed directly 
to the video drivers, and if a driver supports 2D acceleration, the 
draw is done in hardware by the video card. In our new framework, 
these drawing operations need to be able to work directly in the 
memory of the video card when necessary. It makes sense that crossplatform 
libraries are not suitable for this deep integration

Kaj, does Syllable use any particular library for gfx? I don't remember 
what you said. am I right you considered even agg, but then your 
gfx guru decided to go his own way?

It is amazing how we Open Source can divide people. There is gray 
all over the place and this is not a black and white issue. I think 
this is not about the armies of developers, or the quality, but about 
the ability to move fwd and construct on the disclosure of code. 
For as much bad applications there are in Open Source, there are 
good ones, OpenBSD, GCC, Postgress, and the one Rebol incorporated 
AGG.

Thats the reason some projects flourish and others die, or lag behind. 
AGG vs Cairo.

So, it has been for me extremely rare to find it educationally useful. 
However, there are the gems, and things like AGG are shining examples. 
I wil grant you that. (But then, I do not try to understand AGG, 
I just accept it for a masterpiece that it is.)

no, I don't have x-windows powered linux here ... I was just curious, 
as there were some features not supported iirc? but maybe I am confused 
because of os-x version ... well, agg does not use fonts, but dunno 
if true or not ...

Also, the AGG font demos on the desktop appear to be broken.

exactly, to the ttf file (for AGG only, not face/text)

exactly, that should work. refer to Cyphre for more details (i think 
agg text on unix is still somewhat experimental)

Is there support for Type I fonts in Linux and View/AGG ?

here it is http://www.compkarori.com/vanilla/display/AGG

I guess Debian rocks.  The console history works correctly in Debian, 
and so do the fonts in AGG draw.

Talked to Rebolinth again .. he never got AGG fonts working except 
by changing to Debian.

AGG fonts only working under Debian distros still?

not sure what dependencies are there ..... there might be some library 
missing, as happened with my Command due to AGG

Guys, please be patient ;) I'll post DRAW change summary in AGG group 
very soon.

Louis I think that depends on how many people work on widgets set 
and what capabilities and imaginativ they are  :) (Cyphre style with 
AGG are trully a good research way )

like transparente popupmenu layer for menu bars in cyphre style sets 
using AGG

The "problem" with either approach (sub-face / draw) is that RT have 
two technologies (TMD / AGG) that could dramatically impact any implementation 
... but we have no idea when these will be available. :(

Asley I know that it. But that's not beacause RT is working on it 
too that we can't work on it right now with yet existent technologies 
and try to figure out how to do it with the limited capabilities 
(bacause we don't have aaccess to entire VM source code) we have. 
In futur once we yet trully have a working solution and VM will have 
officiallly the new technology AGG we could help Carl on TDM  by 
apporting our RTE/IR (ritch text editor input renderer) code to him. 
it's a base of search for us but it means to be one implicitly for 
Carl If we want to save his time and focus it on the important things 
we have maybe to take in charge some od research work  ;)

Graham some indulgence please menu in rebgui are very alpha stage 
vefor sunday I don"t even know  what could be the result of having 
it to rebogui and if it was workable with older non AGG capable rebol/view 
;)

Global Event System: looks like 'menu has to use it, and I don't 
know if we have a real alternative. One thing I've added to 0.1.8 
is a 'keep function that lets you specify what widgets you wish to 
use and sets to none everything not used by those widgets ... so 
if more complex widgets require global events then so be it.


Contributed code: I prefer simple code (that may need to be enhanced) 
over complex code (that may have to be pruned).


Multi-tasking: The RebGUI engine is 90% where it needs to be so I'm 
spending most of my time on widget integration at the moment.


View 2.0: We have to work with what we have, although I have made 
a concession to the future [AGG] with regards to RebGUI's use of 
draw in preference to image + effects.


Dialectise RebGUI: It would be relatively easy to make the specification 
more VID-like by having each attribute specified with a distinct 
datatype (and moving duplicate datatypes such as an 'offset pair 
to a keyword such as 'at) but you pay a big price in code complexity 
and efficiency; and I'm not convinced that inferred attributes ("this 
is a 3-part tuple so it must be a color, while this is a 4-part tuple 
so it must be a span") make code legibility and maintenance any easier.


None of this is to say I can't be convinced otherwise, this is why 
RebGUI is still ALPHA. ;)

Chris noticed that under AGG things are a bit blurred since we use 
draw commands.

Check and Radio-Group? AGG looks better for these than the pre-AGG 
pixelated look. The lines have more definition and weight IMHO. Can't 
see any difference with Tab-Panel and Button.

nb. Shadwolf: as our Arrow style was pre-AGG, glyph rendering does 
not take advantage of the newer draw commands.  Therefore, it may 
be possible to reduce or eliminate calculations used in 'compose-arrow.

OT: the problem with AGG AA on smaller glyphs (not just arrow) is 
that it tends to have an adverse effect on glyph weight.  'course 
it beats bitmaps when it comes to scaling, but even pre-AA Draw gave 
more precise control -- hence the deterioration of the Arrow glyph 
post-AGG.  Illustrated here: http://www.ross-gill.com/r/chevron-test.png

Chris: i think that your example above turned out being a bug in 
gamma handling in earlier versions of view/agg. i'm not sure if it's 
the same on the latest version (especially if you adjust gamma properly 
for your monitor - the default should be ok for crt monitors i think)

Well  In fact I figured out there was lot of problems with my first 
 port of the arrow and arw widgets made by Chris & Gregg  initialy 
for VID/AGG. So now it's mutch better I solve all existing problems 
in my first implementation.  I made lot  of code cleaning. I let 
implementation samples in commentary and comments maide by initial 
authors ;). Can be found here: http://shadwolf.Free.fr/arrow-RebGUI-port.r

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

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							L	[insert tail shape 'line]
							z	[closed?: true]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							S   [insert tail shape 'curv]
							L	[insert tail shape 'line]
							Q   [insert tail shape 'qcurve]
							T   [insert tail shape 'qcurv]
							z	[closed?: true]
							H   [insert tail shape 'hline]
							V   [insert tail shape 'vline]
							A   [insert tail shape 'arc]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

REBOL [
	Title:		"SVG Demo"
	Owner:		"Ashley G. Trüter"
	Version:	0.0.1
	Date:		21-Jun-2005
	Purpose:	"Loads and displays a resizeable SVG file."
	History: {
		0.0.1	Initial release
	}
	Notes: {
		Tested on very simple SVG icons
		Only a few basic styles / attributes / commands supported

  Does not handle sizes in units other than pixels (e.g. pt, in, cm, 
  mm, etc)

  SVG path has an optional close command, "z" ... AGG shape equivalent 
  auto-closes

  load-svg function needs to be totally refactored / optimized ... 
  *sample only*
	}
]

;	The following commands are available for path data:
;
;		M = moveto
;		L = lineto
;		H = horizontal lineto
;		V = vertical lineto
;		C = curveto
;		S = smooth curveto
;		Q = quadratic Belzier curve
;		T = smooth quadratic Belzier curveto
;		A = elliptical Arc
;		Z = closepath

;print: none	; comment out this line to enable debug messages

load-svg: function [svg-file [file! string!] size [pair!]] [

 id defs x y to-color to-byte draw-blk append-style svg-size scale-x 
 scale-y
][
	xml: either string? svg-file [parse-xml svg-file] [

  unless %.svg = suffix? svg-file [to error! "File has an invalid suffix!"]
		parse-xml read svg-file
	]

 unless xml/3/1/1 = "svg" [to error! "Could not find SVG header!"]

 ;unless find ["id" "xmlns"] xml/3/1/2/1 [to error! "Could not find 
 ID header!"]

 ;unless xml/3/1/3/1/1 = "defs" [to error! "Could not find DEFS header!"]

	id: xml/3/1/2
	defs: xml/3/1/3


	;
	;	--- Parse SVG id
	;

	svg-size: either find ["32pt" "48pt" "72pt"] select id "width" [
		switch select id "width" [
			"72pt"	[120x120]
			"48pt"	[80x80]
			"32pt"	[60x60]
		]
	][

  as-pair to integer! any [select id "width" "100"] to integer! any 
  [select id "height" "100"]
	]

	x: to integer! any [select id "x" "0"]
	y: to integer! any [select id "y" "0"]

	scale-x: size/x / svg-size/x
	scale-y: size/y / svg-size/y

	;
	;	--- Helper functions
	;


 to-color: func [s [string!]] [	; converts a string in the form "#FFFFFF" 
 to a 4-byte tuple
		to tuple! load rejoin ["#{" next s "00}"]
	]


 to-byte: func [s [string!]] [	; converts a string with a value 0-1 
 to an inverted byte
		255 - to integer! 255 * to decimal! s
	]

	;
	;	--- Parse SVG defs
	;

	draw-blk: copy []

	append-style: function [
		command [string!] blk [block!]
	][
		x xy pen-color fill-color line-width mode size radius shape
		closed? matrix transf-command
	][
		xy: 0x0
		size: 0x0
		line-width: 1
		matrice: make block! []
		radius: none
		transf-command: none
		
		
		foreach [attr val] blk [
			switch attr [
				"transform" [print "tranform have been found" 
						;probe val halt 
						val: parse val "(),"
						transf-command: first val
						probe transf-command
						switch transf-command [
							"matrix" [ 
								foreach word val [
									if not find word "matrix"
									[ 
										insert tail matrice to-decimal word
									]
								]
							
							]
						]
				]
				"style" [
					foreach [attr val] parse val ":;" [
						switch/default attr [
						
							"font-size" [ ]
							"stroke" [
								switch/default first val [
									#"#" [pen-color: to-color val]
									#"n" [pen-color: none]
								][
									print ["Unknown stroke:" val]
								]
							]
							"stroke-width" [line-width: to decimal! val]
							"fill" [
								fill-color: switch/default first val [
									#"#" [to-color val]
									#"n" [none]
								][
									print ["Unknown fill value:" val]
									none
								]
							]
							"fill-rule" [
								mode: switch/default val [
									"evenodd"	['even-odd]
								][
									print ["Unknown fill-rule value:" val]
									none
								]
							]

       "stroke-opacity" [pen-color: any [pen-color 0.0.0.0] pen-color/4: 
       to-byte val]

       "fill-opacity" [fill-color: any [fill-color 0.0.0.0] fill-color/4: 
       to-byte val]
							"stroke-linejoin" [
								insert tail draw-blk switch/default val [
									"miter"		[compose [line-join miter]]
									"round"		[compose [line-join round]]
									"bevel"		[compose [line-join bevel]]
								][
									print ["Unknown stroke-linejoin value:" val]
									none
								]
							]
							"stroke-linecap" [
								insert tail draw-blk 'line-cap
								insert tail draw-blk to word! val
							]
						][
							print ["Unknown style:" attr]
						]
					]
				]
				"x"			[xy/x: scale-x * val]
				"y"			[xy/y: scale-y * val]
				"width"		[size/x: scale-x * val]
				"height"	[size/y: scale-y * val]
				"rx"		[print "rx"]
				"ry"		[radius: to decimal! val]
				"d"	[
					shape: copy []
					x: none
					closed?: false
					if all [x not number? token] [

          insert tail shape x * either token = 'V [scale-y][scale-x]
  						    x: none
					]
					foreach token load val [
						switch/default token [
							M	[insert tail shape 'move]
							C	[insert tail shape 'curve]
							S   [insert tail shape 'curv]
							L	[insert tail shape 'line]
							Q   [insert tail shape 'qcurve]
							T   [insert tail shape 'qcurv]
							z	[closed?: true]
							H   [insert tail shape 'hline]
							V   [insert tail shape 'vline]
							A   [insert tail shape 'arc]
						][

       unless number? token [print ["Unknown path command:" token]]

       either x [insert tail shape as-pair x scale-y * token x: none] [x: 
       scale-x * token]
						]
					]
				]
			]
		]
		insert tail draw-blk compose [
			pen (pen-color)
			fill-pen (fill-color)
			fill-rule (mode)
			line-width (line-width * min scale-x scale-y)
		]
		switch command [
			"rect" [
				insert tail draw-blk compose [box (xy) (xy + size)]
				if radius [insert tail draw-blk radius]
			]
			"path" [
				unless closed? [print "Path closed"]
				either transf-command <> none  [
					switch transf-command [

      "matrix" [insert tail draw-blk compose/only [ (to-word transf-command) 
      (matrice) shape (shape) reset-matrix]]
					]
				][
					insert tail draw-blk compose/only [shape (shape)]
			 	]
				]

   "g" [ print "Write here how to handle G insertion to Draw block" 

    insert tail draw-blk probe compose/only [reset-matrix (to-word transf-command) 
    (matrice)]
				
				]
			]
	]	
  
	probe defs
	foreach blk defs [
		switch first blk [
			"rect"	[append-style first blk second blk]
			"path"	[append-style first blk second blk]
			"g"		[
						print "key word" probe first blk  
						print "matrix and style in G" probe second blk  
						append-style first blk second blk 
						;print "what to draw in G" probe third blk
						foreach blk2 third blk [
							probe blk2
							switch first blk2[ 
								"path" [append-style first blk2 second blk2]
							]
						]
					]
		]
	]
	
	
probe draw-blk
	draw-blk
]

view make face [
	offset:	100x100
	size:	200x200
	action:	request-file/filter/only "*.svg"
	text:	rejoin ["SVG Demo [" last split-path action "]"]
	data:	read action
	color:	white
	effect:	compose/only [draw (load-svg data size)]
	edge: font: para: none
	feel: make feel [
		detect: func [face event] [
			if event/type = 'resize [
				insert clear face/effect/draw load-svg face/data face/size
				show face
			]
			if event/type = 'close [quit]
		]
	]
	options: [resize]
]

Thanks for taking this up and running with it guys, you're making 
great progress (far better than I could have). Feel free to take 
ownership of the code and refactor it as needed.

Two minor improvements are:

	unless closed? [insert tail shape reduce ['move 0x0]]

which is Gabriele's fix to the shape close problem, and:

	feel: make feel [
		redraw: func [face act pos] [

   if act = 'draw [insert clear face/effect/draw load-svg face/data 
   face/size]
		]
	]


which cleans the sample feel code up a bit. I'd also remove "VID" 
from the title of this group as DRAW AGG is tied to View. ;)

yes it' quite a nightmare for a AGG newbie as I'm ...

for example the implementation of the LIneargradient I dont have 
any idea about how to translate it to AGG

I'm working hard on the translation of the linearGradient informations 
from SVG files   to AGG

if you wants to write the "in" AGG/draw code that is based on my 
rebol linear gradient list there is the code and a sample file from 
InkScape

I read most of the documentation but then make the link to AGG data 
structure is rather difficult

Good progress! If you change:

	"stroke-width" [line-width: to decimal! val]

to

	"stroke-width" [line-width: to-unit val]


then it'll run all your sample SVG icon files as well. Wish I knew 
the answers to your AGG questions, but like you I'm waiting on more 
documentation / examples.

but what I need are high level information and formation on draw 
agg and this I know very little people that can respond in this point 
 :)

For ppl interrested in  SVG rendering engine. My  tonight work  and 
 test on the engine   is resumed in the AGG topic. To resume before 
matrix bug as causing bad scale and bad position.  Now we have good 
position but still bad scale  i post screen cap samples and we can 
see that the evolution is good  betwin View 1.3.1 and 1.3.2

transform problem are on their way to be solve gradient too by cyphre 
and  Carl those  two things are the most blockant problems until 
they are not completly solved we can't expect to have a full working 
SVG rendering engine  -> most of SVG  imagines use transform effects 
and gradients this means    that if we want to get a pretty good 
and reliable SVG engine we have to fixe those two issue. SVR rendering 
engine is a good and hudge test upon AGG integration to REBOL/View 
and it allows us to embetter it !!! 


Once we get a fully working engine with basic human understandable 
algorithm i will start the  optimisation process using  parse (but 
to be franck i don't  know how parse will react in front svg row 
data or how will be the time to dev this parse based SVG engine ... 
 in all cases I think the actual engine have teached me a lot arrounf 
the SVG to AGG adaptation process so i hope the translation to parse 
and parse/rules will not be too hard and too long)

well last thing i can say is that SVG rendering  engine is very high 
on my task  list ( task number one) i worked on the adding of some 
other new drawing primitive  (image rect, circles). I will continue 
to  work on the close support of all SVG datas that can have a meaning 
in AGG context. SVG rendering engine is  a   2   weeks of work only!!! 
... until i fall on the gradient and transforms problems so this 
ensure us advancing on this project will be very fast once we solve 
bugs in REBOL/View related to AGG (wich is in progress actually)

ty ashley   ^^ time i wasn't giving notice of my progress but mainly 
because Gradeint and transform problem where dependent on AGG an 
not on my  script.

for me to be honnest the advantages of  using SVG instead of images 
 are a lot this is a quick list of my thoughts on what can be done 
with  SVG format.
 - easier embeding of graphical content
- resizing auto ith not grphics quality loss
- cheap but sharp skining 

 - graphical content of an  User  Interface  very low because rebol 
 is pretty able to  work with compression of text content ( compress/decompress)

A little sample to enlight this  compressed SVG file with blender 
logo ->  less than 500 octets (any size can be applyed with no graphic 
loss (aliasing, color loose, blur, pixelisation etc..) )  a fixed 
jped for same content will use  around  50ko. This means less datas 
in memory to as graphic pixel tables are very heavy in VM memory

- Dynamic graphical content. some thing like text scrolling or efffect 
like Flash ones but with  a  reduction of  1000  of the data and 
memory use SVG use a labeling system for  each graphical content 
that compose the image we can provided a tiny system to handle easy 
animation and show/hide of graphical content using raw rebol commands 
-> this will make pretty easier the realisation of dynamic animations 
in rebol ViD content and  as any REBOL/View face is DRaw/AGG capable 
the effects that we can create isn the futur with this idea will 
have no limits  -> this means too to have a pretty fast and ell designed 
SVG engine (that's my actual path on research)

hum new rebol/view have save/png hability woooooooooooopy so there 
is nothing that prevent us to make a  graph /AGG/SVG/PNG  dialect 
 ^^

so for me it's new lol but more serriously until AGG was not available 
i think the use of save/png to-image was really not meaning

would following news help us to get AGG - SVG compatible gradients? 
It regards AGG 2.4, new branch of AGG, and I am sure we will get 
it ported to REBOL too ...


New utility class template is added, gradient_lut. It allows you 
to easily create a color LUT for gradients from a set of color stops 
as they are defined in SVG, section Gradients and Patterns.

now let's convince Carl, that as AGG was good choice for vectors, 
we should find another library for sound. Maybe fmod?

the question is - AGG for vectors, is one of two best free libraries 
- Cairo and AGG ... so - how is fmod quality wise? Is there any better, 
smaller library to have?

Vector? AGG related?

Hi .... with recent Rebcode releases, we can see that internally 
new Core is marked as 2.7 and View is marked as 1.4 Is it just working 
"title" or will those products be marked as that? And if so, can 
we know, what other changes will go for 1.4 View release target? 
Will there be any AGG fixes/additions (to support SVG RebGUI progress), 
or even VID changes? I still think, that VID is missing few fine 
styles as tab, group-box, better list as was introduced on IOS Developer's 
server, (eventually tree, menu), to allow novices to start using 
VID/View more productively. Any chance RT can tell us, what is the 
plan for 1.4 release?

Q: What does the world on Nov-15-2005 look like?


A: Our main goal is to get REBOL into the hands of more users, not 
just programmers and techies.... by the millions over time.  By doing 
that, we create a market for not only handy free REBOL apps, but 
also for commercial apps and entire businesses that are related to 
REBOL.



Q: Given that  window transparency is OS specific, will there be 
a dialect that covers both Windows, Linux and 40+ other OS?  In other 
words, does RT plan on continued support of so many languages, or 
are we entering a new era of specific OS support?


A: Our plan is to make that a window option that is part of the face/options 
for a window.  If an OS does not support this mode, then the option 
will be ignored, but the application will still be fully functional.



Q: I hope it is still valid that cooperation with RT is possible. 
I mean - last few weeks I play with some Win32 functions (thanks 
to Gregg) and I would like we would have proper app behavior in multi-monitor/multi-desktop 
environments .... so I wonder if any SIGs will be created, some ppl 
will be invited to participate, comment etc., or if RT is gonna cook 
it all themselves?


A: Yes, there are many such special interest projects currently going 
on. (Most of them are occurring via private projects in AltME and 
IOS.)  These days 90% of REBOL changes are done in cooperation with 
the REBOL community.



Q: Hi .... with recent Rebcode releases, we can see that internally 
new Core is marked as 2.7 and View is marked as 1.4 Is it just working 
"title" or will those products be marked as that? And if so, can 
we know, what other changes will go for 1.4 View release target? 
Will there be any AGG fixes/additions (to support SVG RebGUI progress), 
or even VID changes? I still think, that VID is missing few fine 
styles as tab, group-box, better list as was introduced on IOS Developer's 
server, (eventually tree, menu), to allow novices to start using 
VID/View more productively. Any chance RT can tell us, what is the 
plan for 1.4 release?


A: Regarding 2.7 and 1.4 question: we change the revision numbers 
(the second number) whenever there is a major change in REBOL that 
may be unstable.  The /core 2.7 kernel (that is in /view 1.4 as well) 
adds new datatypes to REBOL, and they are the first datatypes added 
in several years, so we consider this to be a major change, and marked 
it that way.
Yes, we do plan to be making a few AGG fixes very soon.

Oh, and regarding VID: we plan to be making very big changes there. 
More to come soon.


Q: Could you add struct! support to /Core?

I keep on having situations that would be made much easier by struct! 
when I don't need libraries. For instance, conversions from external 
binary data encodings to internal REBOL values, say for file formats, 
network protocols and so on. Now rebcode has added other forms of 
strong typing like the type-specific opcodes and the vectors. Having 
structs with their constrained field types, their specific data layouts, 
would be a perfect match for the low level operations of rebcode. 
They would be helpful later when implementing your own data types 
as well.


A: On structs: yes, we will enable this feature on core, but it should 
only be used for lower level code.  Objects are more powerful.


Q: Could you add an APPLY opcode to rebcode?

    apply: ["Apply function or path to arguments, save result" word! 
    word! | path! block!]

In rebcode:
    apply x f [arg1 arg2 ...]
Is equivalent to this in REBOL:
    x: do f arg1 arg2 ...


The advantage to doing function calls this way is that the arity 
of the opcode is fixed, even if the arity of the function called 
can't be known ahead of time. The value assigned to the function 
word could be either a function or a path, or for efficiency you 
could have a seperate opcode APPLYP for path values (I'd prefer just 
one opcode for generality but it's your call).


A: I'm not sure what is meant by the path for it. You mean for refinements?
That may actually slow down the apply interface.

Gabriele - could you please pass my latest comments/links to Carl? 
I looked into Io slide-show and found they do use libevent library. 
I posted links into TechNews group. There is interesting reading 
in-there, also hidden is some links - liboop and The C10K problem 
..... Maybe we will find another libraries for further rebol improvements, 
like Cyphre did find agg.

Is the rebol.dll included with the sdk2.62 the same as the viewdll 
that is the plugin ?

If so, what are the magic numbers to use to make it act as the plugin 
?  ( the old plugin doesn't have AGG ).
Thanks.

Ruby community to clone Rebol/View (AGG) - http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/35c2f61d29e94550/28b32a50948920ba

If the build add the Rails framework to the  Ruby/AGG backend. I 
think Ruby will have another big market gain.

Cyphre did find some link to beta Ruby/AGG release, which one note 
of author, stating something like "Download beta release, but this 
is unexpectadly slow :-(" ... which could mean there is still a long 
way to go for them, and we can have REBOL 4.0 by that time ...

graham - my reference was not to Ruby/AGG, which apparently can be 
a good product, but to statements like "rails .... even faster than 
rebol" - whish sounds, from someone who is interested in languages 
so much, like a plain nonsense, comparing language to framework ...

why negative. It is because you read is as a negative. My reaction 
translates to - if PS is good thing to have, then let's have it, 
but then it would be good to have native rebol ps viewer (in AGG) 
or there will be a trouble, if such a thing is dependant upon external 
viewer. And that is my experience here and I can guarantee you, that 
in terms of our big corp it would be a problem. But enough, do what 
you think is best ...

In fact - my question could be just simplified - how do we do print 
preview without GhostView or other PS viewer tools? If that is "somehow" 
possible, then it is only good. That is why I referred to the need 
of AGG based preview, to actually save third app usage - a PS viewer.

AGG DRAW is pure vector gfx

Bugs found in Firefox with Cyphre demo: 

- starts with no sound (the music started when I opened a parallel 
session with Opera, in Opera the sound is ok)

- seems there are some problems with AGG: no rotating Carl Head, 
some flash with gears, no "rebol rulez" in the sky... (Opera is ok)

- when I close firefox the music continue for 4/5 seconds (until 
the buffer is empty ?). In Opera too.

- sometimes the plugin disappear if I refresh the page. I have to 
close the browser. In Opera too.


WIn2000, nVidia GeForce4 MX 440, Firefox 1.5.0.3, Opera 9.0 beta 
build 8393

I have seen a dozen applications used by companies.  The Neilsen 
Media company (famous for their Neilson Report of TV) uses Flash 
for all their applications.  


They could have used Rebol, but Flash is actually better for what 
they are doing.  If Rebol had more front end, or could play back 
SWF files thorugh AGG, then we might have something.


Rebol on the other hand is better for the heavy lifting, parsing 
websites, etc.

u think about using agg directly ?

its VID based, so any current draw blocks set in the effects can 
be used.  the buttons, field, and choice use AGG for their rendering.

thanks  :-)  took a bit of tweaking to get the stuff sorted out, 
but I'm starting to get the hang of AGG.

also note that currently, its 100% AGG/

well, whole new View is 100% AGG :-) Cyphre switched compositing 
engine to that of AGG internally AFAIK

The truth is, I do not have the reflex of using liquid for most of 
my coding, still, but actuall exposure and use, is forcing me to 
value its effect on my code.  this is empiric use, not advocacy. 
 If you could see just how easy it was for me to build fully bug-free 
AGG gadgets in so little time, you'd understand.


its not about just sharing data between gadgets, its about allowing 
your code to know what's going on.

elixir, for example,  easily allocates 10 000 nodes, creates a several 
thousand line AGG script and actually manages to rebuild the whole 
AGG dialect block faster than view can redraw it.

elixir builds a 100% native AGG GUI .   EVERYTHING is built using 
liquid, event the field (control) properties and cursor management.

I also have a simple graphics package which uses AGG directly with 
liquid, so I'll use that to further show liquid ties in from end-to-end.

no VID.  just AGG  ;-)

although GLASS will use the data within AGG instead of view/faces.

It would probably be easier to get AGG to output stuff in a form 
GDI would like though, with more overhead from pushing around all 
of that bitmap data of course.