AltME groups: search

Giuseppe, those are called properties. The getter/setter functions 
you often find in GUIs are basically the same thing, but properties 
hide that in regular assignment syntax. We don't need getter properties 
in REBOL-like languages because we don't use parentheses to call 
functions, but setter functions appearing to be assignment statements 
might appeal to some.


I've had a lot of experience with properties in languages like Delphi; 
most of the popular languages that currently have property support, 
either in syntax or as a convention, are derived from Delphi. It 
makes code a little easier to write, and a lot harder to debug. The 
main advantage to implementing them in Red or R3 would be to make 
it easier to interoperate with .NET or COM objects.


Automatic delegation is something else. With automatic delegation, 
you automatically forward a method call from one object to another, 
just by declaring it as such. That doesn't really work in REBOL-style 
direct-bound functions because we don't have an implicit self parameter 
(we have self, but it's not a parameter). Red would need to have 
a completely different function binding model for that kind of thing 
to work; which it would likely have anyways, due to it being compiled 
rather than interpreted.

It does abstract everything that can be abstracted, currently, IIRC, 
only FPU options (system/fpu/* properties) are platform-specific.

Yes, I can in this case: "unreasonable thinking" here is the fact 
that the "mathematical model" - in this case the numbering of positions 
in series differs substantially from the properties of the object 
it is modelling - in this case there is a difference between the 
"no-gap in the series" versus "gap in the mathematical model".

 in this case the numbering of positions in series differs substantially 
 from the properties of the object it is modelling


Is this again the "inbetween position" vs values counting intepretation 
difference?

If you realize that indices are one degree vectors.   A lot of this 
discussion becomes moot.   vectors of length 0 are considered impossible 
when considering only natural numbers (due to 0 divide).  This is 
why I consider R2's handling of indices proper.   


As such, any series "position" is not AT a value it is LOOKING AT 
a value (oriented in positive direction, starting at a point in space 
which is "0").   like extending your arm to grasp the nth thing in 
front of you.  


Tail are 0 length vectors (thus mathematically imposible), when we 
are beyond  the last item edge we are at the edge of space.   you 
cannot "take" the tail item, there is nothin in front of you, just 
as you cannot "take" the 0th item, there is no such thing, 0 is the 
origin of the vector).


when we consider series indices to be vectors, we see the natural 
relationship which Ladislav pointed with SKIP and other methods.


with vectors, things like COPY/PART make sense in the negative direction, 
just as well as in the positive direction.



In R3, this was changed to indices being OVER a value , with the 
first item requiring you to look down and then away for other values. 
 The issue is that index 0 is looking backwards... that doesn' map 
to any good reasoning.  In fact it creates many weird inconsitencies 
in the model, when you try to describe it.


R3's series changes seem like a kludge work-around to map non-vectorial 
infinite integer space to a bounded vectorial space. sacrificing 
model integrity in the process (while trying to ease its mathematical 
properties).  R3's series *may* be "easier to count in a loop"  but 
the values being used make no sense.   counting backwards requires 
us to manipulate the indice for it to "make sense", whereas before, 
counting backwards was the same as counting forward.  we where just 
LOOKING in the opposite direction (the vector's orientation is inversed).

As such R3's model is actually not only _not_ "weirdly inconsistent", 
but actually more consistent than R2's model, when having to use 
in-language properties to describe it.

WHAT is to find out what stuff is attached under an object. I use 
(d) it a lot with VID, finding out which field was filled with what 
value to see how I could go about dynamically change the properties 
like captions and values and colors.

...and by "reinventing the wheel" I meant just thinking whether PARSE 
has the properties desirable for Rebol, since that has already been 
documented sufficiently as far as I am concerned

Aha, reading the above discussion, my apologies must go to Pekr since 
it was him pointing to the documentation summarizing the properties.

May be that the character sets offerd for selection under the properties 
tab of the Win console don't offer this display choice but I don't 
know how to install others. Currently I only have True Type Lucida 
Console, True type Consolas and Raster... : (

Rebol3 is dead, long live to Rebol3Bazaar


I've been quiet for a long while, and this blog is not easy for me 
to write.

I'm sitting here with a glass of 2013 Ferrarelle mineral water of 
the glass bottle... hoping to be inspired on how to write this...
No, bad introduction...

You know that Rebol is a fantastic programming language, but its 
development was discontinued and bad supported. A lot of people when 
encounter Rebol falls in love for its simplicity, a blend of theory, 
experimentation, and invention, the language embodies elegant and 
wonderful concepts and properties. It was and is the most productive 
language I've ever used. I hope your experience has been similar.


Unfortunately a lot of bad events are leading Rebol to a no through 
road:

- no direction of the new Rebol3
- no a central site open for discussion
- no updates on Rebol 3 source (well, just one every month)
- to many sites about Rebol and with no updates from years


These and other reasons forced me to create http://rebol.informe.com/portal.html
a public forum, with a public wiki and a blog, where everybody can 
contribute. The result is just 17 users, this means that Rebol is 
dying; the cathedral way of Rebol 3  development is not working.

So I'm forced by my love for Rebol to create a new GitHub repository: 
Rebol 3 Bazaar, it's a Rebol 3 source, with graphic working (VID, 
but just on windows at the moment); I promise you:


- pull requests and issues discussed and merged in 24 hours (or max 
a week)
- open to add people to its organiziation
- always update!
- link:  https://github.com/angerangel/r3bazaar


If you like to contribute write me, use GitHub or Rebol portal; you 
don't need to be a programmer, think about a new logo, contribute 
the wiki.

If you know REBOLers who might be interested in this discussion, 
please let them know about this blog posting. I look forward to hearing 
from you,
-Max

I have a script that runs another script (via do) but when I launch 
it from an icon or through startup, the other script asks for permission 
to open a port. I've tried looking for some properties to change 
in the icon and setting secure to allow (which brings up its own 
requester). How do I do this?

Thanks sqlab. I think that's my problem in setting that. The icon 
properties don't seem to let me do that.

There are some tests in the core-tests suite (28 in total), but as 
you can see, there are many properties that aren't tested yet.

Go into properties and select recording options (I think.) It's such 
a damn confusing user interface...!

click OK.  Double click on the volume icon in the task bar -> now 
properties

(Options/properties)

with liquid being lazy, its processing the least so all it neads 
to refresh on any element change is that AGG line block and then 
it just reassembles the draw list.  updating both lists when it needs 
to (not all changes will actually rebuild the 2nd draw block look, 
since it does not share all properties )

the latest version saves all the birth points and their life span, 
but doesn't save out the "looks" properties yet.


about the smoke color slider... yes... I forgot to change it to light 
color.

Hm...  Top Ten...  Some of these undoubtedly will be held for the 
new architecture, but here's my top requests...


1) Group level settings for message notification (activate window, 
play sound)
2) Group name/description search

3) Opt out of public groups so that the group remains public but 
you don't see it.

4) Alphabetical listing of users in group properties (Who's in the 
group, who's not)

5) Navigaion (Forward, Backword) buttons would be really helpful 
particularly when browsing checklists OR clicking on the checklist 
button replaces the group lists with checklists.

6)  When you right click a message then a popup shows telling you 
the text has been copied. This is nice but annoying because you can't 
hit Enter and watch it disappear. I'd personally really prefer a 
context menu but if it just dissappeared after 3 seconds or so that 
would be good too.

REBOL /View (or AltMe)  just crashed on me..when I do the following 
on WinXP.

1. My Computer->Properties
2. Advanced tab->Performance

3. Change from "Let Windows choose what's best for my computer" to 
"Adjust for best performance'

4. Apply..... WinXP 'pops' up a dialog saying /View has crashed and 
ask for information to be sent over to MS.

Can someone try the above and see if it duplicates?

NOTE: I have AltMe running when I did that.

What I really want to see is full exposure of text properties, rigt 
click of the aA button, but a simple "font-size" switch will do.

Windows :: Right click, select properties.

I looked up an old post (2007) talking about how to start Altme Worlds 
on windows start-up. Brock had the answer but I could never get it 
to work. Three years later, I decided to try again. Here are some 
lessons I learned along the way:

Precautions:

You may want to back up the altme folder just in case something goes 
awry. You will also need to know where the files are located.

You may also want to create another temporary worldmaster user and 
note the password. If you're like me, it has been a long time since 
I had to type in the user password.


1. Before you turn off your worlds, go to http://www.altme.com/check.html
and check your world(s). Note the port number and write it down.

2. Create a shortcut icon on your desktop to altme if you don't already 
have one. Do this by right clicking on altme and select "Send to/Desktop."

2. Right mouse click your "Start" menu (I only did this in XP so 
adjust for any changes you might have in your OS) and choose "Explore." 
An "explorer" window will open.

3. Go to the "Start Menu" folder in the the explorer folder tree 
in the left column. In the right column open up "programs" then open 
up "Startup."

4. Drag the altme shortcut icon from the desktop to the startup folder.

5. If you have more than one world, right-click on the just added 
altme shortcut icon and rename it to something like altme-worldname.

6. Show the properties of the just added altme icon by right-clicking 
and choosing properties.

7. There, in the "Target" field, you will add on to what should already 
be there. It should have something like: "C:\Program Files\altme\altme.exe", 
telling the OS where to find altme and the name of the actual program. 
As you may know, the quotes are there because the "Program Files" 
folder has a space in it. Leave it as is and add:

-s "yourworldname" - p the-port-number. E.g., "C:\Program Files\altme\altme.exe" 
-s "myworld" -p 5402. Do not close the properties window but continue 
to the next step.

8. Below the "Target" field you will see the "Start in" field. There, 
enter where altme and its server files exist. The top level folder 
is enough. E.g., "C:\Program Files\altme\" 

9. Apply the changes to the properties and try it out by making sure 
the world is not running and then clicking on the altme icon in the 
Startup folder. This saves you from having to reboot if a mistake 
was made. You should see the familiar altme server window pop up.

10. You need to also check by logging into the world through the 
client. If you can and the data is all there. Great. The only thing 
left is to reboot and make sure it loads by itself.

11. Repeat for all the worlds you have. You'll end up with n altme 
icons each with a different name. 

Things that went wrong:
Before the server could be launched properly via the icon

1. Getting the wrong syntax in the properties/Target. - I thought 
everything had to be enclosed in a single quote string but it doesn't.
After the server was launched

1. Couldn't connect to the altme world - Seem to be related to the 
port #'s I was using. I went back and launched the worlds the manual 
way and checked the ports on the altme website.

2. Could connect but no users. - This had to do with "Start in" info 
or lack thereof. Altme was looking for the data in the Startup folder 
as opposed to my regular altme folder. Your actual data should be 
fine and of course you made a backup, right?

3. Some data (posts) got mixed up - Who knows on that one. I made 
so many attempts, I may have confused something.

4. My user profile was gone or had a different name. - Again, my 
guess is that this was due to the "Start in" info. Worst case, try 
the default "Master" "pass" user. I ended up using another known 
user (hence, my advice to create a temp worldmaster user), then I 
renamed the user I knew was me to me. Weird but it happened in a 
couple of my worlds but only to my profile.

5. I made a copy of the actual altme.exe and named it altme2.exe 
thinking that perhaps this was the problem. The target was then changed 
to reflect it. Don't do this, it  is not necessary and may freak 
you out.


Now I have 4 worlds up and automatically running when I need to reboot 
the server. Yea.

Yup, something like that. Accessors were introduced in Self, then 
ported to Delphi (as properties), then from there to ActiveX, Java 
(as a coding convention), C# (and the rest of .NET), and then many 
other modern languages and platforms (most of the major ones).

Re the new SWITCH proposal. ( Mezz/switch1.r). It fails in the following 
cases (due to FIND datatype searching properties):

switch-test: func [x] [
	switch :x [
		#[datatype! integer!] ["The first variant"]

  #[datatype! decimal!] #[datatype! block!] ["The second variant"]
	]
]

switch-test block!
switch-test decimal!

we can conclude, that there is *no amount* expressible in dollars 
and cents that has got the properties you want it to have

-> Properties -> Advanced -> set to every 10 minutes..

f: read/binary %15.jpg

get-len: [header: skip  (len: to integer! as-binary cp/part header 
2) ]
skip-len: [:header (header: skip header len) :header]
parse f [
        #{FFD8}   ; jpeg Header
        [
                #{FFE0}                         ;JFIF header

                        get-len                 ;get length of a header (2 octets)

                         #{4A46494600}          ;yeah it's a JFIF (confirmation)
                        skip-len
                        some [
                                #{FF}

                                        #{C0}           ;good ! i found the length properties

                                        (print ["height" to integer! as-binary cp/part at header 6 2])

                                        (print ["width" to integer! as-binary cp/part at header 8 2])
                                        break

                                | #{FF}                 ;don't know this header
                                        skip    
                                        get-len 
                                        skip-len
                                | 

                                        [end  skip]     ;error format
                        ]
                        
                        
                | #{FFE1}                       ;EXIF header

                        get-len                 ;get length of a header
                                                ;... to do
                        [end skip]
        ]
        to end
]

REBOL []

parse-async: func [
        file rules
        /local port buffer offset getf seek meta & && result
][
        port: open/seek/binary  file
        buffer: clear #{}
        offset: 1
        getf: func [len][
                offset: offset - length? buffer
                clear buffer 
                append buffer copy/part at port offset len 
                offset: offset + len 
        ]
        seek: [(offset: offset + 1)]
        ..: func [blk] [change/part & compose/deep blk && ]
        parse rules meta: [
                some [

                        &: binary! &&: (.. [buffer: (to-paren reduce ['getf length? &/1]) 
                        (&/1)]) :& 3 skip 
                        | &: 'skip &&: (.. [seek]) :& skip
                        | &: 'get word! integer! &&:

                                (.. [buffer: (to-paren compose/deep [getf (&/3) set [(&/2)] to integer! 
                                as-binary cp buffer]) to end]) :& 4 skip

                        | &: string! &&: (.. [(as-binary &/1)]) :& 
                        | 'end 'skip 
                        | into meta
                        | skip
                ]
        ]
        result: parse/all buffer rules
        close port
        result
 ]
 
if parse-async %15.jpg [
        #{FFD8}   ; jpeg Header
        [
                 #{FFE0}                        ;JFIF header

                        get len 2               ;get data length  for the current header 
                        (2 bytes)

                         "JFIF"                 ;yeah it's a JFIF (confirmation)

                        (len: len - 6) len skip ;skip data (len) times
                        some [

                                 #{FFC0}        ;good ! i found the length properties

                                        2 skip  ; skip length of this header

                                        skip    ; filler ??? always = #{08}
                                        get height 2
                                        get width 2
                                        break   ; finished

                                | #{FF} skip    ;skip this header
                                        get len 2 
                                        (len: len - 2) len skip
                                | 

                                        [end skip]     ;error format
                        ]

                | #{FFE1}                       ;EXIF header

                        get len 2               ;get length of a header
                                                ;... to do
                        [end skip]
        ]
        to end
][
   ?? height
   ?? width
]        
halt

so currently we have 2 distinct objects with same shared properties

seems there is more indirect links between an object and his properties

AFAIK, 'options is used only by window level face. Others are used 
by View as 'face is the View base object.

svv/vid-face is the VID default face, with more properties that you 
can used more safely.

Is there a "proper" way to set font properties for a single element, 
such as 'text after the layout is created?

I'm trying:
view layout [a: text "12345" b: text "12345"]


and set the font size for a: a/font/size: 14 (b is 12 at this point)

then I unview it and:
view layout [a: text "12345" b: text "12345"]
once more. Now b has font size 14 as well.

They seem to share the same font object....

Maybe you use custom faces not based on 'VID-face but on 'face object, 
so there is some "properties" missing in your faces.


This code is from the global event handler and handle field/area 
loose of focus :

	 probe system/view/screen-face/feel/event-funcs

That doesn't matter to them because of other assessments of elegance. 
 I just feel that my own aesthetics of what is elegant or inelegant 
are being redefined by the likes of Gmail.  I sort of don't care 
how it works when I decide to like t, I use it and notice its nice 
properties.  That gets me to the next question when I assess a new 
development platform, I ask: "how can I make something as good as 
that using your tool?"

It's been many years since I've used an IDE, but I recall selecting 
widgets and placing them on a screen, setting the Z order, and various 
properties for certain events.  Isn't VID just a RAD tool for doing 
this in a dialect ...

the particle engine is done, I'm now building a view interface to 
control the various properties like wind/turbulence.   you can even 
ignite your own fires & smoke with a click of the mouse.  

won't be long, I'll put it on rebol.org.

Journal of a 'Newbie' by SteveT
-------------------------------------------

Hi all, second week of using Rebol. had to travel to London this 
week so you guy's have had less 'Noise' from me ;-/


Had some good help off Anton/Henrik with regard to trapping key-presses. 
I'm hoping that some of the properties (refinements) missing from 
R2 will be in R3 - things like forcing case..


I'm getting to grips with 'PARSE'  will be great if the proposed 
lecture comes off.


Still struggling with 'BIND' but  I think I've learned enough about 
PARSE, BIND, CONTEXT & DIALECTS, to start using some of these facilities 
in some apps.  Biggest lesson so far this week has been 'Don't use 
it just because it's there!'  Stepping back from some of the things 
I've tried have lead me to simplifying my app rather than achieving 
a complicated solution!

Happy trails...
SteveT

You messed up by using decimal. Integer division has different properties 
than decimal.

It is very hard to find the best terminology to describe the properties 
(like "evaluation"), exactly because they differ from the common 
cases in other languages.

Wow, sounds cool. By the way, I was just looking at Minix3 with it's 
micro-kernel, and I wondered what kind of kernel Syllable has. I 
found this Syllable FAQ:
What kind of kernel design does Syllable use?

As Syllable is a fork of the AtheOS operating system, the author 
of AtheOS (Kurt Skauen) said "I often ask myself that question too. 
The kernel is very modular and it has a well-defined interface between 
the kernel and its device drivers and file systems. Given that each 
component communicates through a thin, well-defined interface and 
each component does not know much about the others, it resembles 
a micro-kernel. I am not sure if this is the right term though, since 
all kernel components live in kernel-space and are not protected 
from each other, and these are all properties of a monolitic kernel. 
I am a bit confused :)"

IIRC depending on the desktop manager you use, you can open icons 
with a shell automatically.  and can ask the manager to hide the 
shell until the app bums out.  look into the icon's properties... 
This might also only be an option for .r file associated icons themselves 
(not rebol, but for script with an icon).

To get .r files to start in REBOL, just rightclick on one, go to 
Properties, then to Open With, add REBOL/View and make that the default

Not Rebol callbacks. A DLL built using C is injected using LD_PRELOAD 
when running any executable. The executable I'm interested in is 
Rebol, of course. This injected code intercepts calls to XCreateSimpleWindow 
(which creates the X Windows window), and adds some properties to 
it, including one which stores the process id of the application 
opening the window. This means that each X window can be ensured 
to have the process id of the application that opened it (which is 
otherwise not mandated by X). So I could do that to any program and 
it would ensure that there is a way to get the process id. I'm doing 
it to Rebol, and this means it is now possible for another DLL function 
(called from Rebol) to scan all the windows opened on the X display 
and see which one has the Rebol process id. All you need is the process 
id, and this is easy to do with a very small DLL function call.

Bolek: REBOL is not going to start a terminal program for you. However, 
if you have a icon, you can usually open the icon properties and 
tell the "desktop" (XFCE in your case) to start the program inside 
a terminal (ie. it will start a terminal and then the program inside 
it).

FYI.. here's what the latest Flash player is doing with grads.. 

Enhanced stroke properties

Select from a variety of cap and join 
types. Apply a gradient to a stroke as well as a fill. Render stroke 
intersections better with stroke hinting.
Advanced gradient control

Tighter 
control over gradients such as changing the focal point of a radial 
gradient and selecting from different overflow modes. 

CSS3 is on the way -- but very little supports it.  Firefox has some 
CSS3 goodies supported.

More compatibility info than you might ned here:
http://www.corecss.com/properties/full-chart.php

inspecting the properties using Acrobat Reader, it says it's still 
A4 size.

Aha !  Tracked it down. In my frame I had a BASE tag. This caused 
the javascript error:

Error: document.getElementById("navList") has no properties

Source File: javascript:alert('width: ' + document.getElementById('navList').offsetWidth);

<html>
<head>

	<base target="_top" /> 

</head>
<body>

<ul id="navList" >
	<li>Hello</li>
</ul>


<a href="javascript:alert('width: ' + document.getElementById('navList').offsetWidth);">navList 
width</a>

</body>
</html>

Would you write 20.000 similar web pages for a web store, or would 
you write one template and store the properties of the goods in a 
database, for example?

New editor that support REBOL  colored syntax file. This sofware 
is SCITE 1.66 for linux and windows by default REBOL support is not 
activated. edit /usr/share/scite/ScitEGlobal.properties file ( MenuBar 
Options >  Open Global options File) search the line "#import rebol.porperties" 
and remove "#". Save changes (SCITE must be launched from a root 
terminal.) then edit /usr/src/rebol.properties file. Go to the last 
line of this file and set the proper path to your predered rebol 
VM version in the  command.go.($file.patterns.rebol)=....  Save the 
rebol.properties file ( this file can be located from Menubar Options>Edit 
properties>open rebol.properties). Once you make all those changes 
you are able to see rebol color syntax for your beloved rebol scripts.

the scripts are launched into the rebol VM hitting F5 key in SCITE. 
You will notice that the color syntaxe is very more advanced than 
the Crimson Editor one. And you have the  ability to hide the functions/objects 
inside code to make easier to read the script code.

Well this is the concret sign that REBOL  is being more and more 
considered in computing world. This is a good thing and a good reward 
for RT hard work.

Nevermind, I made changes to original global.properties and now everything 
works.

I've read through the SDK docs and am probably missing it, but how 
can you set the Company name, Description and version numbers on 
an encapped app?  (So it doesn't say REBOL Technologies in the file 
properties

If you run a program by double-clicking it from explorer, the working 
directory is set to the directory the program is in. Otherwise the 
working directory is either the directory you are in in the command 
prompt, that set in the shortcut properties, or the working directory 
in your program you are starting the program from. I use this to 
make file management tools that work on the current directory all 
of the time.

The screen does look off (aspect and resolution wise) but I can't 
check as the display properties access seems to be locked down for 
security...

There might be some unusual disokay properties set but I do not have 
access to them it seems...

actually not because we have several problems on recursion group 
interpretation on gradient effect (fill and for border line fill) 
so now we are trying to make a better engine that can be use more 
efficient ly rebol object! properties we are basing our work on xml-to-object 
function ...

I'm just looking at the table widget's properties...is it possible 
to have "hidden" fields? he number of fields in my database are much 
larger than what could be displayed.

re: dbl-click problem. I can't reproduce this one. I assume this 
occurs on Windows? What is the dbl-click speed set to? (Control Panel|Mouse 
Properties|Buttons) Is it a mouse or pen (i.e. TabletPC) that generates 
the dbl-click in question?

theses
 -> "these"
needs the following files been installed
 -> "needs the following files installed"
its spawns
 -> "it spawns"
job in background
 -> "job in the background"
transfer to it your data
 -> "transfers your data to it"
additionnal
 -> "additional"
service which dispatch
 -> "service which dispatches"
If there's no free processes
 -> "If there are no free processes"
it become available
 -> "it becomes available"
properties, event and method
 -> "properties, events and methods"
optionnally
 -> " optionally"
Maximum number of background process
 -> "Maximum number of background processes"
controled
 -> "controlled"
performances
 -> "performance"

First, the values returned by get-elements-by-tag-name doesn't have 
to be in the same format as the internal block structure. It can 
be a list of objects that contain references to the original nested 
structure, or objects that contain fields that correspond to the 
information items that you want, including properties that are constructed 
at runtime like parent.

An alternative is to learn denotational semantics, or lambda calculi, 
but this is only useful to CS major trying to proof properties of 
a language, it doesn't help build the intuitions of the language. 
But I will not discourage to go that route if you please.

.. but when I set TTSModeID it doesn't work. I am not sure if I am 
using the right TTSModeID or if I am passing it correctly...

Robert, I'm extracting Outlook Calendar Appointments and Contacts. 
Just rudimentary at the moment, though. I haven't figured out how 
to surely extract all the properties.

i repost a comment on the last Carl's blog post:
I noticed the use of the new Rich Text Format. Bravo !!! 

will have us the possibility of including sub-blocks of text with 
inheritance of the style properties to the sub-blocks ? 

something like: [bold “bla bla” [red “i' m red”]]

That is also why I asked Carl, if it would be possible to read national 
locale properties from OS, but I can imagine it could get tricky

hum, or you can pass a header block to the write function as is:
>> write [ url!  [ User-Agent: "TOTO" ... ]  #{...data...}]

but it's bugy, you have to add yourself some missing header properties 
in the block to generate a valid request.

like Content-Type: "application/x-www-form-urlencoded; charset=utf-8"

so the layout parser sets the action properties of each gui element

but you can't bind properties of one object into another one

define properties

are there any changes planned in R3 in the way objects work? like 
if you could have some "static" methods or properties that would 
not get copied but referenced when one object is derived from another?

So on data, rather than to populate properties of an object port

can grad-pen do all the properties of SVG gradients that you need?

Use Firebug to inspect which DOM properties give you the correct 
height...

but if the plugin had a properties page, we could allow some scripts 
domains or ip addresses specific rights.  all set to off by default. 
 and all prefs values encrypted when saved of sent to registry, so 
that no virii or other nasty can allow its site to run unhindered.

I thought by setting the object's size properties through the DOM... 
I haven't tried.

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

I just want to share this cause I'm all excited... 


I've been working a lot with liquid recently and I think I've just 
tought of an algorithm which would allow "atomic" multithreading 
using liquid.


it would mean building a kernel which manages the nodes, but basically 
several threads would creep up a liquid processing network in an 
async manner and resolve branches out of order, based on a thread 
semaphore and a stack to realign dependencies...  


If this works... It means Elixir OS could possibly have a multithreaded 
kernel, resulting in ALL applications becoming multihreaded without 
any specific coding needed by the developpers.  :-)


adding a few networked services... you could leverge an entire cloud 
(render farm) without even having to code a single specific line 
of cloud and thread stuff, and this would be directly embeded at 
all levels of the OS down to the button properties... cause even 
the most basic gui properties are built up of tiny liquid nodes...

Watch out in the rsp.html doc file, the "Session Object" table is 
correct, but all the detailled explanations for the session properties 
are incorrect (coming from the old and obsolete API). Sorry for that, 
it will be fixed in the final release of this document tomorrow.

maybe there is some kind of dns error. I tried in IE right now, it 
seems to load some page, which is empty - nothing appears on screen. 
So I pressed right mouse button/properties, and there is following 
item: 

res://ieframe.dll/dnserror.htm#http://localhost/test.php

My service DLL spawns a new thread to respond to SCM (Service Control 
Manager) messages. The main thread is still the one from Cheyenne, 
if Cheyenne dies, the service dies too. That's an intended feature. 
The SCM has built-in service automatic restart capabilities, you 
just need to properly configure that in service's properties.

Although it is possible to take advantage of multi-core technology 
by running several applications processes in parallel, the real benefit 
would be for multi-threaded applications. The challenge then is to 
change single-threaded or sparsely threaded applications into multi-threaded 
and also to debug them.

Erlang has unique properties for taking 
advantage of multi-core technology
One of the fundamental properties 
of the Erlang language is built-in support for very light-weight 
processes, each with its own memory, and using explicit message passing 
for their communication. Because of this most applications written 
in Erlang are realized as a number of cooperating Erlang processes 
representing something in the problem domain of the application, 
for example active call sessions, connections or transactions. Typically 
this will result in many thousands of simultaneously executing processes 
in a heavily loaded application.

The parallelism already present 
in most Erlang applications makes them ideal for taking advantage 
of multi-core technology, without there being any need to modify 
them.

The only thing needed is an Erlang virtual machine (VM) which 
works in a multi-threaded way, and that is what we now are releasing 
in Erlang/OTP R11B.

I don't think you run cheyenne from DOS prompt. Create a dedicated 
shortcut and edit the shorcut properties to add -u in the first field.

Does mysql-protocol.r need to be called in each rsp page that you 
create? I see that Cheyenne has database configuaration properties 
in httpd.cfg is mysql-protocol.r already implemented in Cheyenne? 
Sorry for such basic questions but the documentation is fairly limited.

I'm only concerned with latency with 100 clients... my current system 
uses SQL and bogs down nastily while I do analysis on 4000 items 
and their properties (sorting, filtering, finding etc)
I/O Costs:

L1: 3 cycles
L2: 14 cycles
RAM: 250 cycles
DISK: 41,000,000 cyles
NETWORK: 240,000,000 cycles

You can change that easily if you're running it from a shortcut icon. 
Edit shortcut properties and set the "working folder" where you like 
it to be.

basically, go to the properties for the .r file association in explorer

beach front properties ... might get swamped

the layers will allow us to optimise what gets refreshed and allow 
us to stack some properties of all graphic elements on the same layer, 
even if the graphic elements themselves are rendered as a list (of 
overlapping things)

It's stated that this palette is specialy designed to harmonize. 
And I want to get a palette being based on blue with the same properties.

I think, that it is quite natural. You should probably generate some 
random data having (approximately) similar properties as what you 
intend to process and try some variant approaches to really find 
out, which one is best for the task. Do you know, that it is possible 
to index just a specific record field, i.e. you don't need to make 
a hash containing all the data from the database?

you can negate collisions by building two checksums out of different 
properties of you data and merging them.

There's a fundamental flaw with this.. let say i find 3000 customers, 
but now i want to pull their email property

foreach customers  customer [ (pseudo) intersect the  customer with 
i1 and email i2)
once is fine.. but 3000 loops is really slow

probably need to store the properties as objects

data: [ "bob" [ email "[bob-:-example-:-com]" lname "Jones"] ...]

then continue to index email, lname etc

it appears to me that if all the properties of the header was kept 
as strings.
then we could construct back the header's response with 
>>enline form headers
(no need to make a foreach anymore)

Event handlers are basically functions, they can accept event! or 
object if they have the same properties.

I don't mind the current state of affairs either, as the current 
(post 'self debate) object model (including the PROTECT tickets) 
works great, and is more general than object models with explicit 
support for classes and properties. It would help if you could look 
over the PROTECT tickets though, Ladislav.

Right. We shouldn't be using the term "accessor" anyways: Too vague. 
All OOP languages support accessors. Most languages with the syntax 
support you are requesting call that support "properties".

for liquid, expanding is not a big issue... liquid is totally class/instance 
based.... all liquid properties are stored, not part of the node 
itself.

It's not refined in my head yet enough but i think 'IN needs of a 
redesign.

Especially this form allowed by the specs but throwing an error currently.
>> in [obj1 obj2 ...] [a b c d]
== Error!

it could be powerfull, allowing to inherit properties from a hierarchy 
of objects (think about nested gobs with their own context)
But it's not enough...
I would like that the returned block discard the unbound words.
It would be consistent with the single form.
>> in context [a: 1] 'b
== none

I don't know if i'm clear...

It's the next thing on my list to rewrite PREBOL to be compatible 
with R3's module system. The syntax should be a compatible superset, 
but the internals will be a lot different.

  - hmm, reinventing the wheel? (my INCLUDE is already available from 
  rebol.org library and it has the properties you listed)