World: r3wp

it might actually be easier to look at the chrome source code and 
starting from there!

yeah - the embedding API docs are not there at all

Adobe Flex 4 ActionScript 3 wraps WebKit, right?

a good list here:

http://trac.webkit.org/wiki/Applicationsusing WebKit

Hosting Webkit wouldn't help here: The whole point to HTML5 etc. 
acceptance is that people don't have to install another program - 
they can just use their existing web browser. Hosting Webkit would 
only help us if we want to display existing web browser code; it 
wouldn't be necessary for generating code to run in Webkit, because 
the copy of Webkit that people would be displaying your GUI in would 
usually be a separate program, often on a separate computer. And 
HTML/JS/CSS is just text - we can generate text already.

plug-in still might be the way to go. Google is introducing native 
extensions too ...

Native Client would be an interesting way to get REBOL into a browser, 
particularly once they get the portable version up and running :)

Brian, my point with the embedded WebKit would be to have an alternative 
gui framework that has the capabilities people are used to from a 
browser. With a non-hosted WebKit (or any old browser), you couldn't 
have very close integration with the REBOL runtime.

in-browser use of REBOL is a different thing - for sure more useful 
in the longer term, but what can be done today?

Embedding REBOL *in* Webkit would work well. The other way around 
wouldn't help as much, because we'd be stuck with the browser GUI 
model when we don't have to be. People don't use the HTML/CSS/JS 
model because it's good (it's not), they use it because it's there 
already.

exactly - it's there right now, as opposed to VID 3.4 which is only 
going to be fully available some time from now (in a more polished 
form)

As for embedding REBOL into WebKit, where would that get us? It's 
not as if other browsers based on WebKit would pick up these changes 
even if we were to submit them to the project.

No, I mean there on users' computers already, in their existing web 
browsers, not in *any* standalone program. Webkit embedded in R3 
would be viewed as a standalone program. R3 embedded in Webkit would 
be viewed as a plugin to a program they already have.

doing REBOL through native client is a different thing though - that's 
worthwhile

WebKit hostted in R# would just be viewed as an additional lib that's 
part of a customized distribution

sorry, r#

jeez, you know what I mean :-)

Don't worry, I wasn't thinking of embedding R3 through anything other 
than browser plugin APIs, or Native Client. There's no point to trying 
to submit it into a particular browser unless it also exists as a 
plugin for other browsers.

sorry but using webkit within REBOL is very usefull.  we can use 
HTML content within our own tools.

hope to have a very rudimentary extension soon

least for Windows

Maxim, I don't doubt that it using Webkit in R3 would be useful. 
But it would be useful for other reasons than providing a GUI for 
R3 (the topic of this group) - more for displaying the GUIs of other 
code within R3, other code (un?)fortunate enough to have been written 
in HTML/CSS/JS.

that's what I mean... but it also means that we could build nice 
web dev tools using R3, which could cross-compile as desktop and 
web apps.

anyhow... I'm still anxious to get next plugin/host.

Small status update:


Working on resizing now, particularly proper pixel accuracy and getting 
rid of all blocks. Ladislav and Cyphre are working on a good algorithm 
here.


This will also create a change in how styles draw gobs: Currently 
a gob defines mostly only the draw area of a face and then spaces 
between gobs are used to create paddings. This is efficient, but 
it makes drawing things outside a button, like blurred shadows very 
difficult. So instead, the gob now constitutes both the drawn button 
and its padding. A side effect is that spacings between gobs are 
now always pixel accurate, because they now rely on the draw block, 
rather than the resizing engine.

A downside is that when you define the style, you also need to define 
a click area, to avoid getting a click registered on a space between 
two buttons. But perhaps this can be automated, don't know yet.


Furthermore, there will be keywords available for DRAW blocks to 
easily locate a corner or a center of the draw block.


Overall, these things will make it much easier to write draw blocks 
for styles.

IT seems god, but in the same time, i'm not sure I like this "clipping 
area" of events thing.

A "silly" idea : could use one gob for the drawing, and another one 
in front of it clipped to the "usable" size for the event tracking 
!?

Cyphre has a good idea on how to do this, and it probably involves 
an extra gob. As a side effect, it might be possible to define a 
bitmap mask to get pixel precision accuracy for click events.

Bitmap mask doesn't require another gob.

ok

globs use several layers, one is for mouse interaction.

globs => you mean in glass ?

yep, the low-level engine over which glass is done.


I was confirming that its a good and simple way to go forward for 
R3 too.

Didier, are you thinking of how QNX Photon worked? I can't remember 
exactly, but that sounds like what it did.

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

Demo of pixel accurate resizing.

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


Same as 210, except border sizes for each individual GOB is randomized.

Randomized to be different, but constant for each rect or to vary 
on the different sides?  It seems to be the latter...

I guess I'm asking if the variance I see on the various sides is 
an artifact of the resizing

the gob size is supposed to be nice like in 210, but the border moves 
in and out randomly per side per gob.

this is what you're working on fixing currently?

Cyphre is working on this, yes.

sorry, I should learn how to read stuff that's been posted already...

A downside is that when you define the style, you also need to define 
a click area, to avoid getting a click registered on a space between 
two buttons.

  ..... I am not sure I can understan, how it is done. Is another gob 
  used to define click-area?. Carl reduced VID to one-style = one-gob, 
  and it was clear it can't work for more complex style, you had to 
  "switch" drawblocks anyway. Now if I understand it correctly, we 
  are back to kind of  "border" aspect of R2? 


I still liked maybe more complex but also more flexible way of Gab's 
VID, where one style was compound of more gobs, if needed ....

you don't need another gob to define click-area. It will be probably 
done using a bitmap mask.

Also you can have more gobs in one style. But you do not need it, 
most of the time.

bitmap mask? Will not it be slow?

Pekr, after working with multiple GOBs for a single face, I think 
it's simply easier to just work with one GOB and a set of draw blocks 
on top of it. Otherwise you get many small parts.

Pekr - why slow?

Well, that might be psychological, but I always hated to work with 
"border" in R2. You have to count it into metrics ..... but maybe 
your model is different, than having border area ... but I can understand, 
that having shadow/glow to UI elements could be troublesome othewise 
...

the box model Cyphre is working on is unlike R2View, it's more similar 
to CSS.

why slow? I don't know. What's the bitmap mask anyway? Some low level 
C function? I thought that putting one transparent gob upon the drawed 
gob could be faster, as event engine simply flows event to particular 
gobs .... (but it would probably cost a memory, because you would 
need two gobs for one style)

re "Box model" ... good to know ...