AltME groups: search

anyone know a way to prevent text-list from picking more than one 
item with ctrl?

I need some clairfication in reading the syntax/specs for Rebol2.x 
stuff.
I'm sure there is a pattern, but I havn't seen it yet.

Example: taken from rebol.net/wiki/VID:_Styles#Derived_styles_2

TEXT-LIST
   size: pair!
   rows: block!

   selected: block! ; this way set-face will not work. need to solve 
   this.
   action: block!
   background: tuple!
   background-draw: block!

how do I know when to assign a value to a [word] i.e. 

lo: [text-list size: 300x200]		;;does not work 
view layout lo

and when not to use the [word] such as 

lo: [text-list 300x200] 	;; works
view layout lo


Question 2. Could someone give a one line (short as possible) example 
of setting all the values for this text-list keyword using this format 
lo: [text-list ......]
view layout lo

thanks in advance.

The documentation you've pointed to seems related to R3, not R2.x. 
There's no header info in that page, so just guessing. 

You'll find REBOL 2.x view documentation here : http://rebol.com/docs.html

More precisely:
http://rebol.com/docs/view-guide.html

http://rebol.com/docs/easy-vid.html#section-14	(for TEXT-LIST examples)


About your question, here's a more complete example (not sure that 
all possible options are there, thought) :


lo: [text-list 300x200 yellow blue data ["one" "two" "three"] [print 
"action"]]
view layout lo

Thank you both.  Is it possible to create columns as well or is text-list 
a single column entity?

AFAICT, text-list is single column. Henrik has done some nice new 
components for VID, his LIST-VIEW style should fullfill your needs. 
Have a look at : http://www.hmkdesign.dk/rebol/page0/page0.html

Here's a quick link to what you're looking for : http://www.hmkdesign.dk/rebol/list-view/docs/list-view.html#section-3

thanks for the links.  I do have that list-view, I was trying to 
find a smaller way out.  It was missing one or two features I was 
wanting last I checked, and didn't feel like pouring over the source 
code.  about 100 pages.  My brain would take quite a few months to 
understand it.   Excellent software though.  I'll give it some more 
thought, and thanks again for the vid-notes link.  It looks very 
clean.

If you want a small solution, you can use the LIST style, but it's 
a bit more complex to work with. You can find some examples in the 
vid-usage.r script (look of some examples is horrible, but it will 
show you how to build custom multi-column lists).

well.... looking back through my coded examples... I actually have 
a good working list-box with over l000 rows with the columns correctly 
spaced.  However, its missing some necessary features, one of which 
is how do i attach the vertical scrollbar to the list box.   I tried 
the vid-usage.r script but perhaps I must have missed some key elements. 
 I'll try looking at that again.

data: make block! 16

loop 16 [repend/only data [random "012345789" random "abcdefghij"]]

visible: 5					; number of visible lines
window: (length? data) - visible	; sliding window size
cursor: 0

view layout [
	across
	space 0x0
	
	grid: list 200x100 [
		across
		txt 100
		txt 100
	] supply [	
		if row: pick data count + cursor [face/text: pick row index]
	]
	sc: scroller 16x100 [
		cursor: sc/data * window
		show grid
	]
	do [
		sc/step: 1 / window		; initializing scroller steps granularity
	]
]

I'm glad it helped you. It was a good opportunity for me to refresh 
my memory about the (powerful but under-documented) LIST style.

In case you're wondering about the block after SUPPLY, it's used 
internally by the LIST style to build an iterating function defining 
a local context where COUNT refers to the current row and INDEX to 
the current column. Each horizontally positionned face (purpose of 
the ACROSS keyword) defined in the LIST layout block, is counted 
as a column, so: txt 100 txt 100 => 2 columns.

It's the central point with Rebol, when a function is accepting a 
block as input, you can't  guess if it will be processed as pure 
rebol code, list of data, or as a dialect (mixed data and commands).
Data is code, Code is data. Never forget.

Having trouble changing the data in a drop-down list...

mylist/list-data: new_stuff 
show mylist

works the first time but not there after

you should clear the original block you supplied to the drop down 
list, and then append new items to it.  that should work.

insert clear head mylist/list-data new-data

I'm not sure how to bring up the list of command line switches

Has anyone written a to-do list manager?  There was one on IOS but 
I don't have the client for that anymore, and my recall is that it 
was fairly basic.

Yes, once only, I guess CALL would be ok, just need to install ImageMagic 
on Windows, test it, then install it on Linux server, test again, 
then add this package to the list of dependencies to maintain...cool!

view layout [text-list "this" "is" "a" "text" "list"]
myFile.txt contains "this" "is" "a" "text" "list"
how can I:
view layout [text-list read %myFile.txt]
? 
tia

so you can do this ... get the block first

data: to-block read %myfile.txt

and then compose on the block

view layout compose/only [ text-list (data) ]

Thanks Graham. 
view layout compose [text-list (data)] ; worked

view layout [text-list data parse read %myfile.txt  ""]

I see now what the problem is. Those REBOL types are hardcoded into 
view-request sources. 
But you can patch them away with

	remove find/only req-file/filter-list ["*.r" "*.reb" "*.rip"]

 remove skip find req-file/start-out/3 [fp: rty "Normal" "REBOL" "Text" 
 "Images"] 3

After that, request-file should come up without the REBOL types.

This is not obvious with VID, because you might build such a layout 
in a special setup, but in the VID Extension Kit, you have face constructs. 
A face construct is simply a style that accepts a particular dialect 
as input. The dialect is parsed into VID which then in turn generates 
an internal face tree. This means you can build styles that do something 
like:

view layout [
	paper [
		size a4
		dpi 300
		at 20x20 image bay.jpg
	]
]


The point is that every time you feed the paper new data, using SET-FACE, 
it's re-rendered from scratch using VID.


You can also build very complicated list views that dramatically 
change appearance and number of faces, every time you feed it new 
data.

This is the code I use for RebGUI:

get-fonts: make function! [
	"Obtain list of fonts on supported platforms."
	/cache file [file!] "Obtain fonts from file"
	/local s
] [
	all [cache exists? file] [insert clear fonts unique load file]
	if empty? fonts [
		either OS = 'Win [

   call/output {reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows 
   NT\CurrentVersion\Fonts"} s: copy ""
			s: skip parse/all s "^-^/" 4
			request-progress/title (length? s) / 3 [
				foreach [fn reg style] s [
					fn: trim first parse/all fn "("
					all [
						not find fonts fn

      not find ["Estrangelo Edessa" "Gautami" "Latha" "Mangal" "Mv Boli" 
      "Raavi" "Shruti" "Tunga"] fn
						not find fn " Bold"
						not find fn " Italic"
						not find fn " Black"
						not find fn "WST_"
						insert tail fonts fn
					]
					wait .01
					step
				]
			] "Loading fonts ..."
		] [
			call/output "fc-list" s: copy ""
			s: parse/all s ":^/"
			request-progress/title (length? s) / 2 [
				foreach [fn style] s [
					all [
						not find fonts fn

      (size-text make widgets/gradface [text: "A" font: make font [name: 
      fn size: 10]]) <>

      size-text make widgets/gradface [text: "A" font: make font [name: 
      fn size: 12 style: 'bold]]
						insert tail fonts fn
					]
					wait .01
					step
				]
			] "Loading fonts ..."
		]
	]
	sort fonts
]

system/schemes/system: make object! [
    name: 'system
    title: "System Port"
    spec: none
    info: none
    actor: make native! [[port!]]
    awake: make function! [[
        sport "System port (State block holds events)"
        ports "Port list (Copy of block passed to WAIT)"
        /local event port waked
    ][
        waked: sport/data
        loop 8 [
            if not event: take sport/state [break]
            port: event/port
            if wake-up port event [
                if not find waked port [append waked port]
            ]
        ]
        if not block? ports [return none]
        forall ports [
            if find waked first ports [return true]
        ]
        false
    ]]
    init: make function! [[port][
        port/data: copy []
    ]]
]

Need a little assitance with a choice button in layout. How might 
it be possible to assign a list of tables from db query to a choice 
button. The query is no problem.  But at the moment i see no way 
to use the result block in the layout definition of the choice button

I think that will work, yes, but I would probably do something like:

panel-list: ["Panel 1" panel1 "Panel 2" panel2 "Panel 3" panel3]


choice 150x30 silver data (extract panel-list 2) [panels/pane: select 
panel-list value show panels]

like : choice 150x30 silver data (extract panel-list 2) [panels/pane: 
'get select panel-list value show panels]

Henrik, i need to bother you again. Sorry for that. I use your List-View 
in one of my panes. I am handling the resize event  globally via 
insert-event-func. There i tried to handle the resize of the listview 
also, but  it does not do anything. Everything is resized,  but not 
the List-View.. The next thing i tried was a resize via a button 
directly in the same pane. This works as long the windows hasn't 
been resized before. Do you have any any idea where this might result 
from? In th global function the event is returned after resizing 
all panels.

I don't remember how it works for list-view, but don't you have to 
specify the new size, when using the resize function?

Here's the agg style with get-face doing what I want (returning the 
field name with everything else in a list, suitable for dropping 
into a key/value list):

	agg: panel with [
		multi: make multi [
			text: func [face blk][]
			size: func [face blk][]
			decimal: func [face blk][]
		]
		append init [
			context [
				p: pane  f: facets
				while [all [not tail? p  not tail? f]] [
					either 'label = p/1/style [
						p/1/text: f/1
					] [
						set-face p/1 f/1
					]
					p: next p  f: next f
				]
			]
		]
		access/get-face*: func [face /local p label x] [
			p: face/pane
			label: to-word p/1/text  

			p: next p
			x: copy []
			while [not tail? p] [append x get-face p/1  p: next p]

			return reduce [label x]
		]
	]

next step is implementation of the gross-level polygon proximity 
test (a fast algorythm ignoring polygons which are too far away). 
 


this allows many polygons to live in the same scene without requiring 
collision tests for them.


I'll probably use a double linked-list for X and Y sorting of polygons. 
 this allows us to start at our position directly and spread the 
search on each side of the list (in both directions).

game engines use this simple system.


-create very transparent images with a gaussian fall off.  actually 
give the prefered shape to your image... so if you want a triangle-like 
flame, generate a smooth triangle with alpha/color falloff.

-create a block which will store a list of pairs, each one holds 
the position of a single "particle"

then go over the list, picking up count amount of particles at at 
time with life number of interations.
the life iteration is used to calculate age: life / life-counter

all is left, is to add/remove new pairs to your list, basically, 
the last iteration knocks off old particles from the list and inserts 
new ones at your fire origin.

if you want smoke, just add the "dying" particles to a second list, 
using the same process, to animate them but with a bigger/softer 
image.  

the dying fire becomes the birth of the smoke.

and ...


keys: list-reg/HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"
    probe keys


    keys: get-reg/HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts" 
    "URW Palladio L Italic (TrueType)"
    probe keys


    keys: exists-reg?/HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts\URW 
    Palladio L Italic (TrueType)" 
    probe keys

produces this

[]
URWPA32_0.TTF
false

get-fonts: make function! [
	"Obtain list of fonts on supported platforms."
	/local s fonts
] [
	fonts: copy []
	either 3 = fourth system/version [

  call/output {reg query "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows 
  NT\CurrentVersion\Fonts"} s: copy ""
		s: skip parse/all s "^-^/" 4
		foreach [fn reg style] s [
			fn: trim first parse/all fn "("
			all [
				not find fonts fn

    not find ["Estrangelo Edessa" "Gautami" "Latha" "Mangal" "Mv Boli" 
    "Raavi" "Shruti" "Tunga"] fn
				not find fn " Bold"
				not find fn " Italic"
				not find fn " Black"
				not find fn "WST_"
				insert tail fonts fn
			]
		]
	] [
		call/output "fc-list" s: copy ""
		s: parse/all s ":^/"
		foreach [fn style] s [
			all [
				not find fonts fn

    (size-text make face [text: "A" font: make font [name: fn size: 10]]) 
    <>

    size-text make face [text: "A" font: make font [name: fn size: 12 
    style: 'bold]]
				insert tail fonts fn
			]
		]
	]
	sort fonts
]

The List-View style code kept seg faulting. Rolling back to 2.7.6 
fixed the problem. I don't have this trouble with Windows.

Sometimes, not sure with dropdown data, you need to update the line-list 
facet as well. A few styles force you to work with their internals 
this way, when doing more than simple UIs.

I'm having trouble changing the scroller size (i.e. width) for the 
text-list style. Changing the font size was easy enough. I'm trying 
to make it bigger to accommdate fat fingers on a touch screen display. 
Has anyone done this before? Thanks.

print mold svv/vid-styles/text-list/init

stylize/master [
	fat-list: text-list with [
		use [blk][
			init: copy init
			blk: copy select init [pane: layout/size]
			replace/all blk 16x0 32x0
			change/only find/tail init [pane: layout/size] blk
		]
	]
]


view center-face layout [fat-list "Is the scroller" "fat enough?"]

Yes, but yours is more elegant than the crude patch job I just did 
to the actual text-list style. :)

It depends on if you need the original text-list style unmodified 
alongside your patched version. If you intend merging in other code, 
then it's better to derive a new style. If not, then it doesn't matter.

I decided to leave the original style alone and use your fat-list 
definition for the reasons you stated. Thanks.

No it doesn't change the result.
To test it give a width for the text:

t: join head insert/dup copy "" " " 500 "test"
view layout [text 100x400 t white blue as-is]

test
 is still on the second line.

I tried as-is, line-list: none, I need to use wrap?: yes. Otherwise 
I have to my own wrap function which I don't have time to do.

view layout [f: text-list data ["aaa" "bbb" "aaa" "ccc"] [probe f/picked]]

When I click on "aaa" both lines are selected. Do I missing something 
or is it a bug in text-list?
When use CTRL click, no chance to get both "aaa" in f/picked

text-list uses the text itself as the key, so each string has to 
be different. if you can't use a better alternative for some reason, 
you could change the strings to something like "1) aaa" "2) bbb" 
"3) aaa" ... etc.

I see. Thank you.

As I see there is no chance to make face/data and face/texts for 
text-list, choice styles. When I change like face/data: copy ["a" 
"b" "c"] then face/texts is also syncronized. and vice-versa.

The only way is to use the index? of selected item on a block which 
holds item-data. Is that right?

As I see there is no chance to make face/data and face/texts for 
text-list, choice styles

--> As I see there is no chance to make face/data and face/texts 
>different< for text-list, choice styles.

Duke: You can use dump-face function to get list of styles in your 
layout.

>> win: layout [bt: button 30x20 "Hello" lb: label "Test"]
>> dump-face win
Style: none Offset: 50x50 Size: 72x87 Text: none
     Style: button Offset: 20x20 Size: 30x20 Text: Hello
     Style: label Offset: 20x48 Size: 32x19 Text: Test

It helps to understand, what LAYOUT is doing: As you may know, VID 
is a dialect, which is a parsed collection of words, numbers, strings, 
etc. in a specific format, essentially a sub-domain language, within 
REBOL. The job of LAYOUT is to parse the dialect block and convert 
that into a face tree (a face is just an object, try typing FACE 
in the console). The face tree can then be fed to the VIEW function, 
so the layout can be displayed, so:

VID -> layout -> view -> window displays with content


You can also create a face tree manually, but that's far more laborious, 
which is why VID is there.


When LAYOUT creates a face, it does so in accordance with a style 
from Izkata's shown style list, such as IMAGE or FIELD. A style is 
essentially a prototype face.

Some quines were posted to the mailing list

Nothing relevant in my copy of the original REBOL world, nor its 
short-lived sucessor REBOL2,

Nothing obvious on the Mailing list archive -- that goes back to 
mid-2000 which, I think, predates Reichart's involvement with REBOL.

Is there a convenient way to list they keys of a map?

Not yet. It's on the todo list.

If anyone is interested, there is a task that needs to be done:


We want to list all functions in R3 vs. all functions in R2, so you 
can have a direct reference to compare each function between the 
two. This will help in listing those subtle changes that R3 has in 
functions and there will be many more subtle changes when unicode 
releases are done. This is only meant to be on a per-function basis 
and not for higher level ways to do things

I suggested thereby that we output the internal help of all functions 
in R2 and R3 in a two-column table with R2 to the left and R3 to 
the right. Similarly for all mezzanines, we would output the source 
code to each function in a separate two-column table of the same 
format.
When that is done, it needs to be formatted for DocBase.


If anyone is interested in doing that, just signal it in this group.

Also asked this on the mailing list.

In webpage http://www.rebol.net/wiki/VID:_Commands there is an example 
of TEXT-LIST in R3 as follows:

view [
    text-list [
        ["Header col1" "Header col2"]
        ["row1 col1"   "row1 col2"   "value-of row1"]
        ["row2 col1"   "row2 col2"   "value-of row2"]
        ["row3 col1"   "row3 col2"   "value-of row3"]
    ]
    selected [1 3]
]

In the next snippet out is a block! and I want it's contents to be 
displayed as the rows of the text-list:

view/options [
  text-list [
  	["header"]
  	[out]
  ] options [size: 300x200]
] [title: "my example"]

Also I couldn't find the specific options for text-list

Arie;  Did you get "out" showing up? 
out: ["1" "2" "3"] 

view [text-list ["col1" "col2" "col3"] [out]]]    will show   out 
none none   in the list, you'll need to compose the out

I wouldn't consider this a real solution, but...

view/options compose/deep [
  text-list [
  	["header"]
  	(out)
  ] options [size: 300x200]
] [title: "my example"]

btiffin: yes, but I don't know a way yet to achieve this within the 
r3 text-list specs as known today, hence the trich Gregg showed which 
is a kind of meta-reduce :-)

note that text-list will be replaced in upcoming VID prototypes. 
it's a stopgap solution.

Somehow, I don't think porting to .NET and the DLR will be high on 
RT's priority list.

>> ? evoke
USAGE:
        EVOKE chant

DESCRIPTION:
        Special guru meditations. (Not for beginners.)
        EVOKE is a native value.

ARGUMENTS:

        chant -- Single or block of words ('? to list) (word! block!)

:-)

From the nom list I'd like to see?   Doc, Paul, you, Gregg, Sunanda; 
Oldes; BrianH, oh so many that deserve a great big banner of appreciation. 
 Richard; Reichart; (a ton of the Qtask staffers) etc etc etc.

Speaking of Graphics - Henrik weren't you the one that inquired one 
time about my text-list modification that had the colored text lists?

were you the one that did that text list? that would be about a year 
before I started working on LIST-VIEW.

I personally want to see LIST-VIEW capabilities in R3's list view 
what ever that will be, but it will probably be split up in simple/advanced 
for speed vs. bloat factor.

You if the item in the data was the word red then it would show up 
in the text list on just that line as red same with blue and any 
other color they would show up as their own specified color.

have you used LIST-VIEW?

thanks Brian, throw yourself on the list.

We see much more activity every time something new happens in the 
community. I don't post in the LIST-VIEW group anymore, but does 
it mean that people stopped using it? I didn't stop.

The design process for LIST-VIEW was very short. It took a few days 
to build the first version. After that it was more an issue of getting 
features put on top of other features and spending time on bug fixing. 
There was very little actual design after the first version.

R3 could hook into the display list feature of OpenGL for compositing

remove that means the passed argument is delete from the list and 
nothing else

remove a [b] == remove process done [b] have been removed from the 
list a. Have a nice day shadwolf  you know you really rock  !!!  
probe a  == the list a contains [[a][c]] have a good day shadwolf 
you still rock you know i love you .... That's would be  the best 
^^

i use as "index" for my seachies into the list the offset position 
of each char displayed

so my idea to speed the search process instead of having to use foreach 
loops would be to convert my list into an hash table like data structure 
using the postions as index

Face it, a language with no community is no language

 I wouldn't judge REBOL's adoption rate purely by the number of people 
 who regularly post in this world. I receive a lot of email from folks 
 using stuff I've written in their day-to-day jobs and they don't 
 post here or to the mail list ... I've even spoken to a few startups 
 who are going into business primarily on the strength of REBOL and 
 "time to market". Whether a "killer app" will ever be REBOL-based 
 is the big question ...

He posted this Monday, and am not sure it would hurt to publish it:

Delay in upload caused by:


1. Resize needed some more work.  That has been done, and it is much 
better.  We will probably see a few more bugs, and may still want 
to make some general adjustments.  The main idea of resize has changed 
from earlier VID releases. I will write a DocBase page on it to explain 
how it works and why I changed it. 


2. A few styles broke in recent changes. These need to be fixed. 
Should only take a few hours.


3. A few weeks ago, when making larger changes, I removed some of 
the compound styles. I want to add back at least one or two, probably 
LIST for text lists at minimum.

resizing is automatic, but buggy. there is a list of known bugs.

s-bars, s-list - do those files contain multiple styles?

Rebol[]

fibonacci: func [{Makes a list of fibonacci numbers and stores them
	to a block called fibonacci-block.} loops [integer!] {Number of 
	iterations to run}
	] [
	fibonacci-block: [0.0 1.0]
	count: 0
	loop loops [
		addend-1: index? back back tail fibonacci-block
		addend-2: index? back tail fibonacci-block
		new: fibonacci-block/(addend-1) + fibonacci-block/(addend-2)
		append fibonacci-block new
		count: count + 1
		print count
		print new
		]
	Print fibonacci-block
	write %fibonacci.txt fibonacci-block
	unset fibonacci-block
	halt
	]
Print "Type fibonacci [# of loops] to make fibonacci-block."
halt

Code example:

do %load-gui.r

files: read %*.r

view/options [
	tight [
		text-list files do [set-face ca read-string pick files value]
		scroller
	]
	ca: code-area
][
	title: "REBOL Scripts"
	columns: 0
]

Produces

http://rebol.hmkdesign.dk/files/r3/gui/036.png

Well keep working. I'll need a list-view : )

I'm not sure I want to port LIST-VIEW. I think it's better to start 
from scratch.

Henrik - I reread you list of things which are being worked on. Just 
wanted to ask, if so called "skinning" is not overrated? I still 
can see mainly aplication development aproach with VID 3.4 so far. 
Because - when you think more about browser aproach - what is there 
to skin? Each page usually might mean totally different graphics. 
Buttons, fields, etc. -  the forms, are just little subset of what 
is usually a "website". So - the button will always be the button, 
field will always be just the field. What users might be more interested 
in, is animations, transitions, and that can't be covered by just 
changing the skin. Dunno - tried WindowBlinds (http://www.stardock.com
) once in the past, and imo skinning is overrated - still the same 
thing expressed many times, while web = different aproach each time 
....

If we don't want to start with own windowing system (which might 
be important for browser plug-in where using pop-up windows could 
get problematic because of blockers), then we should start with some 
kind of split window, and look for inspiration to various nowadays 
apps. Once you divide your app window into such sections (it imo 
still can be done with adapted panel style), you can then place icon-bar/menu 
at the top, icon-list or tree on the left, and the form on the right 
side. What some REBOLlers I talk to are also expecting, are styles 
like tree-view, tabs, grid, out of the box ...

I think that heavy alpha TV like interfaces might need completly 
separate skin? I remember how Carl wanted his list style for 1.3 
project (the style was not released, it is in IOS world) to support 
borderless list styles. When you go alpha, it is similar - borders 
might not work  easily ...

SCROLLER now has a tiny bit of intelligence: It will scroll the first 
face that responds to ON-SCROLL if one precedes it earlier in the 
layout code.

So:

view [text-list-box [1 2 3 4 5 6 7 8] scroller]


will automatically attach scroller to the text-list-box and scroll 
it.

view [text-list-box [1 2 3 4 5 6 7 8]  text-list-box [1 2 3 4 5 6 
7 8] scroller]

will only scroll the last text-list-box.

Henrik - is there general 'list style, so that e.g. text-list is 
based upon that?