AltME groups: search

Yes, general sync framework, even for something better than IOS is. 
I am near writing proposal for who would be willing to develop file-exchange 
framework, but supporting certificates, e-signatures. Maybe I could 
get something like 1000 EUR for that, but I know that is hardly enough 
for you "west" folks :-(

I stoped looking for it. :-( If somebody finds something I would 
be interested. 

Besides that: I think it's not so easy to access the phone directly, 
e.g. I don't know whether there is some device what could be accessed 
when the phone is in the cradle or connected via bluetooth or infrared. 
Could be that it's just a Windows Explorer thing that it looks like 
a normal device and that this is hardcoded (it uses of course the 
com port somewhere in the background) so that even copying something 
to/from the phone is non-trivial. At least in this case one could 
write a small application which exports (in this case) the block 
of addresses, writes them to a file and the file could be read by 
Rebol.

Hi, 


I would like to ask about how to implement best the auto-upgrade 
facility in rebol. Now the question is, how to aproach it best way. 
IIRC, Detective does something like that. Will you help me to answer 
some of my thoughts?


- typically the mechanism can be rather easy - just go and read some 
site, check for filesize, if differs, upgrade. But that might not 
be sufficient ..


- or you can store somewhere .txt (.cfg whatver file), containing 
rebol block or object, and do some more clever stuff. Basically following 
questions come to my mind:

- do just simple version check and upgrade to higher version?

- imagine an app, developing rather fast, producing xy version in 
the beginning = update often - the list can get long to load - but 
- you have to maintain it, as some ppl can be on vacation and still 
running old version - so - split it into separate, per-version file? 
I mean - making reverse aproach - provide updating config file for 
each version available. example - you have version 1.0, there were 
two other releases, 1.1 and 1.2 - you check 1.0 upgrade cfg and it 
tells you, you can go directly to 1.2 version ... or not, and you 
go to 1.1 first, then to 1.2 .... the reason is, that some version 
might require to rebuild data structures etc etc., so it is not always 
only about switching .exe

Or am I complicating it in unnecessary way? any ideas?

Out of memory is a common message if tryimg to decompress a corrupt 
compressed file: Could your image be damaged?
decompress join  compress " abc" "c"
** Script Error: Not enough memory
** Near: decompress join compress " abc" "c"

IOS: I would not use it as a permanent server. Instead: When we did 
the bbs, carl fired up a fresh one. We had chat and file-syncing. 
I would prefer to use it in such short-term ways. Then backing project 
up to web.

has anybody been able to use the file transfer ? I tried to send 
jean-Francois  show.r but did not work ?

rif is only rebol indexed file. an indexed file is not an rdb. of 
course, if no rdb matching our needs is found we'll just have rif...

i'm guessing a flat-file would handle 99% of any reblets needs.

It looks like it breaks on html tags that might be broken.  For example, 
I was testing parse on a tab deliminated file and performing the 
following parse:

Hi all,    Have any of you written a parser to handle .rtf files?


I am trying create a simple template file that I can parse against 
to identify Underlined, Bold, Italic, or Regular field values.


Example:  (Since I cannot Bold, Italic, or underline within Altme, 
please pretend to see what I'm saying).

 Config File: (when I typed the following using WordPad) looks like 
 this


Default Arial font 10 * Regular Courier New font 11 * Italic * Bold
Bold Italic * Regular Underline * Regular Strikeout
Regular Underline Strikeout
Bold Italic Underline Strikeout

	Same file when using Notepad to view:


{\rtf1\ansi\ansicpg1252\deff0\deflang1033{\fonttbl{\f0\fswiss\fcharset0 
Arial;}{\f1\fmodern\fprq1\fcharset0 Courier New;}}
{\colortbl ;\red0\green0\blue0;}

{\*\generator Msftedit 5.41.15.1507;}\viewkind4\uc1\pard\f0\fs20 
Default Arial font 10 * \cf1\f1\fs22 Regular Courier New font 11 
* \i Italic * \b\i0 Bold\par

\i Bold Italic * \ul\b0\i0 Regular Underline * \ulnone\strike Regular 
Strikeout\par
\ul Regular Underline Strikeout\par
\b\i Bold Italic Underline Strikeout\par
\cf0\ulnone\b0\i0\strike0\f0\fs20\par
}


I can guess that fs20 refers to the default Arial font, while FS22 
is the Courier New font.
\i italic
\b bold
\ul underline
\par may mean newline
 

I am not sure of what I want the parser to return the results as 
and was wondering if someone has already made a generic parser of 
.rtf files, or can point me out to info regarding them?

I'm pondering attempting a PARSE lecture here on Altme;  It'd be 
run twice, 9am EST, 9pm EST (or somesuch)  Topic would be dialecting. 
 I want to see if it would work, but I'm no where near a professor 
level rebol.  So, think of it as a kindergarten lecture, as a trial.


Plan;  Post this message - see if there is feedback.  Allow for some 
Q&A time for specific topics of interest.  A week or two later, run 
a hour (probably less) of monologue (interruptions allowed for stuff 
that is just plain wrong ... but other than that participants would 
be asked to hold off on questions).  Followed immediately with a 
Q&A, complaint, correction session.  Then a DocBase page created 
with a merged transcript of the two timezoned lectures, things learned 
and hopefully something along the lines of a simple file management 
(or some such) dialect source code file.  R2 related - for me the 
R3 DELECT still hasn't sunk in.  If it works, then perhaps it could 
become a semi-regular activity...there is going to be a lot to discuss 
come "link to the rebol.dll" time.

Nope on the creep;  A DSL will be the outcome of the lecture.  I'm 
leaning either toward a password management dialect or a (simple) 
file management command set.

space: charset " ^-"
spaces: [some space]
chars: complement charset " ^-^/"
digit: charset "0123456789"
digits: [some digit]
section: [digits "." some space]
sub-sec: [digits "." digits spaces]
sub-sub-sec: [digits "." digits "." digits spaces]


rules: [heading some parts done] (where heading is the first line 
of the text file]

parts: [newline | section format_section | sub-section | sub-sub-section]


format_section:   copy sec section copy rest to newline (print reduce 
[sec rest])

hmm, continuous parse ... there was my request for it long time ago, 
and IIRC even Carl said, that it might be usefull. Imagine for e.g. 
encoders ... You read stream from file in chunks, and you evaluate. 
The problem is, when you need to backtrack, you would need to cache 
the stream. Dunno, if something like that is possible at all ...

Also, I was thinking of parsing file ports opened with seek mode.

Here's an example of what you could do with the PARSE proposals:

use [r d f] [ ; External words from standard USE statement
    parse f: read d: %./ r: [
        use [d1 f p] [ ; These words override the outer words
            any [
            ; Check for directory filename

                (d1: d) ; This maintains a recursive directory stack
                p: ; Save the position

                change [ ; This rule must be matched before the change happens

                    ; Set f to the filename if it is a directory else fail
                    set f into file! [to end reverse "/" to end]
                    ; f is a directory filename, so process it
                    (

                        d: join d f ; Add the directory name to the current path

                        f: read d   ; Read the directory into a block
                    )
                    ; f is now a block of filenames.
                ] f ; The file is now the block read above
                :p  ; Go back to the saved position
                into block! r ; Now recurse into the new block
                (d: d1) ; Pop the directory stack
            ; Otherwise backtrack and skip
                | skip
            ] ; end any
        ] ; end use
    ] ; end parse
    f ; This is the expanded directory block
]

Here's an revised version with more of the PARSE proposals:

use [r d res] [ ; External words from standard USE statement
    parse res: read d: %./ r: [
        use [ds f] [ ; These words override the outer words
            any [
            ; Check for directory filename

                (ds: d) ; This maintains a recursive directory stack
                [ ; Save the position through alternation

                    change [ ; This rule must be matched before the change happens

                        ; Set f to the filename if it is a directory else fail

                        set f into file! [to end reverse "/" to end]

                        ; f is a directory filename, so process it
                        (

                            d: join d f ; Add the directory name to the current path

                            f: read d   ; Read the directory into a block
                        )
                        ; f is now a block of filenames.
                    ] f ; The file is now the block read above
					fail ; Backtrack to the saved position
					|
					into block! r ; Now recurse into the new block
				]
                (d: ds) ; Pop the directory stack
            ; Otherwise backtrack and skip
                | skip
            ] ; end any
        ] ; end use
    ] ; end parse
    res ; This is the expanded directory block
]

Strangely enough I wasn't talking about code I had posted that you 
might have used. In the early days before REBOL.org, I tended to 
post code to the mailing list. The code that you would have used 
would have been in REBOL itself - I used to give very detailed messages 
to feedback about mezzanine bugs, usually with rewrites. Many of 
those rewrites made it into REBOL, especially in the 2.5 version. 
Some natives too (to-local-file and to-rebol-file were based on REBOL 
code I wrote and posted).

ahh... so we can blame you for to-rebol-file problems??  :)

http://members.core.com/~bhawley/rebol/to-rebol-file.r

#[datatype string!]  That way we can read data direct from a file 
port and without loading or reducing use parse to identify respective 
datatypes and datatype!.

Brian, it seems that when a file is parsed instead of a sub-directory, 
then your script duplicate the previous sub-directory

The point is though that I'd want it to fail.  The set-word! could 
be used as a delimiter:

	[link-one: %file-one "File One" link-two: %file-two "File Two"]

Would be matched by:

	some [set-word! of link-spec]	

Or in VID:

	some [opt set-word! word! face-spec]

remark is the basis for my proposal.   I can already to what I propose 
in parse v2... but I beleive it could be done so simply and could 
reduce your first example (the recursive file list) to a 5 line affair.

Pavel, this also works with datatypes.  For example:

>> mold/all string!
== "#[datatype! string!]"


This is useful if your loading values from a file.  This way your 
sure to set a value to a string datatype! when desired.

It does not even have parameter to distinguish directory and file 
- what a lame tool. You have to use trick - icacls c:\some-dir\sub-dir-or-file*. 
, which is relict of 8.3 naming, so actually it will match and dir 
and file, not having suffix ....

I got it working. I use the following trick - I identify DOMAIN\USER:(RIGHT) 
or (RIGHT) sections first. Then I put weirdly markers around and 
catch the rest with the skip. The file is "clean", so actually what 
do I skip is either spaces, or path. I do check in emit function:

emit: does [
 if find tmp: trim copy/part p-start p-end ":\" [path: tmp]
 print [path domain user rights]
]

;--- rules - spaces, tabs, newlines

spacer-chars: charset [#" " #"^-" #"^/"]
spacers: [some spacer-chars]

;--- user-rights rules
;--- would be easier, if filesystem would not allow () ...

right-char: charset [#"A" - #"Z"]
right-rule: ["(" 1 2 right-char ")" ]

rights-rule: [r-start: some right-rule r-end: (rights: copy/part 
r-start r-end)]

;--- rule to identify user part

user-chars: complement charset {".,;:\/*}
user-rule: [copy user some user-chars ":" ]


;--- rule to identify domain - I expect it being typed in CAPITAL, 
can contain "-"
;--- the exception is "NT AUTHORITY" - contains space

domain-chars: charset [#"A" - #"Z" "-"]
domain-rule: [
    "NT AUTHORITY\" (domain: "NT AUTHORITY")
    |
     copy domain some domain-chars "\"  
]


;--- rules for combinations of: rights only (RIGHT), or DOMAIN\USER:(RIGT)
domain-user-rights: [
     rights-rule 
    |
     domain-rule
     user-rule
     rights-rule
]


parse/all str: read from-file [p-start: any [ p-end: domain-user-rights 
(emit) p-start: | skip ] to end]

you need to maintain a map of keywords and codes   to that  in its 
own file and read it in to build your rules

pekr, parsing an xml file itself is quite easy.  


Actually, its converting and validating the xml schema or DTD which 
is complex because, basically you have to compile a new parse rule 
out of misaligned parsing concepts.  this will never be easier, until 
someone builds (and makes public) a simple to use, *complete* interpretation 
of each XML-based spec.  XML schema, xpath, etc.

BenBran:
Not sure where to put this so asking here:


I downloaded a web script and it has a  snippet I don't understand:
buffer: make string! 1024         ;; contains the browser request
file: "index.html"
parse buffer ["get" ["http"  |   "/ "  |  copy file to " " ]]

what does:

copy file to " "

mean or do?
tia

So, copy file to " " is the equivalent of this regular REBOL code:
file: if find data " " [copy/part data find data " "]

Sort of. The actual code is a little more complex, more like this:

either tmp: find data " " [file: if 0 < offset? data tmp [copy/part 
data tmp]] [break]

The break being a parse match fail, and file being set to none for 
a zero-length match.

I get whats happening now.  If i compare buffer and file I see the 
clipped text:

>> probe file
== "index.html"

>> probe buffer
{GET /a.html HTTP/1.1
Host: localhost

User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US) AppleWebKit/531.21.8 
(KHTML, like Gecko) Version/4.0.4 Safar
i/531.21.10

Accept: application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5
Accept-Language: en-US
Accept-Encoding: gzip, deflate
Connection: keep-alive
Address: 127.0.0.1}

>>probe parse buffer ["get" ["http" | "/ " | copy file to " "]]
== false

>> probe file
== "/a.html"
 
Should I have been able to see the results instead of  == false?

parse buffer [ "get" [ "http" | "/" | copy file to #" "  ( print 
file) ] to end ]
will return true

PARSE returns true if the rule matches and covers the entire input, 
or false otherwise. Your rule matched but there was input left over. 
PARSE's return value doesn't matter in this case, just whether file 
is set or not. If you are using R3 you can do this too:
parse buffer [ "get" [ "http" | "/" | return to " "]]

That would return the file instead of setting a variable and not 
return false because of leftover input.

try this way, with one replace  change may be more efficent , with 
2 replaces bith would need to be in the sccond half of the file , 
with three in the last third ,with 4 the last quarter ...so although 
there may exist pathological cases where it is more efficent it is 
best not to cater to them.  there  may also be an argument  for not 
allocating twice as much memory but iby the time your file is that 
large you are already running into problems (in r2 at least)

So an entry in the log file starts like this: "[15/May/2010 17:59:56] 
IP address 190.101.1.10 found in DNS blacklist SpamHaus SBL-XBL..."

digits: charset "0123456789"

ip: [some digits "." some digits "." some digits "." some digits 
]

newList: [] 
existingList: []

files: []
foreach file read %. [
	if find file "security.log" [
		split: parse read file none
		foreach it split [
			parse it [[ip] (append newList it) ] 
		]
	]
]

lines: read/lines file
foreach line lines [ ... ]

Ok, continuing the discussion from "Performance" group, I'd like 
to ask for some help with parsing rebol format files.

Basically, I'd like to be able to extract a block near the beginning 
or end of a file, while minimizing disk access.

The files to be parsed could be large, so I don't want to load the 
entire contents, but chunks at a time.

So my parse rule should be able to detect when the input has been 
exhausted and ask for another chunk.

(When extracting a block near the end of a file, I'll have to parse 
in reverse, but I'll try to implement that later.)

As far as I know, there is no way to instruct LOAD/NEXT to only read 
chunks from the file as necessary to load the next value.

Well, I'd like the algorithm to be general enough to get any number 
of block in the file. So far I need just the first, second and last 
blocks.

Um, actually, I remember years ago I wanted to load the rebol header 
of many files, avoiding loading the whole of each file.

Anton, the cost of disk reads dwarfs the cost of LOAD/next. And PARSE 
is much slower at loading REBOL data than LOAD. You might consider 
finding out the max size of the value you are loading, rounded up 
to multiples of 4096 (disk blocks), and just READ/part a bit more 
than that from the disk for each file. Then LOAD/next from the resulting 
string. There is no reason to do speculative reads once you have 
an upper bound on the size you will need to read. In a language like 
REBOL, minimizing disk reads sometimes means minimizing the number 
of calls to READ, not just the amount read.

My script is much more faster.. when I do:

tm: func [count [integer!] code [block!] /local t][t: now/time/precise 
loop count code probe now/time/precise - t]
tm 10 [
	dir: %/F/REBOL\altme\worlds\rebol3\chat\
	foreach file read dir [
		load-first-block dir/:file
	]
]

tm 10 [
	dir: %/F/REBOL\altme\worlds\rebol3\chat\
	foreach file read dir [
		first load/next dir/:file
	]
]

the result is:
0:00:01.047
0:00:06.39

load-first-block2: func[file /local port buffer result tmp ][
	port: open/direct file
	buffer: copy ""
	result: none
	chunks: 0
	until [
		chunks: chunks + 1
		if any [
			chunks > 10
			none? tmp: copy/part port 512
		] [close port return none]
		insert tail buffer tmp
		not error? try [result: first load/next buffer]
	]
	close port
	result
]

Btw... what would be best way to get the last block of the file without 
loading complete file?

what about using something like open/seek at port ((size? file) - 
chunk-size) chunk-size?

Getting chunks in reverse, from the end of the file towards the start, 
is not hard. It's the parse rule to go with it that's difficult.
But first I want to figure out the parse rule that goes forward.

and what if rule ic create dynamic form file in global words  and 
can not by  create in functions ?

I think he meant to ask "and what if RULE is created dynamically 
(ie. loaded from a file) and thus its words are global, and are not 
 (or cannot be) created by functions?"

thank you steeve but i need it for a production server  to parse 
log file for nagios

the best is to copy it to a file and run it.

I use the new INTO string feature a lot with file management code.

I understand the principe, but as I say, on real file it stops.

Thanks... just uploaded a new file on rebol.org... I mistakenly put 
a old one :)

Me? That file must have been wanderd in accidentally.. *whistle*

aaand where is it? i downloaded the file mentioned above but no difference

Oh, and request-file needs the /keep refinement restored.

Added an attempt 

lst: text-list 100x50 data [(read-dir path)] [
				attempt [

    path: dirize clean-path join path pick face/data first face/picked
				show-text txt to-local-file path
				insert clear face/data read-dir path
				face/redraw
			]
			]

Added Czech dictionary file (see http://www.dobeash.com/it/rebgui/roadmap.html) 
and dat files provided by Bobik (see http://www.dobeash.com/files/CzechWin.dat
and http://www.dobeash.com/files/CzechLinux.datfor different char 
encodings - win-1250 & ISO-8859-2 respectively).

in the radio group though, I have a form already up, and I am pulling 
in data from a file to repopulate the form.

So, in the do block of the window, I am reading the data from a file, 
and then settting all the values.

Fair enough, although in that case you could also do something like:

	blk: read my-file
	display "" compose/deep [
		...
		r: radio-group 30 data [ (blk/5)  "M" "F" ] 
		...
	]

request-dir ?
request-file ?

okay i see the edge bug now when i merge the listview code in the 
regui-wiget.r file ^^

Hi. Just looking through rebgui. A question and a comment. (1) In 
the readme.txt file there is a reference to Opera icons but no reference 
to the licensing of those icons. Where can I find the icon licensing 
information please?

(2) I like the table widget with it's sortable columns. But at first 
had problems with trying to sort in the reverse direction because 
I was targetting the sort indicator triangle which does not do anything.

Latest build available at: http://www.dobeash.com/files/RebGUI-038.zip

Issue log: http://www.dobeash.com/it/rebgui/issues.html


*** Unzip this file into your existing RebGUI 0.3.0 distribution. 
Requires View 1.3.1 (1.3.2 preferred) ***


This is mainly a bug-fix release with a new prototype event trigger 
system (see %"Demo - actions.r") and a very early proof of concept 
bubble-menu (see %"Demo - bubble-menu.r").


I'm particularly keen to see whether the event trigger system is 
flexible enough to remove [or reduce] the need for a dedicated (and 
hard to design / implement) one-size-fits-all "field validation" 
system as discussed previously. The bubble-menu demo shows how transparency 
and event detection within a non-square area *could* be done. The 
implementation is not perfect (or anywhere near usable) so I'm open 
to alternate design suggestions! ;)

ashley  my ten seconds solution for edge  problem with listview integration 
to rebgui rebgui-wigets.r file

One file - should be easy. Use prebol. Like encap: you get a single 
file. but that file is text.

That file you can do in your application. rebservice-lib seems to 
use that, + compression.

Here is a rebgui in a single file. Hope that works. Not fully sure 
because %tour.r needs the rebgui around it for images, so maybe touches 
source too. http://polly.rebol.it/test/test/mixlib/libs/rebgui/rebgui38-full.r

i don't know if that's clear 1.2.8+ rebol/vie version create a public 
directory in the local directory where the script is launched and 
not using anymore the  global rebol/public directory.  libskin installaer 
was design to install all file in the global rebol/public directory. 
As this  system have been broken in  early betas  this produce to 
get as many install of libskins in local public directory that u 
have scripts running it. I fear an online distro system for rengui 
willl produce the same issue... and forcing us to install a rebgui 
version not once for all in rebol/public directory global but in 
local script directory ...

Robert, checksum is not as good as size and date because the file 
has to be downloaded to be sure of the checksum, *or* Ashley has 
to upload an index file containing all the checksums for all the 
distro files every time one of them changes.

I make that statement based on the assumption that it is a regular 
webserver and it doesn't have a way of returning only the checksum 
of a file.

However, it can be a good double check after the decision to download 
has already been made and the file downloaded.

I retract that last statement - it implies you know the checksum 
of the remote file.

anton, what is the problem with checksum? It depends on syncing strategy, 
but you have those files on both side (client, server) anyway. afaik, 
the problem with checksum could be its speed. But since we have open/seek, 
we could do checksumming defined,e.g. 3 parts of files, first xy 
bytes, last xy bytes and defined skip somewhere to the middle of 
the file ... dunno if it would work though :-)

I've come against a strange problem. When I do this
	read http://www.dobeash.com/files/rebgui/dictionary/American.dat

it stops and gives a network timeout after reading 23% of the file.
bytes: 68432 of total: 293605 = 23.31 %

This is repeatable. I tried with read-thru/progress and a simple 
read.
Bizarre

Maybe a misunderstanding. "rebpress" must be the first part of the 
file-content. not the filename

Ashley: what about adding in a radio-group in the rebgui-widgets.r 
file the line

pf/action pf

below the line ca. 1340 

face/action face

in the init section where the engage feel is defined. 

I needed to be able to execute the 'action function when the radio 
buttons change, but in the current implemention only the local action 
functions of the single buttons get evaluated, not the sourounding 
group. But if I'm right only for the parent level the action block 
can be defined, as the layout function only sets this block (if found). 
So either I missed a way even to set the functions for the single 
buttons (via normal means - no hacking) or it would be good to add 
at least the above shown line.


secondly some improvements which would be nice, what's everybodys 
opinion about this:

1. in order to be able to get a reference to a window - display should 
return the window-face

2. it should be optional whether the first window will be the parent 
of all other subsequently opened windows, as this affects the behavior 
of the order of view of the windows, eg. I can't bring the other 
windows completely to the front


it's no big deal to insert it into the code right now, but maybe 
it makes sense to have some of these options in general.

How to actually supply so small changes to the project ? Just posting 
them here - I guess so ?

Create a file called %test.r in view-root/public/www.dobeash.com/files/rebgui/ 
with the following:

	REBOL []

	do %rebgui.r


 view layout [text form system/version button "RebGUI" [display "" 
 [text "RebGUI from VID"]]]


and then run by double-clicking it. I see "1.3.2.3.1" in the text 
and clicking "RebGUI" displays the RebGUI window.

0.3.9 is out and it has a lot of fixes / enhancements. From a REBOL/View 
console:

	do http://www.dobeash.com/get-rebgui.r
	do view-root/public/www.dobeash.com/RebGUI/tour.r


The dictionary file has been removed from the distribution and the 
download path has been changed from:

	www.dobeash.com/files/rebgui -> www.dobeash.com/RebGUI


so you may want to delete view-root/public/www.dobeash.com in its 
entirety first to clean things up.


In addition to the large number of fixes ( http://www.dobeash.com/it/rebgui/issues.html#section-2.2
), a number of enhancements are documented here:

	http://www.dobeash.com/it/rebgui/display.html#section-2.1.7
	http://www.dobeash.com/it/rebgui/display.html#section-3.2.4
	http://www.dobeash.com/it/rebgui/display.html#section-3.2.5
	http://www.dobeash.com/it/rebgui/display.html#section-5.20

Also note the following:

	view-face is now activate-on-show by default

 Added a request-password requestor (its password widget problems 
 are known issues)
	group-box and tab-panel now auto-size

 Table column headings are now always left aligned and clicking the 
 arrow works

 Added an 'effects context (only window is present, but others like 
 'button, 'check, etc may be added in future)


And lastly, you will notice that %tour.r has a new "Appearance" tab 
where you can dynamically alter RebGUI's metrics, colors and effects. 
Note that some colors are still "hard-bound" at context creation 
and won't change - these will be made dynamic (via a set-colors func?) 
in the future. Apart from showing off RebGUI's dynamic scaling and 
display abilities, this lets you more easily prototype a unique look 
for your own apps if you want, and if you come up with a set of options 
that is truly fantastic then share it here and it may just become 
the new RebGUI default.

Enjoy!

Depends. You can structure your code so that all the displays are 
in one file and all the business rules / data / action logic in another 
by coding like this:

display "Test" compose/only [
	button (app/labels/save) (app/actions/save)
	drop-list data (app/options/save)
]


and using references to face (and face/parent-face) within your actions. 
This approach achieves a couple of things:

	1) Separation of display from process

 2) code / data reuse (i.e. you can share data / action blocks across 
 multiple displays)

 3) Can reduce the amount of code that is composed as app data / logic 
 can be composed independently of the display
	4) Code is more portable (as face references are generic)
	5) Probably easier to maintain and debug

Problems with this approach are:


 1) "f: field" is easier to reference than "face/parent-face/pane/2" 
 etc
	2) You have to really think about how you structure your code
	3) It's very different from the way we are used to (VID)

Need request-file/keep .. have to comment out rebgui's request-file 
because it lacks this.  Thanks.

If the mouse is a waste of time for your users, then they don't need 
a GUI. Just deliver data entry functionality via a console type application. 
My users [medical] make extensive use of TabletPCs so no mouse / 
pen is a bit of a deal-breaker for me. ;)

the mouse is waste of time, totally

 ... so you don't use a mouse for file management (File Explorer) 
 or browsing? And of course you don't need one for Paint type operations? 
 Not everyone who uses a computer is doing pure keyed data entry. 
 Different strokes for different folks.


Anyway, I'm gradually adding keyboard support to RebGUI as time and 
REBOL fixes permit; but it's not high on my list of priorities.

File management? Ah no, you Windows users :-) I would really like 
to see a video, how one can work effectively using such sh*t like 
windows explorer :-) No, I do use Total commander, totally without 
single mouse press ....

well, so we have altme, even with file-sharing, and we are moving 
to clumsy web methods? :-)

In the works. I've already restructured the source by removing each 
widget (from %rebgui-widgets.r) to its own <widget>.r file under 
a new %widgets/ directory. Next step is to create a link to each 
source file under its matching WidgetsList Wiki entry.


I've also created a monolithic script (striped output from prebol.r) 
which resides at: http://www.dobeash.com/RebGUI/rebgui.zip


The intention at this stage is to have multiple source files that 
can be collaboratively worked on, with a "build" every so often to 
merge them into a single script for easy access / deployment (not 
everyone will want to grab the source from SVN). The fact that each 
widget resides in its own source file now makes it very easy to "plugin" 
additional widgets.

The problem is in file: rebgui-widgets.r inside the choose function. 
I don't have a clue what I have changed in my app to trigger the 
problem.

Here is a short example when it fails:
rebol []

;--- Startup
if system/product == 'Link [

 attempt [call reduce ["d:\rebol\view\rebol.exe" system/script/header/file] 
 quit]

 attempt [call reduce ["c:\programme\rebol\view\rebview.exe" system/script/header/file] 
 quit]

 attempt [call reduce ["c:\rebol\view\rebol.exe" system/script/header/file] 
 quit]
	quit
]

;-- use xpeers framework structure
link-root: first split-path system/script/path
link-root: copy/part link-root index? find link-root "/xpeers/"
append link-root %xpeers/
do link-root/framework/anamonitor300.r
do link-root/framework/slim.r

;-- RebGUI stuff

#include %rebgui.r unless value? 'ctx-rebgui [do link-root/framework/libraries/rebgui.r]

;-- SLIM stuff
slim/open 'debug none ; [mark-my-words]
; mark-my-words/init

unit-size: 4
font-size: 12
tab-size: 120x55

display/min-size "CalcIT" compose/deep [
	label "Land"
	drop-list 60 data ["A" "B"] return
] 1024x768
do-events
halt

RebGUI 0.4.2 is up. Grab it the usual way with:

	do http://www.dobeash.com/get-rebgui.r


You may want to delete view-root/public/www.dobeash.com/RebGUI first 
as a number of old files are now redundant.

This build is the latest snapshot of the repository and includes:


 - %rebgui.r is now a single monolithic (72Kb single line) script 
 (individual source files are in SVN)
	- Cyphre's drop-list change
	- Anton's quit [not] when only one pane remains
	- clear-text and show-text fixes
	- led widget fix (failed when encap'ed)
	- language file for Italian added
	- %tour.r Opera icons replaced with Tango Desktop equivalents


Also note that the RebGUI home page has moved to http://www.dobeash.com/RebGUI/
and that all active issues / tickets can now be found (and updated) 
at http://trac.geekisp.com/rebgui/report/1

I tried:
REBOL Preprocessor 2.0.0
Copyright 2002 REBOL Technologies

Input file? rebgui-ctx.r
Output file? rebgui.r
***ERROR (widgets/button.r): Cannot load file: button.r
** Press enter to quit...

Yes, once you do an "SVN Checkout" the folders and files are displayed 
with a green tick. Editing a file causes it (and the folder it appears 
in) to be displayed with a red changed icon. Right clicking the root 
folder, RebGUI in my case, and selecting "SVN Commit" prompts for 
which changed scripts (and a comment) you wish to save back. Pretty 
straight forward once you've done it.

How is the svn related to get-rebgui?

 The SVN is for developers / experienced REBOLers ... it is used to 
 manage individual widget source files. %get-rebgui.r obtains a pre-built 
 distribution (including a merged %rebgui.r, %tour.r, images and demo 
 scripts). It is targeted at 'end users' who don't want to use SVN.

%tour.r is missing

 I want to add it *without* having to also add sample icon images 
 to the SVN. I'll probably just 'inline' the images so it's all in 
 one big file.


min-size: read this very carefully: http://www.dobeash.com/RebGUI/display.html#section-2.1.2


The Note says it all: "The min-size limit will only be enforced upon 
a window resize, and the size is inclusive of an OS specific number 
of border / title pixels. Also note that if any widgets are resizeable 
(#H and #W) and min-size has not been specified then RebGUI will 
assign a default value equal to the initial window size."

well, you can always state anything. Being a developer's tool does 
not tell anything how ppl are using Rebol to develop. I am not comfort 
with idea of installation, simple as that. I never use double-click 
to launch my scripts and never will do, untill we get one exe and 
components (file associations issue). And noone should explicitly 
tell, how do I use any tool.

The other trick is telling whether a specific user has View set up 
on a multiuser system. There are still some multiuser-unfriendly 
bugs in the REBOL/View installer, mostly for backwards compatibility 
with View 1.2 registry settings. At least the file handling has been 
made multiuser safe - we'll see if REBOL 3 solves the rest of the 
problems.

Hmm, I just logged on as "robert" and I see four buttons above that 
link titled:

	Edit this page
	Attach file
	Delete this version
	Delete page

What OS / Browser are you using?

performance. Once you are used to it, you optimize everything.. a 
single file for installation is good, and while we areat it, why 
not kill all this whitespaces? source is available anyway. (thinking 
loudwith Ashleys voice ;)