AltME groups: search

is that plain C, or C++? Btw - how does Cyphre wrap AGG, if AGG is 
said to be strict C++? Does he have to write any wrapper in C first? 
(He said he has AGG in a form of DLL for R2)

How can I 'wait in linux red? Should I wrap something as sleep() 
function?

The get-word! syntax for integer! variables hasn't been implemented 
yet. So currently, the only way (AFAIR) is to wrap your integer! 
in a struct! (as you would do in REBOL).

I've pushed the enhanced get-word syntax support, so it's now possible 
to get a pointer on integer!, byte!, float! and float32! variables 
(without having to wrap them in a struct!). For example:

	s: declare int-ptr!
	a: 123
	s: :a
	print s/value		;-- will output 123


I will add the ARM backend support for that and update the documentation 
tonight.

It would be easer if #system-include would be like #system so that 
you could wrap an extra context around Red/Sytsem code, without introducing 
an extra wrapper file. Would that be hard?

There's an extra problem when I wrap the C binding in a context, 
but that seems unrelated

I'm trying to wrap my GTK dialect in a context, but I'm hitting more 
context bugs

Does this mean no GUI or just gui done in different way?

 See all the presentation slides for Red, a native GUI system will 
 be provided. Also a web server with a new web framework will be part 
 of Red stack, so modern style web apps will be supported.


The GUI will probably be done in different way than R3 underneath, 
maybe a gob!-like datatype will be a good match, but such implementation 
detail is not known until implementation starts. Also, it is possible 
to extract R3 GUI code, wrap it in a shared library and plug it in 
Red (but I won't be the one doing that and maintaining such wrapper).

(For comparison again, sorry) In R3, objects are in many ways like 
the tables in Lua, used for data purposes as well as for contexts, 
underlying several other datatypes or operations as well. Most contexts 
are declared using these other datatypes or functions that wrap objects; 
raw objects are more often used as data structures than as contexts. 
It might make sense to support case-sensitive objects as data structures. 
Nonetheless, I wasn't the one making the suggestion, and I'd have 
to do a bit of research to dig up who was requesting this.

Kaj, just a remark about Red and bindings: there is still  an additional 
feature to come that will allow to import both Red/System and external 
libs functions directly in Red in a declarative way. It will use 
almost the same syntax as #import in Red/System but will convert 
the datatypes automatically (in the same way R2 does with routines 
and structs). A struct! datatype would then be added also to Red. 
The routine! datatype primary purpose is provide a way to write ultra-fast 
code and enable system programming, even if it can be also used to 
wrap Red/System bindings. I'm still unsure which approach would work 
the best for building bindings to C libraries. I guess you'll be 
the first to find out. ;-)

mostly a wrapper to C
 Red/System doesn't wrap C, it replaces it. ;-)

C++ drivers - bad to wrap for us, no?

Thanks for those ideas, Kaj!  I'm thinking it may be better just 
to wrap libjpeg.

Correct. Yes, it is possible to wrap all your global code in a MAIN 
func.

Hmm, it might not be enough, so you might want to have a look and 
maybe wrap libiconv:
http://www.gnu.org/software/libiconv/

For once, the API looks good and simple enough (4 functions to wrap).

I just looked up an example of how to e.g. obtain contact list, the 
official API way, not via some low level direct SQLite hacks. Found 
following link, since Android 2.0, there is ContactsContract class 
for that. But - those examples are more complex, e.g. obtaining cursor 
to DB and looping via returend list after sending a query.


As to understand our bridge - what we are allowed is mainly to wrap 
objects/classes and their methods. I mean - get them assigned to 
Red words. Then we have ability to invoke their methods. I wonder 
though, how one wraps such example as in the following link: 


http://www.higherpass.com/Android/Tutorials/Working-With-Android-Contacts/


Another question - would it be possible to create JAVA function on 
Red side, wrapping the sourcecode? Think inlining of ASM in C, or 
inlining of R/S code in Red?

If you want to offer multiple functions as a library, you can wrap 
their shared state in a CONTEXT

It certainly would be nice to wrap all possibilities up in one package.

To call Red/System code from Red, you have to write a ROUTINE to 
wrap the differences and marshall the arguments:

Arnold: it seems you didn't get that Red and Red/System are two different 
languages. As they are living in different abtraction layers, you 
can't expect to directly include code from one in the other. There 
are special interfaces for that purpose, ROUTINE is the main one 
for calling Red/System code from Red. That doesn't mean that all 
your Red/System code needs to be in a routine, just the interfacing 
code. The rest can be in different libraries that you load into Red/System 
space using #include in #system or #system-global directives. Including 
Red/System code into Red directly is not possible, because, these 
are two different languages. So you need to wrap your Red/System 
code (and Red/System includes) into a #system* directive.

You'd wrap ASM in C with an ASM marker, wouldn't you?

Same thing. You need to wrap Red/System code inlined in Red with 
a Red/System marker

OS libraries and R3 libraries are both libraries. However, with GPL2 
they make an exception for linking to OS libraries even if they're 
closed source. With GPL3 they extended that exception to libraries 
that come with a runtime or VM, like Java, .NET, or closed-source 
REBOL. The exception doesn't go the other way though: It's not allowed 
to link to GPL'd libraries with closed code.


Ladislav, the runtime library is used to implement the interpreters, 
and includes the interpreters for that matter, but it's still a library. 
The DO interpreter really doesn't do a lot; it resolves the op and 
path syntax and dereferences words, but everything else is done by 
the functions of the runtime library, which your code is bound to 
at runtime. But for the good news, it's at runtime, so afaict the 
GPL doesn't require you to release your source because of that binding, 
as long as you load the source at runtime, which you pretty much 
have to do at the moment for scripts.


Encapping is a trick, but you can handle that with some limitations. 
Extensions will need to be GPL 2, and that means that they can't 
be used to wrap closed-source libraries unless they were included 
with the operating system you're running on. Encapping regular scripts 
and modules is semantically iffy, but you could handle that with 
a FAQ entry that explicitly says that loading a R3 script doesn't 
count as linking, even if you bind the words to GPL'd values. The 
same FAQ entry would apply to scripts in files, databases, whatever.

It is common to use this FAQ entry as a way to make GPL extensions 
that wrap proprietary components: http://www.gnu.org/licenses/gpl-faq.html#WindowsRuntimeAndGPL


Developers commonly put links on their web site to the vendor's web 
site to download the DLL. However, it's iffy with GPL2 because the 
actual exception is worded like this:

However, as a special exception, the source code distributed need 
not include anything that is normally distributed (in either source 
or binary form) with the major components (compiler, kernel, and 
so on) of the operating system on which the executable runs, unless 
that component itself accompanies the executable.


Read literally, it would exclude runtime libraries that aren't bundled 
with the OS. It's more unambiguously OK with GPL3.

A make-extension function to wrap the compilation of the extension 
would require the Red compiler to be ported to R3. In the end, this 
won't work anyway, because it's going to be ported to Red itself

This is only partly true.


It is in fact faster to SHOW the whole window, rather than calling 
SHOW multiple times for single elements, when there are sufficiently 
many elements in the window. Still, SHOW also depends on the size 
of the area to display, so if you have, say 10 fields, wrap them 
in a PANEL style and then perform the SHOW on the PANEL instead of 
the whole window or the individual fields.

it is a internal field to store text in VID widgets (its about word 
wrap I think)

by default all radio buttons in the same pane switch together, you 
can just wrap your radio buttons in a panel.

We are giving developers more control by saying that some stuff is 
under their control (i.e. the code blocks). We are providing some 
safety by saying that some stuff is presumed to be not under their 
control and thus possibly suspect (i.e. immediate-evaluation parameters 
to functions that they didn't write). We do screening of some stuff 
because that cuts down on the screening they have to do themselves. 
That way dvelopers can use functions and assume that they are safe 
to use by default.


For instance, one advantage of #1993 FOR would be that they would 
have to go out of their way to make it do an infinite loop, since 
no combination of start, end and bump would generate one. That means 
that they wouldn't have to wrap calls to FOR in expensive conditional 
code, they can just pass in any values of those parameters and trust 
FOR to never go infinite without them expecting it. Your CFOR would 
not have that advantage, but since it takes code blocks for all parameters 
it is assumed that you are more careful about those code blocks, 
as you should be as a general rule in R3.


It's about providing a balance. Complete consistency in how all parameters 
are treated regardless of their nature would not allow us to help 
developers where they need it. However, having a consistent policy 
that code must be treated more carefully by developers than non-code 
allows developers some flexibility while still allowing them to be 
careful. That is why code that developers provide explicitly is considered 
to be what they want to do, at least from the outside of functions. 
And you can make the distinction between code and non-code using 
simple type tests, which is why we have APPLY and ASSERT/type.

By saying that SPLIT-PATH always behaves the same way, depending 
on whether the path ends with a slash or not, it may not shortcut 
a few cases for us, but it does make it easy to reason about, and 
also to wrap for other behavior. e.g., you can always dirize the 
path before calling it.

And as I said - some real service example should be provided - as 
someone mentioned in other channel - why not to wrap just simple 
"Hello word"?

I don't know if it is usefull to have sliders in there, but what 
happens if menu is larger than app window, or app window is near 
screen-face border? Will menu wrap to the other side then? What happens 
if you resize main window etc?

While I'm at it ... am I the only one where links get distorted in 
display? Klicking works, but long links seem, are displayed wrong 
... they either wrap to the next line (partly overriding the text 
there), or part of the link isn't displayed.

Ah, then the answer to your question is : 100% of our energy is going 
into AltME 2.  It is not worth fixing that error (which is in Rebol 
I should mention), since we will be working with Carl when we wrap 
this up.

INMOLD: func [

 format [block!] "internal formatting to apply eg. [newline all skip 
 3]"
	value [block!] "block you would like formatted"
	/local path code
][
	; wrap NEW-LINE
	code: reduce [path: to-path 'new-line 'value true]
	parse format [
		any [
			'remove (poke tail code -1 false)
			| 'newline () ; redundant
			| 'all  (append path 'all)
			| ['skip set n integer!] (append path 'skip append code n)
		]
	]
	do code
]

The first load/all seems to wrap in brackets once too often !

Graham: I might not quite be getting it but this style works for 
me.  Wrap your code in a "go" function and then ; Loop forever
forever [
    if error? result: try [go] [
        errobj: disarm result
        errorlog [mold errobj]
        either noask [
            alert reform ["There has been an error logged"
                  newline copy/part mold errobj 200

                  newline "See File/Configure/View Error File/ for more info"]
        ][

            unless question/title reform ["There has been an error logged."

                                  newline copy/part mold errobj 200] "Continue?" [
                print ["Type Q to quit, GO to restart FirM"]
                halt
            ]
        ]
    ]
    ; halt
    recycle
]

btiffin ... I guess it's good to wrap an error handler around the 
whole program, and too often I don't. I just trap suspect areas, 
and then get caught when something happens in a region where I was 
not expecting the possibility of an error.

about Roberts stack: most of that is inbuild in series, so why wrap/rename 
it?

size of draw-text: you want wrapping? afaik not. there is a complicated 
handmade way, you make a face of that size with 'wrap and use that 
to calculate the lines.

with [append init [iter/para/wrap?: false]]

as for always-on-top or other modes of Windows, it is a pity we don't 
have them. It is just one single function call, which even C lamer 
as me was able to wrap ;-) ShowWindow or ShowWindowPos

here is an example for handling multiple non-exlusive switches:


lets say you have refinements /a /b /c /d.      /d is mutually-exlusive 
to all others and a + b reacts differently than when alone... trying 
to wrap that in if/either can be a nightmare, and its impossible 
using case or switch... BUT using any/all actually makes it quite 
visual and simple to see flow:

Wrap it in a function.
now-timestamp: does [rejoin [...]]

blank line is required if you manualy wrap your line at 70/80 char 
because your editor does not wrap by himself (Carl's intention, see 
makedoc2.5 header)

maybe later i will wrap all the zip package into a .exe file using 
grebox wrapper from shadwolf and spag' :)

Does \note wrap text?

The web page created by makedoc2.r is too wide for my screen. How 
can I make the lines wrap at the right border of the window so that 
when the window size is changed the line breaks are automatically 
adjusted?

so does it just wrap on words?

this is being done to try and format and wrap text of course.

guru question;  Will a utype! definition be allowed to wrap builtins? 
 SNMP MIBs require a fairly heavy weight tuple!  But will a short 
MIB conflict with internal scans of tuple! or do utype! scans take 
some form of precedent?  I've become curious, yet remain dumb enough 
to not know.

You should wrap your code in a context.

I wanted to do some basic regex set, some common denominator, partly 
as an exrcesise in parse and partly to stop people looking at rebol 
saying "it has no regex". so now it has ;)
So I'm not sure what dialect of regex is the best one.

Block parse syntax to strings - you mean that char! ? Yes, it's probably 
not doing anything, the code needs some cleanup.
I plan to wrap it in context, yes.

as for NS plug-in, I provided some started too ... basically less 
than 15 funcs to wrap to have it without tricks imo ;-) I just need 
C coder for similar cooperation :-)

not sure the sdk is needed. If we are after old plug-in, not mozz 
components, then it is really few funcs to wrap ...

It's fairly straigt-foward (I think!).


.......If you have no multi-part data, then just used the "standard" 
read-cgi  -- but remember that on some platforms no input returns 
"" while on others it returns none
http://www.rebol.com/docs/words/wread-io.html


.....If you have multi-part data (say an uploaded file), then use 
Andreas' decode-multipart-form script:

 http://www.rebol.org/cgi-bin/cgiwrap/rebol/ml-display-message.r?m=rmlKVSQ


.....If the form could have both or neither (ie there may or may 
not be a file uploaded), then each of the above solutions will fail 
(Carl's when there is. and Andreas's when there isn't)....So wrap 
the full code in a few attempts to handle that.

I never got cropped long lines, it should wrap

And, there is also the problem that occurs if any code example is 
too long, pushing out the right margin for the entire doc. I've thought 
about correcting for that in MD. But, not sure how best to do that 
(wrap or clip).

I will have to find a way of how to study it - it is very late here 
and I just looked into archive size - 1.6 MB  archive - oh my ... 
so - if there is no simple way of how to wrap it, I will go my own 
way, as usual, even with limited featureset - I don't need fancy 
javascript/java/whatever graphing - if I go View way, I will have 
to develop AGG based graphing anyway ...

the only way I will accept it is - 1) someone introduces me quickly 
into how to use it, wrap it 2) it comes preinstalled on linux similar 
way, of how I can use webmail for e.g. I will not go thru all this 
- http://www.mrtg.cz/mrtg-nw-guide.html

Question to HTML / CSS gurus
I have to display Rebol code in an HTML page. I use <PRE> tags.

Problem : whatever I use (Cell, Div, Pre) the wrap only occurs based 
on the window width, not the one I specified in the tag.

So, how to force PRE text to wrap in a specific width ?

I don't think, you can force a wrap at a certain place. It's in the 
nature of HTML, as it's not wysiwyg.

<pre> literally means "as written" -- if there are no line breaks 
in the text, then there will be none on the page.
***

Some lines in <pre> tags can be accidently enormously long, and need 
to be wrapped by hand.

That's one reason REBOL.org offers you a user-setting for the point 
at which you want Mailing list messages to be forcibly wrapped:
http://www.rebol.org/cgi-bin/cgiwrap/rebol/cpt-update-profile.r

(See Appearance and settings / Point at which Mailing List Archive 
messages will start to wrap.)

Dideir, yeah we ran into this recently in allowing people to escape 
code inside our Wiki.  We allow Rebol, HTML, etc.

At first it seems counter intuitive. But this is the way of HTML.


Aside from the straight forward concept as Sunanda mentioned, if 
you are willing to process the code a little you can count the characters 
of the longest line, and scale the text to match the final output. 
 A couple of points dropped on a font stil are readable, and many 
sentences still fit.


Another is to encode the whole thing, in other words convert all 
the "<" for example to escape sequences.  Now HTML will wrap everything 
automatically.

Well - there is property in CSS - 3 - but add this in style
pre {
 white-space: pre-wrap;       /* css-3 */
 white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
 white-space: -pre-wrap;      /* Opera 4-6 */
 white-space: -o-pre-wrap;    /* Opera 7 */
 word-wrap: break-word;       /* Internet Explorer 5.5+ */
}
http://myy.helia.fi/~karte/pre-wrap-css3-mozilla-opera-ie.html

if you are on an unreliable or slow connection, you might experience 
timeouts which will in turn cause network errors. I recently worked 
on a similar system and you have to basically wrap all code that 
access the internet in TRY and do a lot of error trapping and possibly 
some retrying to ensure that uploads and downloads of entire filesets 
are done correctly. The code in build-site.r will not do that, so 
you have to restart the upload if it fails.

With QM, I use QuickTags (integrated into RSP or standalone) to build 
the form elements, and then wrap common constructs in functions.for 
data-driven forms.  It's not as pure as say, Henrik's HTML dialect, 
but perhaps has the flexibility of being at markup level.

http://www.ross-gill.com/page/QuickTags


Alternatively I have a make-doc dialect (somewhat rough) that I use 
for forms on my site wiki.

http://2008.rebolconf.info/on/!Edit_Form?format=raw

Interestingly this search engine has a REST interface so you can 
wrap your own custom search around it.  95k pages and still going 
...

Set-Net not provided.
** Script Error: stylize has no value
** Near: stylize [
    wmtxt: text "Test" 255.255.0 font-size 16
    wtext: text " " 640 as-is no-wrap black white
    box: box...
** Press enter to quit...

and could wrap my app in a little batch file... to make it invisible 
...

shadwolf: Adding a hide flag requires me to alter all my data. Just 
wrap it around, if the grid doesn't know about it, just skip it.

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

I think not, Graham .... we have such a problem ... big corporation, 
we try to define xml formats. The trouble is, big products do wrap 
it for you, but what about smaller companies?

I probably need to wrap <message> tags around it too.

REALLY hard to wrap my head around the dialect.. and its VERY verbose.. 
yet using the Flash IDE = simple.

I would like to know how is it with trapping the errors? I read available 
rebcode docs, and it seems to me that you can make your rebol process 
to fail by wrong rebcode code, right? Is it  theoretically possible 
to wrap rebcode call into 'try, so if it fails, error is returned 
instead of process crash?

You can have all of your generated code segments be added as snippets 
of the same length if you wrap them in a block surrounded by the 
same code. For that matter, only that code block would need to be 
changed when changing the generated rebcode. You could even handle 
the freelist with ease by swapping marker code into free areas.

Probably not, then. You might want to wrap this all in a context 
statement to capture the global variables you're using.

It would probably be easier to wrap the Speech API and use it directly.

Really? I thought that's a pretty cool idea, and than wrap it inside 
a VM running on a host OS.

Then break it down into discrete queries and wrap it in some loops:

blk: copy []

foreach [company-id order-id date amount total] sql [

 select [company-id order-id date amount total] from orders where 
 [amount > 2000]
][
	company-name: second sql compose [lookup companies (company-id)]

 foreach [item-id item-price goods-name] sql compose [select * from 
 order-items where (order-id)] [

  insert tail blk reduce [order-id date amount total item-id item-price 
  goods-name company-name]
	]
]

sort/skip/compare blk 8 [8 1 5]

I understand... which is why I noted, it could be an option... cause 
although  substitution variables are closer to SQL,  expression embedding 
within parenthesis is quite familiar in rebol ... 


but in any case, We can all just wrap the rebdb calls within our 
own I guess ;-)

I would be glad, if we would work from original sqlite3.r version, 
Ashley .... it is simplified wrapper, not messing with scheme code 
... first we can make this one better, then properly wrap scheme, 
although using scheme for local files is not of much use anyway ...

There is some collation function which we need to wrap. I posted 
it here some time ago, but we were not succesfull in wrapping and 
utilising it. I also tried to look into IIRC Python sources, and 
it was not clear to me, how to specify it in REBOL level. IIRC it 
is callback type function ...

you can wrap the fields in a panel and use:

set-face my-panel [db/:counter/2 db/:counter/3 ...]

word wrap queries (like in the old amiga api) within AGG draw would 
be cool too... as in, what would the size of this text (or any gfx 
element, for that matter) be with current font/drawing settings. 
 and how many letters from a string fit within this box ? wrapped 
or not.

I like the API being able to wrap a one dll from each generation, 
and then update that dll for security fixes.

French wrap songs, but at the end the guys are speaking Russian (I 
think. Definitely not French, though).

ScotT - interesting - I posted some link and said it earlier, that 
RT could concentrate upon NS plug-in only .... as there is (somewhere 
:-) wrapper ActiveX, which can wrap to NS plug-ins ....

slim is about managing the internals ... both technically and politically. 
 its about providing a unique and consistent code model to allow 
tools to wrap around this.

we could probably wrap the code in the way you specify. but then, 
slim allows you put your code anywhere...

basically I want to use rebol 3 core and wrap it within an OS shell.

Is this what you have to do SSL enable/wrap Cheynne ? http://www.stunnel.org/examples/https_windows.html

hmm, we could also wrap SDL, no?

yes, I completely agree with NickA... python's lua's haxe's very 
important strenghts were always that you got a easyer "scripting 
/ dynamic lang" access to various c/c++ apis ranging from databases, 
 openssl, libevent..  to wxwidgets to 3d and 2d engines (pyogre, 
pycap, pyglet) ... These bindings aren't all "perfect" fit to the 
language, for example coding xwPython app feels a LOT more low level 
than java swing app as you are dealing with direct c++ api, but they 
give you full world of choices that you otherwise just couldn't have, 
and you can always build wrap core api-s in more in this case rebolish 
shape.

I also need to add extend Draw dialect with a new command: text-box. 
It's an improved version of 'text that allow you to define a bouding 
box, align the text horizontally and vertically and auto-wrap text.

I found a justification routine (doing also alignement). I need to 
study it to see if it fit my needs : align and line-wrap at the same 
time.

word wrap or line wrap?

line wrap