AltME groups: search

Ok, TOOLBAR is based on VID-FACE, so let's first check if it has 
a words dialect.
	>> print mold svv/vid-styles/face/words
	none
Good, so we can set our own without breaking anything.
	toolbar: FACE with [
		; define DATA function in the style-specific dialect

  words: compose [data (func [new args][new/data: args/2 next args])]
	]

All this does is allow a slightly easier spec. Your example from 
the blog:
	view layout [button-bar with [data: [ok-btn cancel-btn]]] 
can now be:
	view layout [button-bar data:[ok-btn cancel-btn]]

Ok, it doesn't save you much in this one example, but over time, 
it will.

Sorry, correcting that last example:
can now be:
	view layout [ button-bar data [ok-btn cancel-btn] ]

it makes it possible for you in your style to provide words in the 
layout dialect to.. blabla

for example, table layouts are a dialect on its own to describe the 
layout of a single row and then repeat that, where his uses a more 
rigid html-like structure.

Re: Google Charts API -- there's not much finesse to it, just looks 
nicer than the ugly API:

	view layout [
		image chart [
			size: 150x40
			type: 'sparkline
			data: [45 55 38 35 37 58 59 64 60]
			color: black
			area: [color solid 255.255.255.204]
		]
	]

lay: layout [ 

origin 0x0
space 0x0

list blue 250x220 [
 across
 adres: field 50  

 zmienna: field 50
 pad 0x4
 wartosc: field 50
 pad 0x4
 tag-in: field 50
 pad 0x4
 tag-out: field 50

return ] data

[["join" 100]
 ["yui" 89]
["ytr" 5 ]
["99" 7]
["7878" 5] ]

Q. On Windows you can define a func as:

maximize-face: func [
	"Maximizes a face on screen."
	obj [object!]
][
	obj/changes: [maximize]
	obj
]

which lets you do:

	view maximize-face layout [text "Hello world!"]


but this is of limited use when you want to know how big the [maximized] 
screen will be *prior* to layout.

	help system/view/screen-face/size

isn't quite what we want, so I cobbled up the following:

max-win-size?: has [scr-face view-face] [
	scr-face: system/view/screen-face
	view-face: make face []
	view-face/changes: [maximize]
	;	view the face
	insert tail scr-face/pane view-face
	show scr-face
	wait .001
	;	unview the face
	remove back tail scr-face/pane
	show scr-face
	view-face/size
]

which has two drawbacks:

1) It requires the face to be shown (screen flickers briefly)
2) It doesn't work on Linux

Anyone else mucked around with this sort of stuff?

hmm, and once he is in View layout = rendered state, he simply wants 
to press a button and get resulting image ... Maybe he could render 
it once again in the background somehow? But how?

>> container-face: layout [b: box 50x50 red button "to-image" [show 
b/pane r: to-image b/pane]]

>> subface: layout/size/offset [at 0x0 box 100x100 blue] 100x100 
0x0  b/pane: subface
>> view container-face
>> view layout [image r]

rebol[]

container-face: layout [b: box 50x50 red button "to-image" [b/pane: 
none show subface r: to-image subface b/pane: subface show b view/new 
layout [backdrop black image r] ]]

subface: layout/size/offset [at 0x0 box 100x100 blue] 100x100 0x0 
 b/pane: subface
view container-face

Pekr: the solution for your problem is:

sublay: layout/offset [
	box 100x100  field ""
] 0x0
view layout [
	b: box 50x50
	button "do-obr" [
		save/bmp %obr.bmp to-image make sublay [
			pane: head forall pane [
				pane/1: make pane/1 []
			]
		]
	]
	do [b/pane: sublay  show b]
]

;-- working example
lay: layout [
	size 500x200
	button "Change Title" [
		lay/text: join "Time: " now
		lay/changes: 'text
		show lay
	]
]

view lay

'line-list is only used on "long 'text" face (more than 200 chars 
IIRC). Be carefull with it.


'span was used in View 1.2.1 to set a pixel ratio (zoom) between 
'offset, 'size and correspondng real screen values. I think recent 
beta/alpha does not care of it.

'saved-area is considered if  value is 'true IIRC.


'action is checked by 'feel function, so can be used if 'feel does 
not care of.

'data depends of  'feel too.


'type could be used. Only 'layout or other VID functions use it AFAIK

By the way, the words in a face object are not "facets", as I fell 
into believing some time ago. Facets are a style's dialect words 
which follow the style word in the layout block. eg. layout [BUTTON 
"hello" red [print "pressed"] ]    BUTTON is the style word, the 
rest that follow are the facets. These may or may not translate nicely 
into attributes in the new face object created for this button. A 
single facet could affect several attributes inside the button face.

This I grabbed in Dec 2002
Rebol [
	title: "little custom tray exapmle"
	author: [cyphre-:-seznam-:-cz]
]

set-tray: does [
set-modes system/ports/system [
	tray: [
		add main [
			help: "Just some help line"
			menu: [
				desktop: "This is my tray"
				bar
				test: "test item"
				bar
				quit: "Quit"
			]
		]
	]
]
]
system-awake: func [port /local r][
    if all [r: pick port 1 (r/1 = 'tray)] [

        if any [(r/3 = 'activate) all [(r/3 = 'menu) (r/4 = 'desktop)]][

  view/new/offset layout [banner "you clicked the tray button 1"] random 
  200x200
        ] 

        if all [(r/3 = 'menu) (r/4 = 'test)] [view/new/offset layout [banner 
        "you clicked the tray button 2"] random 200x200]
        if all [(r/3 = 'menu) (r/4 = 'quit)] [quit]
    ]
    return false
]
system/ports/system: open [scheme: 'system]
append system/ports/wait-list system/ports/system
system/ports/system/awake: :system-awake 
set-tray
wait []

Ashley, since you have separated the View and VID facets, does this 
mean that RebGUI can work closely with VID, without the two affecting 
each other ? Eg. could faces from a VID LAYOUT be moved into a RebGUI 
DISPLAYed layout, et vice versa ?

It was not immediately clear to me, from the DISPLAY help, whether 
ORIGIN-SIZE was referring to the window offset or the initial layout 
position within the window. Compare to LAYOUT/ORIGIN.  Actually I 
was probably confused because I was expecting something similar to 
VIEW/OFFSET...

how can I refresh a layout while i'm resizing it ?

actually when I resize a layout by clicking left mous button and 
pointing to one of it's borders I have an ugly thing

how can I do to insert a refresh action while the border of the layout 
are deplaced

rebol[]


last-sgrp: copy ""		;global used to keep track of last selected button 
in sgrp window

reset-toggles: does [

 t1/state: t2/state: t3/state: t4/state: t5/state: t6/state: t7/state: 
 t8/state: false
]

two-digits: func [num][
	either 10 > num [num: join "0" num][num]
]


get-report-date: function [/delim][report-day day rsd today s e day-diff][
	report-day: 6			; 6 = Saturday, start day of report
	today: now/weekday
	day-diff: report-day - now/weekday

 rsd: now + day-diff		;rsd = report start date		;'difference function 
 used to do date math
	either delim [

  s: join rsd/year ["/" two-digits rsd/month "/" two-digits rsd/day]
	][
		s: join rsd/year [two-digits rsd/month two-digits rsd/day]
	
	]
	e: rsd + 6
	either delim [
		e: join e/year ["/" two-digits e/month "/" two-digits e/day]
	][
		e: join e/year [two-digits e/month two-digits e/day]
	]
	report/text: join s [" - " e]
	show report
]

clear-entry: does [
	probe t1/text probe t2/text probe t3/text probe t4/text
	print "-------"

    clear-fields bx1			;;;;;;;;;;;; Error of disappearing toggle values 
    starts here
	probe t1/text probe t2/text probe t3/text probe t4/text
	print "======="
    ;clear-fields bx2			;;;;;;;;;;;;
    ;create-dt/text: form now
    ;update-dt/text: form now
    unfocus
    show dex
]

new-ticket: does [
    ;store-entry			;stores existing entry
    clear-entry			;clears fields for new entry
    if last-sgrp <> "" [application/text: last-sgrp]
    environment/text: copy "prod"
    show [application environment]
    focus application
]

dex-pane1: layout [
	across
	label "Support Group:"	application: field return
	label "Environment:" 	environment: field return
	label "Report Dates:"	report: field return
	btn "New Ticket" [new-ticket]
	pad 20 btn "Reset Toggles" [reset-toggles]
]

dex-pane2: layout [
	across
	label "Search Criteria:"

 t1: tog "o79" [write clipboard:// join "se sa**/" [last-sgrp: t1/text 
 "ca datp/" get-report-date/delim]]

 t2: tog "p23" [write clipboard:// join "se sa**/" [last-sgrp: t2/text 
 "ca datp/" get-report-date/delim]]

 t3: tog "o88" [write clipboard:// join "se sa**/" [last-sgrp: t3/text 
 "ca datp/" get-report-date/delim]]

 t4: tog "p11" [write clipboard:// join "se sa**/" [last-sgrp: t4/text 
 "ca datp/" get-report-date/delim]]
]

dex: layout[
	bx1: box dex-pane1/size
    bx2: box dex-pane2/size
]

bx1/pane: dex-pane1/pane
bx2/pane: dex-pane2/pane

view dex

>> help clear-fields
USAGE:
    CLEAR-FIELDS panel

DESCRIPTION:
     Clear all text fields faces of a layout.
     CLEAR-FIELDS is a function value.

ARGUMENTS:
     panel -- (Type: object)

Poking around a bit in the View executable (1.2.10.3.1) I "discovered" 
the following undocumented words (and have assumed they belong to 
the indicated facet based on the position of other known words). 
I've worked out what a few of them do, anyone care to comment on 
the others (or point to documentation if covered elsewhere).

Draw
--------
fill
font

Effect
--------
dither
alphamul
anti-alias
func
merge		; I know this was covered, just can't find where
chisel
	view layout [box 20x40 effect 'chisel box 40x20 effect 'chisel]
round
	view layout [box 20x40 effect 'round box 40x20 effect 'round]

Feel
--------
inactive
active

Options
--------
parent
	view/new a: layout [size 400x400]
	view/new/options layout [size 200x200] compose [parent (a)]
	do-events
min-size
	view/options layout [box blue 400x400] [resize min-size 200x200]
activate-on-show

view/new layout [b: box effect [draw [font none text "hello"]]]
wait 2
b/effect/draw/font: make face/font [size: 40] show b

; Yep, 'merge instructs the effects engine to compose effects using 
underlying faces:
dots: http://www.ross-gill.com/r/grid-teal.png
img: http://www.ross-gill.com/r/find-file.png
view center-face layout [
    backtile dots
    image img
    image img effect [blur blur blur]
    image img effect [merge blur blur blur]
]

'fill : to fill a form

view layout [box 100x100 effect [draw [pen 255.0.0 fill-pen 0.0.255 
polygon 0x0 0x90 90x90 fill 50x50]]]

Tried on both 1.2.10 and 1.2.48. Note that the lack of a red line 
on 1.2.10 is due to a known bug with polygon (fixed in 1.2.48).

On 1.2.48 I can't see a difference between:


a) view layout [box 100x100 effect [draw [pen 255.0.0 fill-pen 0.0.255 
polygon 0x0 0x90 90x90 fill 50x50]]]

b) view layout [box 100x100 effect [draw [pen 255.0.0 fill-pen 0.0.255 
polygon 0x0 0x90 90x90]]]

So I'm still not sure what 'fill is supposed to do. ;)

view layout [box 100x100 effect [draw [pen 255.0.0 fill-pen 0.0.255 
polygon 0x0 0x90 90x90 fill 90x0]]]

 view layout [box 100x100 effect [draw [pen 255.0.0 fill-pen 0.0.255 
 fill 0x0 0x90 90x90 90x0]]]

; A bonus tip -- each of the tog actions in dex-pane2 are essentially 
the same.  You could clean up as follows:
tog-action: [
    write clipboard:// join "se sa**/" [
        last-sgrp: face/text "ca datp/" get-report-date/delim
    ]
]

dex-pane2: layout [
    across
    label "Search Criteria:"
    t1: tog "o79" tog-action
    t2: tog "p23" tog-action
    t3: tog "o88" tog-action
    t4: tog "p11" tog-action
]

Brock, check out the source of CLEAR-FACE, and you will see that 
it tries to do  
	face/access/clear-face*

, therefore you should look at the access object to see what it really 
does:
	layout [text with [?? access]]

There, you will also see RESET-FACE, which would have also solved 
your problem

because it does a COPY as well. I think COPYing to start with as 
Chris showed is a safer way, though.

view window: layout [
	f: field
	b: button "clone me" [f/text: b/text show window]
	button "clear-fields" [clear-fields window show window]
]

view window: layout [
	f: field
	b: button "copy me" [f/text: copy b/text show window]
	button "clear-fields" [clear-fields window show window]
]

I have a text-list in a layout and I have a simple log-function:
log: func [message [string! block!]][
	append log-list/data rejoin [now/date "/" now/time " " message]
	show log-list
]

aahhh, no matter how deeply you know something, there is always something 
that gets on your nerve...

changing the button font color seems to be a genuine pain... can 
someone refresh me why its impossible?


this doesn't work... altough I've allocated a stand-alone font and 
have removed all the dynamic code which AFAIK plays around with the 
font or text:



view layout [button "ok" font [color: red] with [feel: make feel 
[redraw: none over: none]]]

yet, this works:


view layout [text "ok" font [color: red] with [feel: make feel [redraw: 
none over: none]]]

you have to set 'colors, not 'color:

view layout [button "ok" font [colors: reduce [red white]] with [feel: 
make feel [redraw: none over: none]]]
for a button with inactive color red and active color white

http://www.rebol.org/cgi-bin/cgiwrap/rebol/view-script.r?script=layout-1.8.r

Scrollpanes are in the middle of getting a revamp which will include 
an enhancement or two to the layout engine itself but the revamp 
isn't available yet...

the complete website has a new layout too ;-)

View layout [box 300x300 help.gif at 40x50 box 200x150 effect [merge 
colorize 128.128.255]]

View layout [box 300x300 help.gif at 40x50 box 200x150 effect [merge 
gradmul 1x1 100.100.100 100.100.100]]

View layout [box 300x300 help.gif at 40x50 box 200x150 effect [merge 
gradcol 1x1 100.100.100 100.100.100 ]]

;Try this:
view layout [
    text "Testing..." black white
    box "drag box" 50x50 effect [merge colorize green] feel [
                engage: func [face action event] [
                        if action = 'down [start: event/offset]
                        if find [over away] action [

                                face/offset: face/offset + event/offset - start
                                show face
                            ]
                    ]
            ]
]

;From http://www.rebol.com/how-to/feel.html

view layout [
    size 240x240
    style dragbox box 40x40 font-size 11 feel [
        engage: func [face action event] [
            if action = 'down [
                face/data: event/offset
                remove find face/parent-face/pane face
                append face/parent-face/pane face
            ]
            if find [over away] action [

                face/offset: face/offset + event/offset - face/data
            ]
            show face
        ]
    ]
    dragbox "Box 1" navy
    dragbox "Box 2" teal
    dragbox "Box 3" maroon
    dragbox "Box 4" gold
]

Mmmm although I dont use Layout... so i need to be creative ;-)

Not using layout won't affect that one bit

view layout [space 0 backdrop help.gif image logo.gif effect [key 
254.254.254] image logo.gif effect [key 2.2.2]]

view layout [
	origin 0x0
	space 0x0
	size 400x400
	at 0x0 box 300x300 aqua 
	at 200x100 box 200x300 linen
	at 0x100 box "In the middle" 400x200 khaki feel [
	        detect: func [face event] [
            		if event/type = 'move [	
				popup/text: event/offset - 0x100 
				popup/offset: event/offset + 10x0
				show popup
			]
		return none			
		]

 ] font [ size: 72 ] effect reduce [ 'merge 'colorize 128.64.128 ] 
 	

	popup: box 50x15 font [color: white size: 10 shadow: none ] 

  effect reduce [ 'merge 'colorize 128.64.255 'draw [ pen 0.128.0 box 
  0x0 49x14 ]]
]

layout [image with [?? multi]]

If I have a layout is it possible to just add stuff on-the-fly if 
certain conditions are met? Like this:
	layout [
		...
		if my-var > 5 [name: button red return]
		...
	]

Of course it's possible to build the layout block up front using 
normal Rebol code but IMO being able to do it inline makes a lot 
of sense.

layout [

 do [if my-var > 5 [layin [name: button red return]]]  ; something 
 like this ?
]

I think my hypothetical example above is better as:
	layout [
		inlay [if my-var > 5 [[name: button red return]]]
	]
then INLAY only needs to be a layout dialect function.

But actually, this reminds me of the discussions we had about argument 
propagation, the want for replace/deep etc.

Perspectives of a newbie! By Steve Thornton (SteveT) 


In your first steps in using REBOL (If your like me) you'll go and 
have a look

at other peoples scripts - luckily the REBOL Viewtop is full of them. 


One thing that stumped me to begin with was that each developer differed

slightly in how they setup their 'Layout' or 'Views' this is because 
there is

a degree of flexibility that covers different situations. You can 
call a view 

and a layout all in one go, or you can make a layout seperately and 
then call 

it when executing the view. While I quickly understood this, I like 
to follow 

'best practice' when creating the initial framework of my application.


It would be a great help if a diagram was available showing where 
to place 

things. For example I went wrong by trying to place view options/effects 

inside the layout structure, When you look at some of the one/two 
line examples
it looks as if you can do that.

Steve

Steve, another insightful post.  I'm far from an expert but have 
been around the Rebol world for a while, mostly in lurk mode.  The 
reason that I am aware of for generating a layout prior to calling 
a view, is so you can dynamically build the layout.  Then, once all 
of the logic has constructed your dynamic layout, you view the entire 
peice together.

If you don't build the layout first, then you can't write functions 
that access the named widgets inside the layout.

Hi Graham, some dems say - main: layout [ .....   where other use 
main: make [...... would you usuall use make ??

sorry main: make layout [.....

I don't think I've ever used "make layout"

SteveT, using faces directly with MAKE is a lower level approach 
than LAYOUT. What LAYOUT does, is produce a face object that consists 
of many subfaces from your layout description written in the VID 
dialect. Each one of these face objects have settings for size, offset, 
appearance, text content, etc, which are set as the layout description 
is parsed. Using MAKE FACE directly provides greater control, but 
is more cumbersome to use, because you have to set all these values 
manually and arrange the face tree manually. You can see the content 
of the base FACE object in the console with:

>> ? face


The FACE object is the only object ever used, so it's a good idea 
to get to know it. You can extend it with more values and VID does 
this, to create variants, modes and extra operations on a face, like 
SET-FACE, GET-FACE, etc.


The reason why many choose to skip VID for this, is that VID doesn't 
provide the level of control needed as some things can't be determined 
properly at layout time, such as interdependency of sizes or offsets 
between faces, which is why VID doesn't support easy resizing out 
of the box.


Oh and when you get to try VID3 in REBOL3, forget everything I said, 
because it's a whole different system. :-)

main: layout [
        vh2 "Subpanel Examples"
        guide
        pad 20
        button "Panel 1" [panels/pane: panel1  show panels]
        button "Panel 2" [panels/pane: panel2  show panels]
        button "Quit" [quit]
        return
        box 2x140 maroon
        return
        panels: box 220x140 coal
    ]


Hi all, what does guide do above - I can't find it in the Dictionary

this means here, that it will affect how far to the left 'return 
will put the layout cursor

you can also use it like this:


view layout [button "hello" here: guide button "test" at here btn 
"boo!"]

Steve, just additional comment on 'guide word.  Henrik stated this 
"this means here, that it will affect how far to the left 'return 
will put the layout cursor" which is not incorrect, but I believe 
it also remembers the top margin location as well. In the example 
you provided, without the 'guide where it is, the box should have 
lined up with the top of the "Subpanel Example".  However, it lines 
up where the guide was placed, under that text.

GUIDE is also sensitive to the layout "direction", i.e., whether 
you're using ACROSS or BELOW. You can also manually remember locations.

	; some layout code
	here: at	; remember a postion
	; some layout code
	at here
	; some layout code

image image-logo %your-pic.png

main: layout [

    box 72x72 image-logo [alert "You've clicked!" ] 
	   	feel [over: func [face act pos] [
    			face/size: either act [82x82][72x72] show face
   				ref/size: either act [82x50][72x40] show ref

      helper/text: either act ["Click me now!"]["Highlight an icon"] show 
      helper 
    		] 
    	]
    below

    ref: box image-logo 72x40 effect [gradcol 0x1 0.0.0 80.80.80 flip 
    0x1 fit blur]   	
    below
    helper: text "Highlight an icon" silver / 1.5
]

main/size: 150x200
main/effect: [gradient 0x-1 0.0.0 120.120.120]
view/new main
do-events

You can redefine the engage yourself like this:
layout [
	style my-field field feel [
		engage: func [face action event][
			..
		]
	]
]

layout [f: field] probe f/flags ; == [field return tabbed on-unfocus 
input]
view layout [f: field with [deflag-face self return]]

view layout [field feel [insert body: second :engage bind [if all 
[act = 'key event/key = tab][focus f3 exit]] body/2] field f3: field 
"This is f3"]

view layout [
	size 200x300
	ch: choice "one" "two" "three" [
		print [index? face/data mold face/data]
		probe get-face face
	]
]

Mmm.. set-face is not implemented fully. Use this:
	layout [my-choice: choice ...]
	set-face my-choice my-choice/text: "two"
(we have to update the face/text ourselves.)

IDE for REBOL must be open for example in the Layout designer I want 
to be able to choose betwin comon Vid or a sub widget library like 
RebGUI for example ;)

4) Add a few other tools like layout, etc. But not make it complicated.

my-font: make face/font [name: "Arial Black" size: 24] view layout 
[box effect [draw [font my-font pen black fill-pen yellow text "Text" 
vectorial]]]

font-a: make face/font [name: "Arial Black" size: 24]
font-b: make face/font [name: "Arial" size: 12]
view center-face layout [
    btn 120x48 with [
        append init [

            append effect compose [draw [font font-a pen black fill-pen yellow 
            text 16x8 "Button" vectorial]]
        ]
    ]
    btn 20x120 with [
        append init [

            append effect compose [draw [transform -90 0x0 0x90 1 1 font font-b 
            pen none fill-pen black text 0x2 "vertical text" vectorial]]
        ]
    ]
]

fovsz: 450x450

layout compose [starfield: image (fovsz) black]

starfield: to-image starfield

loop 1000 [
	col: random 255
	starcol: to-tuple reduce [col col col]
	poke starfield random fovsz/x * fovsz/y starcol
]

view/new layout compose [
	b: image starfield
]

hvector: func [x y v][

 (fovsz/x / fov) * (fov / 2 + either zero? pos/2 - y [90][arctangent 
 (pos/1 - x) / (pos/2 - y)])
]

vvector: func [y z v][

 (fovsz/y / fov) * (fov / 4 + either zero? pos/2 - y [90][arctangent 
 (pos/3 - z) / (pos/2 - y)])
]

map: [
	"A New Beginning"
	""
	"Rebol HQ, led by their jedi leader,"
	"Carl Sassenrath, has begun"
	"preparations to strike back against"
	"Darth Gates at the Redmond system"
	"during a time of growing unrest"
	"among the netizens of the Empire."
	""
	"As the Empire works to complete"
	"construction of their hailed"
	"planetary domination device, code"
	{named "Longhorn Death Star", small}
	"centers of resistance continue to"
	"gain support among the"
	"oppressed masses."
	""
	"Even with mounting support, only"
	"One is powerful enough to overcome"
	"the dark side of the Force --"
	""
	"Rebol/View 1.3"
]

mapimg: copy []

foreach line map [

 b1: layout/origin compose/deep [text (line) 840 center font-size 
 48 sky black (either any [line = map/1 line = last map]['bold][])] 
 0x0
	append mapimg to-image b1
]

pos: [0 30 20]
dir: [0 0]

fov: 45

for l pos/2 200 .1 [
	agg: copy []
	x: 0 y: 0
	foreach item mapimg [
		y: y + 5
		if y < pos/2 [
			append agg compose [
				image (item)
				(to-pair reduce [hvector x + 15 y dir/1 vvector y 0 dir/2])
				(to-pair reduce [hvector x - 15 y dir/1 vvector y 0 dir/2])

    (to-pair reduce [hvector x - 15 y + 5 dir/1 vvector y + 5 0 dir/2])

    (to-pair reduce [hvector x + 15 y + 5 dir/1 vvector y + 5 0 dir/2])
				black
			]
		]
	]
	b/effect: compose/deep [draw [(agg)]]

	show b

	pos/2: l
]

view layout [b: box navy 100x100 effect [draw [circle 30x50 19.5 
20.2 circle 60x50 19.5 20.6]] image b/size * 4 to-image b]

img1: to-image layout/tight [image 40x40 effect [draw [pen black 
fill-pen leaf circle 20x20 19]]]

img2: to-image layout/tight [image white 40x40 effect [draw [pen 
black fill-pen leaf circle 20x20 19]]]
view layout [image 200x200 img1 image 200x200 img2]

view layout [box navy effect [draw [scale 0.1 0.1 text "hello" 40x40]]]

view layout [b: box 200x200 effect [draw [scale 1 1 pen 192.0.0 line-width 
32 line 10x10 190x190]] scroller 200x20 [b/effect/draw/scale: b/effect/draw/3: 
face/data show b]]

view layout [b: box 200x200 effect [draw [transform 0 0x0 1 1 0x0 
pen 192.0.0 line-width 32 line 10x10 190x190]] scroller 200x20 [change/dup 
at b/effect/draw 4 face/data 2 show b]]

view lay: layout [

 size 500x500 backeffect [draw [translate 250x250 scale 0.2 0.2 line-width 
 1 circle 0x0 300]] 
	scroller [change/dup at lay/effect/draw 4 face/data 2 show lay] 
	scroller [lay/effect/draw/line-width: face/data * 100 show lay]
]

rebol [
	date: 24-Jul-2005 
	author: "Anton Rolls"
	comment: {

  Investigating why adding/removing 'merge from effect block seems 
  to change line-width on
		arc, circle etc.:

		ToDo:
		  - try to 

  - It looks like the AGG anti-aliasing is with the default window 
  background color ?

    When MERGE is added, then it's with the actual color that is merged 
    (seems ok and good to me).

    - so try to set b1/color so it's the same as the color anti-aliased 
    against in the merged version

    Perhaps default window background color (200.200.200) is close to 
    the default agg anti-aliasing color ?
		  (do not use custom window color)
		- try a simple LINE
		- report to RAMBO or AGG group
		- submit to RAMBO


  This shows that the addition of 'merge seems to add 0.5... (?) or 
  some scaled factor to the line-width:
	}
]

effect-blk: [
	draw [
		pen black
		line-width 0
		translate 25x25
		scale 1 1 
		circle 0x0 24 ;arc 0x0 24x24 0 270
	]
]
make-2nd-effect: func [/local result][
	result: copy/deep effect-blk
	insert result 'merge

 ;result/draw/line-width: result/draw/line-width - 0.5 ; <- even with 
 this they don't look quite the same

 result/draw/line-width: result/draw/line-width - any [attempt [correction-scr/data 
 * 0.1 + 0.5] 0]
	result
]
refresh: does [
	b2/effect: make-2nd-effect
	show [b1 b2]
	big1/image: to-image b1
	big2/image: to-image b2
	diff/image: xor big1/image big2/image
	same-txt/text: join "same? " big1/image = big2/image
	show [big1 big2 diff same-txt]
]
view/new window: center-face layout compose/only [
	across
	label 80 "scale"
	scroller 200x20 with [data: 1][
		change/dup next find b1/effect/draw 'scale face/data 2
		refresh
	]
	return
	label 80 "line-width"
	scroller 200x20 [
		b1/effect/draw/line-width: face/data * 4
		refresh
	]
	return
	label "line-width correction"
	correction-scr: scroller 200x20 [
		refresh
	]
	return
	b1: box 50x50 [refresh] effect (effect-blk)
	b2: box 50x50 [refresh] effect (make-2nd-effect)
	same-txt: text 200
	return
	big1: image 200x200
	big2: image 200x200
	return
	diff: image 200x200
]
refresh
do-events

ft: make face/font [size: 60] 
view center-face layout [
	origin 0
	box 400x80 white effect [
		draw [

   fill-pen linear 0x0 0 100 30 1 1 black white black white black white
			font ft
			text 0x0 "Wavin' REBOL" vectorial
		]
		emboss
	] with [
		rate: 0
		n: 0
		feel: make feel [
			engage: func [f a e][
				f/effect/draw/3/x: n: n + 2
				show f
			]
		]
	]
]

The following code demonstrates this. Comment / uncomment the draw 
effect line to see the difference a simple draw command makes.

count: 100

do-test: func [label info /local img-size start end] [
	img-size: to-pair label/text
	img: to image! layout [

  origin 0 box img-size blue reform ["Testing" img-size ". . ."] font 
  [size: 24]
	]
	view/new/options center-face layout [
		origin 0 i: image img img/size
		;effect [draw [circle 100x100 100]]
	] [no-title no-border]
	;	test loop
	start: now/time/precise
	loop count [show i]
	end: now/time/precise
	;	display result
	info/text: form to-integer count / (to-decimal end - start)
	show info
	unview
]

view layout [
	title "Resolutions"
	across la: label 100 "800x600" ia: info 100 center
	return lb: label 100 "1024x768" ib: info 100 center
	return lc: label 100 "1280x1024" ic: info 100 center
	return btn "Run" [do-test la ia do-test lb ib do-test lc ic]
]

stylize/master [
	rte: box with [
		color: gray 
	    tampon: ""
	    buffer: []
	    line-index: 0
	    char-sz: none
	  	current-text-offset: 0x0
	  	cursor-text-offset: 0x0
	  	max-text-offset: 0x0
	  	text-color: black
	  	pane: []
	  	
	  	set-font-style: func [ font-s [word!]] [
	  		switch font-s [

      bold [insert tail buffer compose/deep [[ [size: 11 style: [(font-s)]] 
      (either cursor-text-offset/x <> 0 [cursor-text-offset] [as-pair 0 
      (line-index * 20)]) "" ]]]

      normal [insert tail buffer compose/deep [[ [size: 11 style: []] ( 
      either cursor-text-offset/x <> 0 [cursor-text-offset][as-pair 0 (line-index 
      * 20)]) "" ]]]

      underline[insert tail buffer compose/deep [[ [size: 11 style: [(font-s)]] 
      (either cursor-text-offset/x <> 0 [cursor-text-offset][as-pair 0 
      (line-index * 20)]) "" ]]]

      italic [insert tail buffer compose/deep [[ [size: 11 style: [(font-s)]] 
      (either cursor-text-offset/x <> 0 [cursor-text-offset][as-pair 0 
      (line-index * 20)]) "" ]]]
	  		]
	  	]
	  	
		feel: make feel [
			engage: func [f a e] [
				switch a [
				   
					key [ probe e/key
						switch/default e/key [
							#"^M" [
							line-index: line-index + 1

       f/current-text-offset: as-pair 0 f/current-text-offset/y + 20]

       insert tail f/buffer compose/deep [[ [size: 11 style: [(font-s)]](as-pair 
       0 (line-index * 20)) "" ]]
							
						][
							f/tampon: rejoin [f/tampon to-string e/key]
							draw-text: []
							print "f/buffer:"
							probe f/buffer
							foreach line-to-draw f/buffer [
								print "line-to-draw"
							;line-to-draw: f/buffer/1
								;probe line-to-draw
							;set [font-style start-offset text-to-show ] line-to-draw
							
								font-style: line-to-draw/1
								start-offset: line-to-draw/2
								line-to-draw/3: rejoin [line-to-draw/3 to-string e/key]
							;probe font-style 
							;probe start-offset
							
								font-obj: make face/font font-style
							;probe font-obj 
								text-to-show: line-to-draw/3
								;probe text-to-show

         insert tail draw-text  compose [ font (font-obj) pen (f/text-color) 
         text (start-offset) (text-to-show)]
							] 
							;print "draw-text:"
							;probe draw-text
							

       ;draw-text: compose [ pen (f/text-color) text (f/current-text-offset) 
       (f/tampon)]
				    		f/effect: make effect reduce [ 'draw draw-text  ]
				    		draw-text: none 
				    		;probe f/current-text-offset

       f/cursor-text-offset: as-pair (f/cursor-text-offset/x + 9) f/current-text-offset/y 
				    		;show f
						]
						f/pane/1/offset: f/cursor-text-offset 
						show f
					]
					down [
						;insert f/buffer compose [(as-pair 0 (line-index * 20)) ""]
						focus f show f
					]
					
				]
			]
		]
		append init [

   insert buffer compose/deep [[[size: 11 style: []] (as-pair 0 (line-index 
   * 20)) ""]]
			probe buffer

   insert pane make face [ color: red size: 2x20 offset: cursor-text-offset 
    ]
			show self 
		]
	]
]


view layout [
  across
  	btn "bold" [test-rte/set-font-style 'bold]
  	btn "underline" [test-rte/set-font-style 'underline]
  	btn "italic" [test-rte/set-font-style 'italic]
  	btn "normal" [test-rte/set-font-style 'normal]
  return
  	test-rte: rte 300x300
]

(Warning, this will lock up whatever instance of rebol you are running 
it in)

sp: 0
b: layout [
    c: box 400x400 white effect [
		draw [
			'pen 255.23.23 23.255.23 
			'line-pattern 1 sp
			'curve 50x350 200x50 350x350 200x300
		]
	]
	button "boom" [sp: sp - 1 show c]
]
view b

Ok, so here it is:

-fixed image keying bug (swapped color components in keying tuple!)
-line width is now now changing according to scale

-fixed rendering of transformed images(now uses aplha premultiplied 
data)

-fixed LINE-PATTERN bug (multiple line patterns in DRAW block should 
work properly now)

-fixed MATRIX bug(wrong matrix calcualtion was corrected in this 
case)

-fixed SKEW command inconsistency (now it takes degrees as arguments 
instead of radians)

-fixed FILL-PEN bug when filling images (now it doesn't render images 
upside down)

-fixed ANTI-ALIAS cmd(now it is possible to switch this mode within 
one DRAW block)

-removed POP command (was obsolete, PUSH with block! arg is used 
instead)
-fixed fill/outline pixel aligning problem
-fixed visual bug when rendering circle with line-width > 1
-fixed text character encoding problem
-improved gradients: added REFLECT and REPEAT modes, example:
view layout [
	origin 0
	box 400x460 effect [
		draw [
			pen none
			fill-pen linear 10x10 0 190 0 1 1 black red green blue black
			box 10x10 390x90

   fill-pen linear 10x160 0 190 0 1 1 black red green blue black repeat
			box 10x100 390x180

   fill-pen linear 10x310 0 190 0 1 1 black red green blue black reflect
			box 10x190 390x270
			fill-pen radial 80x350 0 20 0 1 1 black red green blue black
			circle 80x350 70

   fill-pen radial 190x350 0 20 0 1 1 black red green blue black repeat
			circle 190x350 70

   fill-pen radial 320x350 0 20 0 1 1 black red green blue black reflect
			circle 320x350 70
		]
	]
]

view layout [
    box 640x480 effect [

        draw [line-width 48 pen 0.132.28.0 0.0.0.0 arc 0x0 90x90 358.163265306122 
        90]
    ]
]

Is is possible to deform an image into a triangular shape ?


I tried the following .... but specifying the 3rd & 4th co-ordinates 
as the same produces no image at all ....
view layout [

    box 100x100 effect [draw [image logo.gif 10x10 90x10 90x90 10x90]]

    box 100x100 effect [draw [image logo.gif 10x10 90x10 60x90 40x90]]

    box 100x100 effect [draw [image logo.gif 10x10 90x10 51x90 49x90]]

    box 100x100 effect [draw [image logo.gif 10x10 90x10 50x90 50x90]]
]

GLayout v0.5.4 released (on rebol.org, as usual)
---------------------------------------

-SWITCH-PAD: tab-pane like style... supply all tabs directly within 
the main layout, if you want i.e. no need to separate  each tab's 
layout.

-field style: new visuals, faster, more obvious, supports rounded 
corners, fixed sizing.
-menu-bug vs popups bug fixed
-hshrink now fully implemented for text and buttons.
-buttons now supports mouse-relative popup menus

-center group style, allows to center static-sized objects or adds 
margins support for stretchy content

GLayout demo 0.9.1 Released:
------------------

-auto-updates latest version of GLayout (as per slim requirement).

-new layout using switchpad (btw, switchpad automatically adds a 
right-click popup to select panes)
-takes advantage of new GLayout features.

-improved input field filter example, now properly reacts to caret 
offset (cursor)
-better button and field options examples
-adds center style examples.

do http://www.rebol.org/cgi-bin/cgiwrap/rebol/download-a-script.r?script-name=glayout-demo.r

!Liquid release v0.6.4
--------------------------------------------------------------
- cleared a few bacteria (microbugs ;-)
- better support for linked containers
- fixed orphaned  links (named yet non-linked inputs).
- start of commit concept (just the func layout)
- started !plug core reference docs 


to download the lib:	http://www.rebol.org/cgi-bin/cgiwrap/rebol/download-a-script.r?script-name=liquid.r

docs on liquid project:	http://www.pointillistic.com/open-REBOL/moa/steel/liquid/index.html

!plug reference:		http://www.pointillistic.com/open-REBOL/moa/steel/liquid/plug/plug-reference.html

Rebol/Flash dialect (RSWF) version 2.5.0 is available!
compressed: http://box.lebeda.ws/~hmm/rswf/rswf_latest.r(89kB)

uncompressed: http://box.lebeda.ws/~hmm/rswf/rswf_2.5.0.r(331kB) 

as colorized HTML: http://box.lebeda.ws/~hmm/rswf/rswf_2.5.0.html
 (885kB) 

What's new:

- New swf-parser included which replaces old exam-swf function (useful 
for importing foreign SWF files)

- Added implementation of Class definitions for SWF versions 6 and 
higher (I have to create some examples)

- Added new 'trace function into actions (which can be use to compile 
swf files with or without trace calls easily)

- 'require and 'include now accepts block of files or urls (I should 
modify my rswf code colorizer to show included files as well)


Here is also new example how to include first of GUI elements: http://box.lebeda.ws/~hmm/rswf/example/swf8-cliphandler

In the future I would like to create something like mini Layout dialect 
which will be used for better positioning of the new GUIs I'm working 
on.

Electronic Arts IFF ILBM loader:
http://www.fys.ku.dk/~niclasen/rebol/libs/gfx/iff.r

Can handle 2, 4, 8, 16 and 32 color images, HAM6 images (4096 colors) 
and HALFBRITE (64 colors). HALFBRITE hasn't been tested yet, as I 
couldn't find such an image easily. Handle both compressed and non-compressed 
images. This is an example, where rebcode would help a lot, as a 
320x200 image can take several seconds to uncompress.
Usage:

iff-image: load-iff %some_picture.iff
img: iff-image/as-image

img now is a REBOL image!, than can be viewed like:
view layout [image img]

Crud, brief synopsis:

	write s3://<bucket>/my-file.txt "My File"

 write/custom/binary s3://<bucket>/my-png.png read/binary %my-png.png 
 [read]
	editor s3://<bucket>/my-file.txt
	layout [image load s3://<bucket>/my-png.png]

Requires AWS key and secret.

btw, the reason liquid-vid is taking some time, is that the whole 
layout is built using dataflow !  :-)

Category order setting works great. The new layout has more padding 
on Chrome than it did before (I may be wrong about that), but looks 
good to me. Great stuff! :)

Not perfect but it give results.

pie: pie-chart [
    size: 300x200
    start: -80
][
    "block" none 0
    "crash" #ff3030 .04
    "major" #ff6060 .09
    "minor" #ffb850 .44
    "tweak" #ffd850 .03
    "text" #ffd850 .02
    "trivial" #ffd8a0 .31
    "not a bug" pewter .06
]

view layout [
    box 300x200 white effect [draw pie]
]

try this on linux...

pie: pie-chart [
    size: 300x200
    start: -80
    text: [pen gray text ]
][
    "block" none 0
    "crash" #ff3030 .04
    "major" #ff6060 .09
    "minor" #ffb850 .44
    "tweak" #ffd850 .03
    "text" #ffd850 .02
    "trivial" #ffd8a0 .31
    "not a bug" pewter .06
]

view layout [
    box 300x200 white effect [draw pie]
]

pie: pie-chart [
    size: 300x200
    start: -80
    font: make font [size: 10]
][
    "block" none 0
    "crash" #ff3030 .04
    "major" #ff6060 .09
    "minor" #ffb850 .44
    "tweak" #ffd850 .03
    "text" #ffd850 .02
    "trivial" #ffd8a0 .31
    "not a bug" pewter .06
]

view layout [
    box 300x200 white effect [draw pie]
]