AltME groups: search

lay: layout [btn "start" [lay/rate: 1 show lay] btn "stop" [lay/rate: 
none show lay]] lay/feel: make lay/feel [detect: func [face event][if 
event/type = 'time [print ['tick now/precise lay/rate]] event]] view 
lay
p: open http://www.rebol.com
close p
view lay

Just noticed: HIDE stopped minimizing a window face some time after 
1.2.5.3.1, eg:
	view lay: layout [button [hide lay]]
Is that a bug, or intended? (I'll check this out more later.)

i have a wish: integrating 'comment in some more dialects. parse, 
layout come to mind. could then be used for embedded documentation. 
what do you think?

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.

view layout [text "Après noël en forêt" box 150x20 effect [draw [text 
0x0 "Après noël en forêt"]]]

Please mock up an example -- you could do it in View layout  -- that'd 
make the discussion more concrete.

Good news -- no absolutely positiioned DIVs, so it is a fairly fluid 
layout, will flow easily into most window size.


Bad news -- main frame of site is a table. Originally, it was nested 
DIVs but that caused some layout problems when displaying <pre> sections 
of code. Going to a table was a quick fix that has never been looked 
at again.

ctx: context bind [
	chars: charset [ #"A" - #"Z" #"a" - #"z" #"0" - #"9" #"-" #"_"]
	non-chars: complement chars

	set 'copy-word has [start end end-rule car-pos] [
		if any [not focal-face not caret] [exit]
		
		car-pos: index? caret
		end-rule: copy []
		
		parse/all head caret [
			any [
			 	start: some chars end: (

     if all [car-pos >= index? start car-pos <= index? end] [end-rule: 
     'break]
				) end-rule
				| some non-chars (start: end: none)
			]
		]

  if all [start end] [write clipboard:// probe copy/part start end]
	]
] in system/view 'focal-face

view layout [
	area "This is some text to test"

 text "To copy the word under the cursor : hit CTRL+K or press the 
 button bellow"
	button "Copy word" #"^K" [copy-word]
]

is it possible to use an object variable for a VID item, such as 
obj: make object! [t: none] where I would like view layout [obj/t: 
button "hello"] in some way? it doesn't work...

o: context [var: none]
layout [button with [o/var: self]]
o/var/type ;== face
o/var/style ;== button

For example, don't do this:
text: context [var: none]
layout [button with [text/var: self]]
** Script Error: Cannot use path on none! value
** Where: forever
** Near: text/var: self

The most elegant solution would be to patch layout so it accepts 
set-paths.

blocks are also great for composing in, e.g creating a dynamic layout 
block to pass to the layout function or draw

view layout	[
    across
    lbl "field 1" f1: field return
    lbl "field 2" f2: field return
    btn "hide f2" [hide f2]
]

Could you help me anybody? I have a simple sequences of commands: 
  view layout [label "hello"]  tx: request-text "something" ... I 
need invoke request-text immediately after main window showed - not 
after the main window is closed...

So if i use view layout [.....] it is as some as if i use: view/new 
layout [....] do-events ?

I can not understand behaviour of my example:
If i have a script1.r:
view layout [ ...
  btn "script2" [
    do %script2.r      
    print 123
  ]
]
... and sript2.r has: view layout [.....]
I expected that <print 123> will not execute because 
script2 has view layout... (no view/new layout [...])

it does not seem to work:

view layout [btn "So what?" [inform layout [text "So what?"]]]

so how can i get layout of requester(f.e. request-text) to do it 
?> insert tail system/view/sreen-face/pane/1/pane   <what?>

LAYOUT calls GROW-FACETS which handles some types and collects others 
in blocks to let NEW/MULTI handle them (where NEW is the face which 
is being created.) See the code here:
print mold get in svv 'grow-facets

Plus the user interface loks a little off because it is written for 
an older version of WinCE, and the title bar didn't match the standard 
layout even then.

I haven't tried it on the smartphone layout, but I would be shocked 
if it worked. :)

people who startout using Ubuntu, Fedora or Redhat find themselfs 
In an Linux world that not even default with i.e. Disk-Structures 
on Tru64 or Solaris or HPUX.. while using other Linux distributions 
from around 1995 they stick with the UNIX system (IV|V) layout..But 
when it comes to development I can emagine to make a choice between 
"package handling" and "environment handling"... Then I would stick 
with debian..just has a better package manager...where slackware 
is a little more the "do it yourself package manager.." still 'tar 
does wonderful things.. for the user...

fnt1: make face/font [
	name: "/usr/share/fonts/truetype/freefont/FreeSans.ttf"
	size: 32
]
fnt2: make face/font [

 name: "/usr/share/fonts/truetype/freefont/FreeSansBoldOblique.ttf"
	size: 64
]

view layout [
	origin 0
	box snow 400x100 effect [
		draw [
			pen black
			font fnt1
			text anti-aliased 0x0 "Rebol Rulez!"
			pen blue yellow
			fill-pen red
			line-pattern 10 10
			line-width 2
			font fnt2
			text vectorial 0x30 "Rebol Rulez!"
		]
	]
]

view layout [b: box 200x100 navy image help.gif feel [engage: func 
[face action event][if find [over down] action [b/text: mold pick 
face/image event/offset show b]]]]

For the next release I will be changing the way in which the locale 
works. (For security reasons)

The locale.r file will no longer be evaluated ... i.e. the program 
will no longer do %locale.r.
The program will expect a pipe seperated file something like
    ; menu items
    gm_about|About
    gm_Accounts|"Accounts"
    gm_Contacts|"Contacts"
    gm_Folders|"Folders"
    gm_Help|"Help"
    gm_New|"New"
    gm_Preferences|"Preferences"
    gm_Send|"Send"
    gm_Unread|"Unread"
    gm_Layout|"Layout"

    ; gui items
    gt_Add|"Add"
    gt_Add-to-cont|"Add to Contacts"
    gt_Attach|"Attach"

i guess that should be 'layout

you can basically have the artist doing the pics and layout, and 
 a developper doing the code part...

so can you speak a REBOL script into here? Oops forgot, not Messenger 
where do [ view/new layout [ box ] ]  can be done...

view layout [image percent photo.JP button "quit "[quit ] ]

One question though. Both class and id are used mostly to describe 
layout. I mean - Gabriele's temple uses class and id to identify 
what/how data should be filled in, but it may not be in correspondence 
with design. I should note, that Temple design is how I imagine templating 
system should work. When you work in trio-mode - user (entering data 
into app), programmer and designer (which can't program), most template 
systems are not acceptable, as they break the ability to see the 
design work result, unless loaded into production environment, and 
that is not acceptable in my situation ...

on Gab's Temple. 


pre-defining the 'id' is a way for developers and designer to communicate 
and agree on certain stuffs. That is how the separation of work is 
being done. Developer will code with 'address' in mind in their business 
logic..and designer just design the layout and only need to put in 
id 'address'.

Divs are ultimately more flexible than tables.

Tables have their place -- for the display of tabular data as they 
were intended.
For page layout and markup, DIVs are ultimately less boxy.

They also, usually, produce data flow that is more friendly than 
tables for people using accessibility aids.

I have a problem with some layout.


Trying to align an output of 'processingtime' and some 'footer' on 
the same line.. but I always end up wiht the footer a line below. 
The left-right alignment is correct though.

---
.footer {
	text-align: right;
	font:10px verdana, arial, helvetica, sans-serif;
	color: #666;
	background: transparent;
}

.processingtime {
	text-align: left;
	font:10px verdana, arial, helvetica, sans-serif;
	color: #666;
	background: transparent;
}
--

--
<div class="processingtime">some processing time</div>
<div class="footer">some trademarks stuffs</div>
--

view lay: layout[
 button "title-time" 300[
  lay/text: form now lay/changes: 'text show lay
 ]
]

We can't make  layout transparent but we can make inside window transparenc 
level maybe this coud be a good thing to dig on

Why would you need to differenciate them ? The same words can be 
interpreted differently by LAYOUT or DISPLAY.

view layout [box edge [size: 10x10 image: logo.gif]]

view layout [box edge [size: 12x12 image: logo.gif effect: [tile 
gradcol 1x1 255.0.0 0.0.2
55]]]

view/options lay: layout [
	box "Bouncing window !!" 300x200 rate 1 feel [
		engage: func [f a e] [
			if a = 'time [lay/changes: 'restore show lay]
		]
	]
	text "Minimize me (if you can ;-)"
] 'resize

just a detail: in facets document, /span datatype is pair! . you 
could use it to store other data, but if you set a pair! to /span, 
/view will use it as virtual size for face (it still works in later 
betas, so one should be careful to not use it to store coordinates) 
ie:
f: layout [
   banner "Testing /span" guide 
   box 400x400 effect [gradient 1x1 0.0.0 255.255.255] 
   button "Hello!" return 
   text-list data ["just" "a" "list"] 
   image logo.gif logo.gif/size * 2
]

f/span: f/size  ; here we tells /view to use virtual coordinates 
for all subfaces

view/options f 'resize ; will give a fully resizable window (widgets 
included), but it only works for reducing window's size.

As long as there is a glossary that let's you translate from familiar 
terms, I think you're OK using REBOL's native terms, though they 
were foreign to me when I started.

Window or dialog?

 Or Screen or Form or Layout. A Dialog is usually something other 
 than the main screen in an app. You sometimes need to use all those 
 terms if you're speaking in the domain of an application, so use 
 wha'ts appropriate in each context. 

Face or graphical object?

 Or Control or Widget. Tough call on this one. I was used to Control 
 from VB, and Face confused me as it could be a layout as well. I 
 like distringuishing between layouts and controls. Hmmm Maybe a hierarchical 
 tree.

Facet, attribute, property or descriptor?

 I like either Attribute or Property. I can live with Facet in REBOL, 
 it's shorter, and it makes sennse if you think in terms like "let's 
 discuss this facet of the business". 

Style, widget or template?
	Style, definitely.

bug: the last widget in a rebgui layout determine the width of the 
face - if the last widget is narrow, the window is narrow.

fix: in %display.r, you have to keep track of the maximum x value:

- near "xy: origin-size" you can initialize a 'max-width: "max-width: 
origin-size/x"

- in parse loop, just after xy update "xy/x: xy/x + last-face/size/x", 
you can update the 'max-width: "max-width: max max-width xy/x"

- after (outside) the parse, near where the y size is last updated 
"xy/y: xy/y + last-face/size/y", you can set the x size to be the 
'max-width: "xy/x: max-width"

In http://www.dobeash.com/it/rebgui/widgets.html, 

in Feel function templates, there's missing the 'move event in engage.
It's used for dragging actions in a layout.
Here a vertical splitter widget using it :

Following documents updated to reflect latest changes / feedback:


 RebGUI Display User's Guide	- new layout refinement plus widget descriptions 
 added
	RebGUI Widget Designer's Guide	- init attribute added
	REBOL/View Facet Summary		- various

yep layout

Vincent: 'list behavior & features - less is more at this stage, 
once we have something to look at we can refine it.


shadwolf: 'text+ removal. While a useful widget for certain domains 
(like WYSIWYG editors / browsers) it's not a basic building block 
widget. There were also some unresolved implementation issues with 
it at this stage - I'll add it back in at a later date as an optional 
or advanced widget.


shadwolf: multi-column list. An implementation model I liked was 
that adopted by Gui4Cli ( http://users.hol.gr/~dck/g4c/) which allows 
simple "table" representations (including column type and alignment 
definitions). Can't say I've come across that many UI's that use 
anything other than text / numbers in a standard list (thumbnails 
and scrolling check-box options are usually implemented in an app 
specific manner).


Ammon: 'display/popup. If it's sufficiently different from 'display/layout 
then I'm all for it.


Ammon: Wizard style. A wizard widget, if simple enough, would be 
a good addition. Like 'group-box and 'tab-panel it is a meta-widget 
that groups / uses other widgets. I'll make this distinction clearer 
in the next version of the docs. On a side note, my install example 
has convinced me of the need for an 'indent option (and the fact 
that use of 'offset should reset the line-height calculation).


Ammon: "Unless otherwise specified, text size reverts to 200x9999 
if the string contains a newline." I probably need to rephrase this, 
but what I was trying to say was that by default 'text is 9999x20 
which let's you write a string without having to know it's width 
in advance (9999 will auto-size it), *but* if the string contains 
a newline then it is the height that is the more important variable 
so it'll use 200x9999 instead. Of course it'll only do this if you 
don't provide an explicit size yourself (the "unless otherwise specified" 
bit). Hope that makes a bit more sense.

Display/Popup is significantly different from /Layout.  /Display 
appends the face that is generated to System/View/Screen-face.  This 
makes it so that a popup can extend beyond the window of your application.

splitter: adding a richt-click to reset splitter to original position. 
If users have screwed up their layout ;-))

Personally, I think it would be very cool to have a non-RT GUI dialect 
that was better than VID, but just as flexible.  I wrote VID in very 
short period of time, and it was disigned for more than what it is 
typically used for.  For example, VID is written in such a way that 
it makes it easy to write something like the Layout script -- because 
you can return to the original VID source code from the face itself.

so things like view layout [ btn "EXIT" [quit]] would be writed in 
more than a sigle line in REBGUI ;)

WRT my question about extending/customizing layout. Would it be possible 
to add something to RebGUI so that this is possible:
	if my-var > 5 [optional: button red 100]

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

resizing system: How about a method that will store the layout if 
altered by the user and reload the GUI in the same layout? It always 
drives me nuts if I have to resize application splitter bars, panes 
etc. when starting again.

a simple way could be 

1) VID -> RebGUI : a 'face widget for RebGUI, to put any prebuilded 
face (ie made by 'layout) in a display,

2) RebGUI -> VID : a 'make-face -like function to build a reusable 
RebGUI face

i hope. after all, both create faces. thee are a few differences 
in your api (action has 2 arguments, init is function). and you have 
a resize-system. will look what i can do. at least something like 
  vid[ vid-stuff ] ; symply calls 'layout
should be doable.

Yes Anton.  I'm looking for a brief example - a small layout that 
shows the capability.

I remember when /view first came out it seemed there was someone 
that made a gui that was eliptical using only faces and no layout.

Usage: 
my-face: layout [field "just a field" [print face/text]]

display "A RebGUI display" [
    ...
    x-face [data 'my-face action [print "Hi!"]]
   ...
]

I was also thinking about the feature that was being discussed that 
allows for more tabs than the width of the layout.  How about an 
option to allow the tabs to wrap when larger than the layout?  Take 
the number of tabs, divide the total by two and auto-size the tabs 
to the full width of the layout, just now there is two rows.  I think 
this would be a nice alternative behaviour for when the user interface 
benefits from being able to see all possible tabs.

Why does the following not work ? Anamonitor shows that the engage 
got into place, but the rate doesn't work. I seam to forget something,
 
with rebgui:

do %rebgui.r
display "test" [
    text "hello"
    do [
        face/rate: 5
        face/feel: context [
            engage: func [f a e][
                print 'bla
            ]
            redraw: detect: over: none
        ]
    ]
]
do-events


with vid:

x: layout [button "hallo"]

x/rate: 5
x/feel: context [
    engage: func [f a e][
        print 'bla
    ]
    redraw: detect: over: none
]

view x
do-events

???any help :-)

main: layout [
  space 2 origin 4
  across

  style pane-tog tog of 'panels		; Just to avoid puting {of 'panels} 
  in each tog lines below
  pane1-tab: pane-tog 100x30 "Pane 1" [show-pane pane1]
  pane2-tab: pane-tog 100x30 "Pane 2" [show-pane pane2]
  pane3-tab: pane-tog 100x30 "Pane 3" [show-pane pane3] return
  content-pane: box 300x200 return

  btn white "Save" ; Save and Apply are used here for decorative purposes
  btn orange "Apply"
  btn sky "Close" [unview]
]

pane1: layout/offset [
  across
  text "Setting 1" field return
  text "Setting 2" field
] 0x0

...

The note talk about layout/TIGHT, but you did not use it before !!!!

hmm... this will mean that the layout/offset is not the same as contents-pane/pane/offset

well, if you can write a stylesheet that outputs a layout.  Not at 
all impossible, <xsl:output method="text" />

format-xml: func [ xml
    /local out space prev
][
    out: copy ""
    spacer: copy ""
    prev: copy </tag>
    foreach tag load/markup xml [
        either tag = find tag "/" [
            ; we have a close tag
            

            ; reduce the spacer by a tab unless the previous was an open tag
            either not tag? prev [
                ; not a tag
                remove/part spacer 4
            ][
                ; is a tag
                if prev = find prev "/" [
                    ; last was a closing tag
                    remove/part spacer 4
                ]
            ]
        ][ 
            either tag? tag [
                ; current is tag
                ; indent only if the prev is not a closing tag
                if not prev = find prev "/" [
                    insert/dup spacer " " 4
                ]
            ][
                ; is data
                insert/dup spacer " " 4 
            ]
        ]
        repend out rejoin [ spacer tag newline ]
        prev: copy tag
    ]
	view layout compose [ area (out) 400x400 ]
]

obj2xml: func [ obj [object!] out [string!]
	/local o 
][
	foreach element next first obj [
		repend out [ to-tag element ]
		either object? o: get in obj element [
			obj2xml o out
		][
			repend out any [ o copy "" ]
		]		
		repend out [ to-tag join "/" element ]
	]
]

You should, we can talk to you about how to configure your drive 
in the first place.  I have some simple tricks I do for my laptops 
(I only use laptops, and live on them). 

Quick list:

Put everything in PGP folders.

Install XP to a small partition, and have a ghosted version on the 
same drive (seperate partition).

Basic layout is C: = Boot and XP, D: = Data (your personal Data, 
E: = Extra applications, Z: = Archive og Ghost of C:.
Keep the custom Ghost CD for your laptop with you.


With this, if somoene steals your computer they don't get your data.
If C gets corrupted, you can recover.
And, it is REALLY easy to back up just your data fast.

snd: load http://krutek.info/rebol/sound.r

view layout [
	button "play" [
		wav: make sound [rate: 22050 data: snd] 
		print "make wav" ? wav
		sndport: open sound:// 
		insert sndport wav 
		print "insert sound" ? wav
		close sndport
	]
]

denismx, when I've taught REBOL to people, even people who are already 
familiar with other programming languages, it has been helpful to 
make the distinction between the REBOL language and the dialect engines.


REBOL is really a data model and related syntax, and a bundle of 
library functions that manipulate data in this model. A dialect is 
really a semantic model for interpreting this data, like what people 
think of as a language in real life. A dialect engine is a set of 
library functions that think of the data in the same way - I know 
this sounds anthropomorphic, but it makes it easier to explain REBOL 
if you think of the different dialect engines as entities that are 
acting on a set of commands you are giving them. You can even use 
role playing to demonstrate this, having one of your students act 
out the part. It also helps to name each of these models after the 
main function that implements them - otherwise people might not get 
the distinction between them and REBOL as a whole.


There are some functions that only deal with the REBOL data model 
and don't really do anything with the data other than translate it 
from or to some concrete syntax. It is best to group these functions 
by the syntax they implement - the group that implements what people 
normally think of as the REBOL syntax is LOAD, SAVE and MOLD.


When teaching REBOL dialects I usually start with what I call the 
DO engine, what people normally think of as the REBOL language. DO 
is a stack machine like Forth, but it uses a prefix syntax to make 
it easier to use (by making DO dialect code more resemble that in 
other programming languages). DO also does a simple swapping hack 
to implement inline operators, which you will have to demonstrate 
so that your students will understand DO's operator precedence or 
lack thereof. DO always works on REBOL data: If you pass it a string 
or file that contains REBOL syntax code, DO will call LOAD to convert 
it to REBOL data - this is an important distinction to make so that 
your students can distinguish between the data and the processor 
of that data. There are many functions that depend on DO to interpret 
their blocks of "code", such as IF, WHILE, FOR, etc. It is important 
to note that these are just functions, not "syntax". DO's only syntax 
is the predefined operators that DO swaps (these are effectively 
keywords because of how the swap is implemented), the word/set-word/get-word 
difference, the interpretation of paths and the precedence of parens. 
Everything else is a function.


There is also the PARSE engine, a rule-based recursive-decent parser 
with limited backtracking, that implements three dialects (simple 
parse, string parse and block parse). These dialects actually have 
keywords, as well as an entirely different execution model. Also, 
there is the View engine, which implements the LAYOUT and DRAW dialects.


Refering to these engines as state machines isn't helpful, because 
the distinctions between their execution models, or whether they 
even have execution models, is important for distinguishing between 
them. You need to use the higher-level terms like stack machine, 
composition engine and such.

I hope this helps!

Well, I've just manually extracted the rebol functions from my latest 
script demo-virtual-face.r (as posted in the View group), so I'm 
looking at those. I've excluded layout and draw dialect keywords. 
The order in which the functions appear is interesting. I have some 
duplicates. So now I'm analysing..

Ok, so here's my frequency table:
    6 compose 
    5 as-pair 
    5 func 
    4 do 
    3 show 
    2 all 
    2 copy 
    2 find 
    2 form 
    2 get 
    2 in 
    2 pick 
    2 print 
    2 to-image 
    2 use 
    1 * 
    1 + 
    1 - 
    1 <> 
    1 = 
    1 append 
    1 bind 
    1 center-face 
    1 change 
    1 clear 
    1 context 
    1 do-events 
    1 either 
    1 first 
    1 foreach 
    1 if 
    1 join 
    1 layout 
    1 load-thru 
    1 make 
    1 mold 
    1 object? 
    1 reduce 
    1 remold 
    1 remove-each 
    1 repeat 
    1 second 
    1 select 
    1 to-pair 
    1 to-path 
    1 view

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.

Version 2.6.0 available.... now with first version of LAYOUT... (only 
buttons available now) http://box.lebeda.ws/~hmm/rswf/example/swf8-layout-buttons

Version 2.8.0 available....

- Updated layouter (now with new 'Field, 'Password and 'Area GUIs)

http://box.lebeda.ws/~hmm/rswf/rswf_latest.r
http://box.lebeda.ws/~hmm/rswf/rswf_2.8.0.r


New example script: http://box.lebeda.ws/~hmm/rswf/example/swf8-layout-fields

Version 2.9.0 ... now with Calendar GUI and fixed one nasty bug in 
'IF compilation after 'EITHER rule
http://box.lebeda.ws/~hmm/rswf/example/swf8-layout-calendar

It is possible to create drag'n'drop editor in the dialect as well.. 
but first I have other goals. And maybe one day you will be able 
to create layout from Rebol VID too.

To give you an example.. this.. 
<?xml version="1.0" encoding="utf-8"?>

<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml"layout="absolute">

<mx:Panel title="My Application" width="200" height="300" x="0" y="0">

<mx:Label text="Welcome to Flex!" mouseDownEffect="WipeRight" height="45"/>


</mx:Panel>
	<mx:PopUpButton x="483" y="20" label="PopUpButton"/>
	<mx:Accordion x="441" y="50" width="200" height="200">
		<mx:Canvas label="Accordion Pane 1" width="100%" height="100%">
		</mx:Canvas>
		<mx:Canvas label="asdf" width="100%" height="100%">
		</mx:Canvas>
		<mx:Canvas label="asdf" width="100%" height="100%">
		</mx:Canvas>
		<mx:Canvas label="adsf" width="100%" height="100%">
		</mx:Canvas>
	</mx:Accordion>
	<mx:CheckBox x="441" y="258" label="Checkbox"/>
	<mx:DateChooser x="238.5" y="31"/>

</mx:Application>

don't you think we need new windowing system for browsers? I think 
that view layout is not good model anymore ... it opens new OS window 
... but that will be regarded being a popup .... we imo definitely 
need rebol own windowing system ...

standard Windows user type designing,  bad layout, bad looks, cramped, 
and very inconsistent with itself in the first look!

an example to be site in courses about how NOT to design a UI.

1) why did you name somehow not traditionally functions as connect 
and disconnect?


open and close are already taken and I wanted to avoid pathing (sqlite/open) 
or prefixes (sqlite-open) as the number of words added to the global 
context is relatively few and I wanted them to be meaningful words 
in their own right (same reason why VID doesn't have vid-layout, 
vid-center-face, etc). Connect and disconnect are the commands used 
to login/logout of another user in many databases; so while the context 
is not strictly correct, they are recognisable DB words.

2) why can't we support multiple name-spaces?


You can via the connect/attach refinement (and this lets you transparently 
reference tables across multiple "databases"). Why would you want 
to concurrently access multiple databases that are *not* related 
to each other in any way?

3) can we have opened only one db at a time?


Yes, bar /attach as above. The benefit of this approach is that you 
minimise the number of file locks a single process obtains, and you 
don't have to track state information (i.e. you don't need to tell 
'sql which DB you are referring to).


4) Would it also be possible to extend e.g. 'headings to return non-string 
 values?

No, as it may contain strings like "count(*)"

5) don't agree with exposing functions as you did


I tend to write CONNECT, SQL, etc in upper-case so db references 
embedded in my code stand out. Come up with a better naming scheme 
that everyone likes though and I'll adopt it. ;)

For that matter, is it possible to specify the size of the client 
area relative to the page size, have it resize with the page, and 
have the REBOL layout inside handle the resize as if a View window 
had been resized by the user?

some usefull tidbits are pre and post layout hooks... which allow 
a style to add faces to its spec BEFORE layout is called (usually 
much easier than trying to create faces directly).

this is how the scroll pane works.  it adds its scrollbars to the 
layout, dynamically and then lets the layout take care of everything.

the post layout hook, allows you to react to the layout, just after 
its done, but before moving on to other gadgets.

which is handled in the gl-layout function.

this means that if no face in a layout can stretch or is elastic, 
the window will never allow resizing in that direction... trying 
to resize it beyon, will effetively resize the window back to its 
nominal size, allowing the other axis to resize freely.

this layout for example: 

column [
	header "enter text"
	field
]

will popup a window which stretches only in x by default

if you ever change something interactively and wish to recompute 
the layout (cause the sizing needs have changed for any reason) then 
call refresh on any face or group.

Hi Maxim, 
are there liquid pumps?

As an example, imagine a layout with 2 input values, and 2 outputvalues, 
which depend on both inputs, e.g. input 2 numbers, and get  product 
and sum.

Now if I change the value of 1 input field, the new value would flow 
to both output fields. As far as I understood liquid so far, I now 
need another way to notify those 2 output fields, that there are 
new values waiting. And they have to actively get the new data.

Now add a pump, which pumps the data into the system, so that dependent 
!plugs automatically are recalculated.

Is this possible now? What do you think about adding this?

applying this to a gui driven with liquid nodes, you could freeze 
the the whole layout on a modal window... and let your inputs continue 
to process in the background... updating animation, and reacting 
to async reads... for exacmple.


when you unfreeze the gui and call a refresh of the gui plug, all 
the data which was being processed in the background, is now automatically 
available ,as if nothing had been frozen and a simple update of the 
node, will refresh you gui with nothing to manage.

is the gui an actual picture of the school's layout.

The gui has the rooms names as buttons. When you press the room name 
its layout (made of buttons) is shown along with a standard feedback 
layout (a form to send requests via CGI POST)

I have a newer version which has the "ability modifiers" added as 
extra labels to the right of the abilites... it took me 5 minutes 
to do, and it only needs one new simple !plug derivative:

;- !ability-mod
!ability-mod: make !plug [
	valve: make valve [
		type: 'ability-mod
		;-----------------
		;-     process()
		;-----------------
		process: func [
			plug
			data
		][
			vin [{!ability-mod/process()}]
			plug/liquid: 0
			vprobe data
			if integer? data: pick data 1 [
				plug/liquid: to-integer (data - 11 / 2)
			]
			vout
		]
	]
]


and necessary linkage within the !character setup, and appropriate 
faces in the window layout.

As you know, I just totaly reviewed how liquid-vid will handle its 
layout (now a live prodecural network in its own), so I am hard at 
work building that, but I will definitely put some time on integrated 
unit testing, when I rebuild the visual graph editor.  its such a 
great idea, as we have discussed, the I/O aspect of plugs cannot 
be ignored in dataflow, so this would be a great way to profile, 
document and verify expected node behaviour.

btw, the work being done for liquid-vid's layout, is now the official 
prototype for the inital layout engine for GLASS

for the layout algorythm,  I actualy did a complete flow analysis 
of a row/column resizing liquid graph.  its actually rather simple, 
when you force yourself to follow what data goes where.  note that 
I was able to build this without creating a processing cycle... which 
is neat, since some values are going to the parent face and coming 
back to its pane elements.

I put 0% of time on site layout, once its done.  I just edit content 
and make the page.  its like editing make doc, but in html format... 
also, the tags are not standard html type tags  they nest directely 
 <p! text <b! is bold <i! and italic>>>

I'd say we need a presentation tool that relays layout data to a 
number of people along with streaming audio. That's my biggest issue 
with the experiences we've had with devcon videos.

rebol [
	title: "explore.r"
	version 1.0
	date: 2009-03-19
	author: "Maxim Olivier-Adlhoch"
	copyright: "2009(c)Maxim Olivier-Adlhoch"
	tested: "win xp"

 notes: "Add any dir to the dirs block.  options are self explanatory"
]

dirs: [
	%/C/ []
	%"/C/program files/" [expand]
	"%tmp%" [label "temp dir"]
	"" [ label "my documents"]
]

blk: []

explore-dir: func [path expand? /local cmd][

 call/shell rejoin [" explorer " either expand? ["/n,/e,"]["/n,"] 
 path ]
]

ctr: 1
foreach [item opts] dirs [
	ctr: ctr + 1
	expand?: found? find opts 'expand
	label: any [select opts 'label to-local-file item]
	append blk compose/deep [ 
		pad 20 
		(to-set-word setw: rejoin ["dir" ctr]) check (expand?) 
		pad 20 

  btn 200 left (label) [ explore-dir to-local-file item get in (to-word 
  setw) 'data ]
	]
	append blk 'return
]


view layout compose [across vtext right "expand?" vtext "folder" 
 return (blk)]