Learn REBOL By: Nick Antonaccio Updated: 1-21-2013 See http://howtomakeaprogram.com and http://easiestprogramminglanguage.com for quick introductions to REBOL. Go to http://rebolforum.com to ask questions. All of the examples in this text are available at http://re-bol.com/examples.txt Be sure to see the 68 YouTube video tutorials that cover this material (10 hours of video). An updated and expanded version of this tutorial, specifically aimed at Business Programming is available at http://re-bol.com/business_programming.html A quick game programming tutorial is available here. An additional CGI tutorial is available here. A simple introductory tutorial application for children is also available. A tutorial about using REBOL with the Etsy API is available here. See Nick's page about programming for hire at http://www.wherecanifindaprogrammer.com ===Introducing REBOL What is REBOL? Why use it? * REBOL is a uniquely small and productive development tool that can be used to create powerful desktop software, dynamic CGI web site and server applications, rich distributed browser plugin applications, mobile apps, and more. REBOL's blend of capability, compact size, ease of use, cross-platform functionality, and variety of interpreter platforms enable it to gracefully replace many common tools such as Java, Python, Visual Basic, C, C++, PHP, Perl, Ruby, Javascript, toolkits such as wxWidgets, graphic/multimedia platforms such as Flash, DBMSs such as Access, MySQL, and SQLite, a variety of system utilities, and more, all with one simple paradigm. Despite its broad usefulness, REBOL is far easier to implement than any other comparable tool. * REBOL is ultra compact. Its uncompressed file size is about 1/2 Meg on most platforms. It can be downloaded, installed, and put to use on all supported operating systems in less than a minute, even over a slow dialup connection. * REBOL can also be used immediately, without installation, on over 40 operating systems as a lightweight file manager, text editor, calculator, database manager, email client, ftp client, news reader, image viewer/editor, OS shell, and more. You can use it as a simple utility program with a familiar interface to common computing activities, on just about any computer, even if you're unfamiliar with the operating system. * REBOL includes GUI, network, graphics, sound, database, image manipulation, math, parsing, compression, CGI decoding, secure network services, text editing, and other functions built-in. No external modules, tool kits, or IDEs are required for any essential functionality. * REBOL is easy enough for absolute beginners and average computer users to operate immediately, but powerful and rich enough for a wide variety of complex professional work. * REBOL has useful built-in help for all available functions and language constructs. * REBOL is supported by a friendly and knowledgeable community of active developers around the world. * REBOL is available in both free and supported commercial versions. The free version can be used to create commercial applications, with very few license restrictions. Part of the REBOL language is open source, and that code is available directly in the interpreter. The closed components are kept in an escrow account, in case the Rebol Technologies company ever goes out of business (source code escrow licenses are available for those who use it in critical work). * REBOL has a facility for ultra fast performance using "Rebcode", which can be optimized like assembly language, but works the same way across all supported hardware and operating systems (using the exact same code). * REBOL was created by Carl Sassenrath, who developed the Amiga operating system executive in 1985 (the first preemptive multitasking OS kernel for personal computers). REBOL has been in commercial use since its first release in 1998, and a 3rd major release of the language is in active development as of 2009. * REBOL is a modern, multi paradigm development tool (procedural, object oriented, and functional), but its unique syntax goes well beyond traditional approaches to computer language design. REBOL code is typically much shorter and more readable than other languages, and REBOL is often far more productive than other development tools (very often, dramatically so). There's absolutely no simpler solution for cross-platform GUI creation, anywhere (the code for a complete program window with a button is simply: view layout [button] ). But that just scratches the surface. REBOL has a striking ability to simplify difficult computing tasks of all types, with straightforward, high level code dialects. No other development tool is as adept at creating practical domain specific languages. On a more basic level, the storage/manipulation/transfer of all data is managed by a single ubiquitous code structure. Arrays, lists, tables, and even sizable databases of mixed text, code, and binary data are all stored using one consistent "block" syntax. Blocks are created simply by surrounding any list of data with square brackets. Like everything else in REBOL, the format is extremely simple, but it enables many powerful features for searching, sorting, comparing, dissecting, evaluating, storing, retrieving, transferring and otherwise manipulating information of all types. Common network protocols and data values are also natively usable in REBOL. You can read and write data directly to/from web servers, email accounts, databases, and more, add/subtract time, date, and other values automatically, manipulate XML, HTML, CSV and other formats natively, display and apply effects to images, play sounds, etc., all without any preparation, complex formatting, or use of any external library code. REBOL has a built in, powerful "parse" dialect which elegantly replaces the need for regular expressions in most cases. The list of such practical features is long, but REBOL is not built from simple gimmicks - it's a deep and powerful tool. Because so many practical computing elements are all built into REBOL, and interact natively, the learning curve required to get real work done is much easier than in other development environments. No other language includes such straightforward and versatile mechanisms for accomplishing the most basic work of computers - managing data of all types. * REBOL is small, practical, portable, extremely productive, and different than the typical mess of modern computing tools. It does not rely on a large stack of disparate technologies to accomplish useful computing goals. All it's features exist inside one tiny downloadable executable that anyone can get running, on just about any computer, in less than a minute. It can be used as anything from compact utility application to powerful professional development environment. Even average computer users with absolutely no coding experience can learn to create real, useful and powerful REBOL scripts very quickly. Here are a few screen shots of examples covered in this tutorial: =image rebol_tutorial/mosaic.png Downloadable Windows executables of these programs are available at: http://musiclessonz.com/rebol_tutorial/examples ===How This Tutorial Is Organized There are 5 main parts to this text: #Fundamentals:
The first sections cover how to use the REBOL interpreter (typing in the console, creating scripts, navigating built-in help, creating .exe's, etc.), basic language constructs and syntax (variables, functions, data types, conditions, loops, i/o, etc.), and the fundamentals of creating GUI program windows (~65 pages). #Examples:
12 fully documented programs which demonstrate, line by line, how the above fundamentals are put together to form complete applications (~35 pages). #Other Important Topics:
Graphics, animation, 3D, using databases, accessing DLLs and the OS API, web site CGI programming, writing multitasking code, 3rd party tool kits, parse, objects, ports, and more (~100 pages). #Real World Case Studies:
21 full case studies covering how a wide variety of complete desktop, network, and web site applications were conceived and created using REBOL. This section demonstrates, step by step, how each of the examples grew from concept to final design using outlines, pseudo code, and detailed finished code. Each example demonstrates a variety of practical REBOL concepts, code patterns, and tools, and helps guide you towards "thinking in REBOL" (~230 pages). #Additional Scripts and Resources:
More code and resources to help complete your understanding of REBOL and continue learning. This tutorial is less than 450 pages, yet it covers the REBOL language from the ground up, fully documents the creation of more than 50 applications, and contains many additional short scripts and useful concepts. Links to other online documentation resources are provided to more fully learn many topics, but no third party reference materials are required to understand any example in this text, even if you've never programmed a line of code before. If you're familiar with other programming languages, be prepared to think about coding in ways that are a bit different from your accustomed patterns. You won't find the typical explanations of object oriented programming, modules, pointers, arrays, string management, regular expressions, or other common topics in this text. That's because REBOL's design provides straightforward solutions to reduce or eliminate the need for many complex syntax structures and coding techniques you may know. Every step of the way through this tutorial, you'll pick up practical approaches to easily achieve computing goals of all types. By learning REBOL, you'll learn to get many things done more quickly and easily than you can with any other tool. Enjoy! ===Getting Started: Downloading and Installing REBOL, Hello World The REBOL interpreter is a program that runs on your computer. It translates written text in the REBOL language syntax ("source code") to instructions the computer understands. To get the free REBOL interpreter, go to: http://www.rebol.com/download-view.html For Microsoft Windows, download the rebview.exe file - just click the link with your mouse and save it to your hard drive. If you want to run REBOL on any other operating system (Macintosh, Linux, etc.), just select, download and run the correct file for your computer. It works the same way on every operating system. You can use the stand-alone versions on just about any desktop machine. Upload the correct interpreter version to your web server and you can also execute REBOL CGI programs directly on your web site. You can also install a plugin version to run full REBOL desktop applications directly on pages in a web browser. Once you've got the tiny REBOL desktop interpreter downloaded, installed, and running on your computer (Start -> Programs -> REBOL -> REBOL View), click the "Console" icon, and you're ready to start typing in REBOL programs. To run your first example, type the following line into the REBOL interpreter, and then press the [Enter] (return) key on your keyboard: alert "Hello world!" Before going any further, give it a try. Download REBOL and type in the code above to see how it works. It's extremely simple and literally takes just a few seconds to install. To benefit from this tutorial, type or paste each code example into the REBOL interpreter to see what happens. Install Notes: To enable REBOL/View console support in Ubuntu Linux, follow these instructions: # Download the tar.gz file for Linux x86 - Fedora (Kernel 2.6). # Open with archive manager (default). # Look in the rebol-276 folder (or whatever version you've downloaded). # Select and extract the "rebview" file into Ubuntu's HOME directory (the parent of the Ubuntu folder in the file system, or /home/ubuntu/ at the command line). In some versions, the file name is "rebol" instead of "rebview". # Open a terminal window (Applications -> Accessories -> Terminal) # Type "./rebview" (without the quotes), or "./rebol", depending on the version you've downloaded. On some versions of Linux, you may need to run "./rebview +i" to install the required libs. For Ubuntu 10.04 and some versions of REBOL, you may need to run the following on the command line: http://re-bol.com/rebol_ubuntu1004.txt. ===An Amazingly Tiny Demo and Some Simple Examples Many of the examples programs in this tutorial are available as downloadable Windows executables, at: http://musiclessonz.com/rebol_tutorial/examples To whet your appetite, here's an example that demonstrates just how potent REBOL code can be. The following script contains 10 useful programs in LESS THAN HALF A PRINTED PAGE OF CODE: # FREEHAND PAINT: Draw and save graphic images # SNAKE GAME: Eat the food, avoid hitting the walls and yourself # TILE PUZZLE, "15": Arrange the tiles into alphabetical order # CALENDAR: Save and view events for any date # VIDEO: Live webcam video viewer (not just a static image) # IPs: Display your LAN and WAN IP addresses # EMAIL: Read emails from any pop account # DAY CALCULATOR: Count the days between 2 selected dates # PLAY SOUNDS: Browse your computer for wave files to play # FTP TOOL: Web site editor (browse folders on your web server, click files to edit and save changes back to your server, create and edit new files, etc.) This example is 100% native REBOL code. No external libraries, images, GUI components, or other resources of any kind are imported or called. It runs on Windows, Mac, Linux, and any other OS supported by REBOL/View. To run it, just download the tiny REBOL interpreter and copy/paste the code below into the console (a Windows .exe is also available here): REBOL[title:"Demo"]p: :append kk: :pick r: :random y: :layout q: 'image z: :if gg: :to-image v: :length? g: :view k: :center-face ts: :to-string tu: :to-url sh: :show al: :alert rr: :request-date co: :copy g y[style h btn 150 h"Paint"[g/new k y[s: area black 650x350 feel[engage: func[f a e][ z a = 'over[p pk: s/effect/draw e/offset sh s]z a = 'up[p pk 'line]]] effect[draw[line]]b: btn"Save"[save/png %a.png gg s al"Saved 'a.png'"]btn "Clear"[s/effect/draw: co[line]sh s]]]h"Game"[u: :reduce x: does[al join{ SCORE: }[v b]unview]s: gg y/tight[btn red 10x10]o: gg y/tight[btn tan 10x10]d: 0x10 w: 0 r/seed now b: u[q o(((r 19x19)* 10)+ 50x50)q s(((r 19x19)* 10)+ 50x50)]g/new k y/tight[c: area 305x305 effect[draw b]rate 15 feel[engage: func[f a e][z a = 'key[d: select u['up 0x-10 'down 0x10 'left -10x0 'right 10x0]e/key]z a = 'time[z any[b/6/1 < 0 b/6/2 < 0 b/6/1 > 290 b/6/2 > 290][x]z find(at b 7)b/6[x]z within? b/6 b/3 10x10[p b u[q s(last b)]w: 1 b/3:((r 29x29)* 10)]n: co/part b 5 p n(b/6 + d)for i 7(v b)1[ either(type?(kk b i)= pair!)[p n kk b(i - 3)][p n kk b i]]z w = 1[clear( back tail n)p n(last b)w: 0]b: co n sh c]]]do[focus c]]]h"Puzzle"[al{ Arrange tiles alphabetically:}g/new k y[origin 0x0 space 0x0 across style p button 60x60[z not find[0x60 60x0 0x-60 -60x0]face/offset - x/offset[ exit]tp: face/offset face/offset: x/offset x/offset: tp]p"O"p"N"p"M"p"L" return p"K"p"J"p"I"p"H"return p"G"p"F"p"E"p"D"return p"C"p"B"p"A"x: p white edge[size: 0]]]h"Calendar"[do bx:[z not(exists? %s)[write %s ""]rq: rr g/new k y[h5 ts rq aa: area ts select to-block(find/last(to-block read %s)rq)rq btn"Save"[write/append %s rejoin[rq" {"aa/text"} "]unview do bx]] ]]h"Video"[wl: tu request-text/title/default"URL:"join"http://tinyurl.com" "/m54ltm"g/new k y[image load wl 640x480 rate 0 feel[engage: func[f a e][ z a = 'time[f/image: load wl show f]]]]]h"IPs"[parse read tu join"http://" "guitarz.org/ip.cgi"[thrucopy my to]i: last parse my none al ts rejoin["WAN: "i" -- LAN: "read join dns:// read dns://]]h"Email"[ g/new k y[mp: field"pop://user:pass@site.com"btn"Read"[ma: co[]foreach i read tu mp/text[p ma join i"^/^/^/^/^/^/"editor ma]]]]h"Days"[g/new k y[ btn"Start"[sd: rr]btn"End"[ed: rr db/text: ts(ed - sd)show db]text{Days Between:}db: field]]h"Sounds"[ps: func[sl][wait 0 rg: load sl wf: 1 sp: open sound:// insert sp rg wait sp close sp wf: 0]wf: 0 change-dir %/c/Windows/media do wl:[wv: co[]foreach i read %.[z %.wav = suffix? i[p wv i]]]g/new k y[ft: text-list data wv[z wf <> 1[z error? try[ps value][al "Error"close sp wf: 0]]]btn"Dir"[change-dir request-dir do wl ft/data: wv sh ft]]]h{FTP}[g/new k y[px: field"ftp://user:pass@site.com/folder/"[ either dir? tu va: value[f/data: sort read tu va sh f][editor tu va]]f: text-list[editor tu join px/text value]btn"?"[al{Type a URL path to browse (nonexistent files are created). Click files to edit.}]]]] That's the entire application - all 10 programs. Go ahead, give it a try. Download the REBOL interpreter and copy/paste the code above into the console. It only takes a few seconds. By the end of this tutorial you'll know exactly how all that code works, and much more... +++ - Several Basic Examples The above example is obfuscated to demonstrate just how malleable and compact REBOL code can be. The following examples represent more typical, readable REBOL code. This first example demonstrates how to create a basic GUI program window (the size info in this example is optional): view layout [size 500x400] Here's a program window with a text area and a button: view layout [area btn "Click Me"] In this example, the button does something when clicked: view layout [ area btn "Click Me" [alert "You can type in the square area."] ] The following example demonstrates how the button can be made to save any text typed into the area, to a file on the hard drive: view layout [ a: area btn "Save" [ write %reboltut.txt a/text alert "Saved" ] ] Here's a little text editor application that builds on the idea above. You can likely get a sense of how it works just by glancing through the code: view layout [ h1 "Text Editor:" f: field 600 "filename.txt" a: area 600x350 across btn "Load" [ f/text: request-file show f a/text: read to-file f/text show a ] btn "Save" [ write to-file request-file/save/file f/text a/text alert "Saved" ] ] Here's an email client you can use to read and send emails to/from any pop/smtp server: view layout[ h1 "Send:" btn "Server settings" [ system/schemes/default/host: request-text/title "SMTP Server:" system/schemes/pop/host: request-text/title "POP Server:" system/schemes/default/user: request-text/title "SMTP User Name:" system/schemes/default/pass: request-text/title "SMTP Password:" system/user/email: to-email request-text/title "Your Email Addr:" ] a: field "user@website.com" s: field "Subject" b: area btn "Send"[ send/subject to-email a/text b/text s/text alert "Sent" ] h1 "Read:" f: field "pop://user:pass@site.com" btn "Read" [editor read to-url f/text] ] As you can see, REBOL is typically very easy to read and write. ---Opening REBOL Directly to the Console Before typing in or pasting any more code, adjust the following option in the REBOL interpreter: click the "User" menu in the graphic Viewtop that opens by default with REBOL, and uncheck "Open Desktop On Startup". That'll save you the trouble of clicking the "Console" button every time you start REBOL. ===Some Perspective for Absolute Beginners This tutorial moves at a pace quick enough to satisfy experienced developers, but because REBOL's learning curve is different from other programming languages, it can also be understood clearly by beginners. If you're reading this text as a novice programmer, it can be helpful to understand a few basic concepts that provide perspective about learning to program. First: Essentially, all computers do is let users input, store, retrieve, organize, share/transfer, manipulate, alter, view and otherwise deal with data in useful ways. So, everything you'll do when writing code basically involves manipulating text, numbers, and/or binary data (photos, music, etc.). The fundamental components used to deal with data haven't changed too dramatically in the past few decades. They've simply improved in speed, capacity, and interface. In the current state of modern computing, data is typically input, manipulated, and returned via graphical user interfaces such as program windows, web forms displayed in browsers, and other keyboard/mouse driven "GUI"s. Data is saved on local hard drives and storage devices (CDs, thumb drives, etc.) and on remote web servers, and is typically transferred via local networks and Internet connections. Images, sounds, video, and other types of multimedia data are contained in standardized file formats, and graphic data is displayed using standard mathematical techniques. Knowing how to control those familiar computing elements to allow users to manipulate data, is the goal of learning to program. It doesn't matter whether you're interested in writing business applications to work with inventory and scheduling (text and number data), programs to alter web pages (text and image data), programs to play/edit music (binary data), programs to broadcast video across the Internet (rapidly transferred sequential frames of binary data), programs to control robotic equipment, compute scientific equations, play games, etc... They all require learning to input, manipulate, and return data of some sort. You can do all those things with REBOL, and once you've done it in one language, it's easier to do with other programming tools. REBOL allows programmers to quickly build graphic interfaces to input and return all common types of data. It can easily manipulate text, graphics, and sounds in useful ways, and it provides simple methods to save, retrieve, and share data across all types of hardware, networks, and the Internet. That makes it a great way to begin learning how to program. By learning REBOL, you'll learn about all the fundamental structures and concepts in programming: variables, functions, data types, conditional operations, loops, objects, etc. You'll also learn about important topics such as user interface design, algorithmic thinking, working with databases, the operating system API, CGI, and more. Those topics all share conceptual and technical similarities, regardless of language, and you'll need to learn to think in those terms to write computer programs, even in a language that's as easy to learn as REBOL. Despite its ease of use, REBOL is an extremely powerful tool. For years it has been used by professionals in enterprise level work around the world. You may never need to learn another programming language. If you've never done any real "programming" before, the first part of this text may seem a bit technical. Don't be put off. There is no other language with a faster learning curve than REBOL - you'll begin to see the big picture within a few days. Working through this tutorial, you'll gradually build recognition of REBOL language idioms and practical code patterns, by example. The first part of the tutorial will be a whirlwind introduction to many of the fundamental language elements. Just take it all in, and if you really want to learn, be sure to type in, or at least copy/paste, each example into the REBOL interpreter. Reading through the code isn't enough. ===A Quick Summary of the REBOL Language ---Built-In Functions and Basic Syntax As with any modern programming language, to use REBOL, you need to learn how to use "functions". Functions are words that perform actions. Function words are followed by data "parameters" (also called "arguments"). Paste these functions into the REBOL interpreter to see how they work: alert "Alert is a function. THIS TEXT IS ITS PARAMETER." request "Are you having fun yet?" editor "Edit this text." browse http://rebol.com Some functions don't require any data parameters, but do produce "return" values. Try these functions in the interpreter. They each return a value selected by the user: request-pass request-date request-color request-file The return values output by the above functions can be used in your programs to accomplish useful goals. The file name output by the "request-file" function, for example, could be used to determine which data gets opened and manipulated in your program. The data returned by the "request-pass" function can be used to control access to selected data. Many functions have optional or limited parameters/return values. These options, called "refinements", are specified by the "/" symbol. Try these variations of the "request-pass" function to see how they each perform differently: request-pass/only request-pass/user "username" request-pass/title "The 'title' refinement sets this header text." request-pass/offset/title 10x100 "'offset' repositions the requester." Some functions take multiple arguments. The "rejoin" function returns the joined ("concatenated") text arguments inside brackets. Concatenation is very important in all types of programming - you will see this function in use often: rejoin ["Hello " "there" "!"] +++Understanding Return Values and the Order of Evaluation In REBOL, you can put as many functions as you want on one line, and they are all evaluated strictly from left to right. Functions are grouped together automatically with their required data parameter(s). The following line contains two alert functions: alert "First function" alert "Second function" Rebol knows to look for one parameter after the first alert function, so it uses the next piece of data on that line as the argument for that function. Next on the line, the interpreter comes across another alert function, and uses the following text as it's data parameter. In the following line, the first function "request-pass/offset/title" requires two parameters, so REBOL uses the next two items on the line ("10x100" and "title") as its arguments. After that's complete, the interpreter comes across another "alert" function, and uses the following text, "Processing", as its argument: request-pass/offset/title 10x100 "title" alert "Processing" IMPORTANT: In REBOL, the return values (output) from one function can be used directly as the arguments (input) for other functions. Everything is simply evaluated from left to right. In the line below, the "alert" function takes the next thing on the line as it's input parameter, which in this case is not a piece of data, but a function which returns some data (the concatenated text returned by the "rejoin" function): alert rejoin ["Hello " "there" "!"] To say it another way, the value returned above by the "rejoin" function is passed to (used as a parameter by) the "alert" function. Parentheses can be used to clarify which expressions are evaluated and passed as parameters to other functions. The parenthesized line below is treated by the REBOL interpreter exactly the same as the line above - it just lets you see more clearly what data the "alert" function puts on screen: alert ( rejoin ["Hello " "there" "!"] ) Perhaps the hardest part of getting started with REBOL is understanding the order in which functions are evaluated. The process can appear to work backwords at times. In the example below, the "editor" function takes the next thing on the line as it's input parameter, and edits that text. In order for the editor function to begin its editing operation, however, it needs a text value to be returned from the "request-text" function. The first thing the user sees when this line runs, therefore, is the text requester. That appears backwards, compared to the way it's written: editor (request-text) Always remember that lines of REBOL code are evaluated from left to right. If you use the return value of one function as the argument for another function, the execution of the whole line will be held up until the necessary return value is processed. Any number of functions can be written on a single line, with return values cascaded from one function to the next: alert ( rejoin ( ["You chose: " ( request "Choose one:" ) ] ) ) The line above is typical of common REBOL language syntax. There are three functions: "alert", "rejoin", and "request". In order for the first alert function to complete, it needs a return value from "rejoin", which in turn needs a return value from the "request" function. The first thing the user sees, therefore, is the request function. After the user responds to the request, the selected response is rejoined with the text "You chose: ", and the joined text is displayed as an alert message. Think of it as reading "display (the following text joined together ("you chose" (an answer selected by the user))). To complete the line, the user must first answer the question. To learn REBOL, it's essential to first memorize and recognize REBOL's many built-in function words, along with the parameters they accept as input, and the values which they return as output. When you get used to reading lines of code as functions, arguments, and return values, read from left to right, the language will quickly begin to make sense. It should be noted that in REBOL, math expressions are evaluated from left to right like all other functions. There is no "order of precedence", as in other languages (i.e., multiplication doesn't automatically get computed before addition). To force a specific order of evaluation, enclose the functions in parentheses: print (10 + 12) / 2 ; 22 / 2 = 11 (same as without parentheses) print 10 + (12 / 2) ; 10 + 6 = 16 REBOL's left to right evaluation is simple and consistent. Parentheses can be used to clarify the flow of code, if ever there's confusion. +++White Space Unlike other languages, REBOL does not require any line terminators between expressions (functions, parameters, etc.), and you can insert empty white space (tabs, spaces, newlines, etc.) as desired into code. Text after a semicolon and before a new line is treated as a comment (ignored entirely by the interpreter). The code below works exactly the same as the previous example. Notice that tabs are used to indent the block of code inside the square brackets and that the contents of the brackets are spread across multiple lines. This helps group the code together visually, but it's not required: alert rejoin [ "You chose: " ; 1st piece of joined data (request "Choose one:") ; 2nd piece of joined data ] ONE CAVEAT: parameters for most functions should begin on the same line as the function word. The following example will not work properly because the rejoin arguments' opening brackets need to be on the same line as the rejoin function: alert rejoin ; This does NOT work. [ ; Put this bracket on the line above. "You chose: " (request "Choose one:") ] If you want to comment out a large section of code, simply surround it with curly braces: { This line doesn't do anything. This line also does nothing. This line is ignored too. } ---More Basics: Word Assignment, I/O, Files, Built-In Data Types and Native Protocols In REBOL, the colon (":") symbol is used to assign word labels ("variables") to values: person: "John" Now, the word label "person" can be used anywhere (without the colon), to represent the text "John". Notice that the variable "person" has been rejoined with some other text below: alert rejoin ["The person's name is " person] Word labels are NOT case sensitive: alert person alert PERSON alert PeRsOn ; to the REBOL interpreter, all three lines above are the same In this next example, the word "filename" is assigned to the value returned by the request-file function (a file chosen by the user): filename: request-file Now, the label "filename" can be used to represent the file selected above: alert rejoin ["You chose " filename] REBOL is a bit different from other programming languages in that word labels can be assigned to anything: numbers, text strings, binary data, arrays, lists, hash tables, functions, and even executable blocks of code. At this point, just be aware that when you see the colon symbol, a word label is being assigned to some value. The "ask" function is a simple way to get some text data from a user at the interpreter's command line (similar to "request-text", but without using a pop-up requester): ask "What is your name? " In the example below, the variable "name" is assigned to the text returned by the ask function (i.e., entered by the user). Again, the parentheses are not required - they're just there to clarify the grouping together of the 'ask' function with its text argument: name: (ask "What is your name? ") Now you can use the variable word "name" to represent whatever text the user typed in response to the above question. The "print" function is a simple way to display text data at the interpreter's command line: print rejoin ["Good to meet you " name] The "prin" function prints consecutive text elements right next to each other (not on consecutive lines): prin "All " prin "on " prin "one " print "line." print "On another." Multi-line formatted text is enclosed in curly braces ("{}"), instead of quotes: print { Line 1 Line 2 Line 3 } Quotes and curly braces can be used interchangeably on a single line: print {"text"} print "{text}" You can print a carriage return using the word "newline" or the characters ^/ print rejoin ["This text if followed by a carriage return." newline] print "This text if followed by a carriage return.^/" Clear the screen using "newpage": prin newpage The "write" function saves data to a file. It takes two parameters: a file name to write to, and some data to write to that file. write %/C/YOURNAME.txt name NOTE: in REBOL, the percent character ("%") is used to represent local files. Because REBOL can be used on many operating systems, and because those operating systems all use different syntax to refer to drives, paths, etc., REBOL uses the universal format: %/drive/path/path/.../file.ext . For example, "%/c/windows/notepad.exe" refers to "C:\Windows\Notepad.exe" in Windows. REBOL converts that syntax to the appropriate operating system format, so that your code can be written once and used on every operating system, without alteration. The following 2 functions convert REBOL file format to your operating system's format, and visa versa: to-local-file %/C/YOURNAME.txt to-rebol-file "C:\YOURNAME.txt" You can write data to a web site (or any other connected protocol) using the exact same write syntax that is used to write to a file (be sure to use an appropriate username and password for your web site ftp account): write ftp://user:pass@website.com/name.txt name The "read" function reads data from a file: print (read %/C/YOURNAME.txt) REBOL has a built-in text editor that can also read, write, and manipulate text data: editor %/c/YOURNAME.txt You can read data straight from a web server, an ftp account, an email account, etc. using the same format. Many Internet protocols are built right into the REBOL interpreter. They're understood natively, and REBOL knows exactly how to connect to them without any preparation by the programmer: editor http://rebol.com ; Reads the content of the ; document at this URL. editor pop://user:pass@website.com ; Reads all emails in this ; POP inbox. editor clipboard:// ; Reads data that has ; been copied/pasted to ; the OS clipboard. print read dns://msn.com ; Displays the DNS info ; for this address. print read nntp://public.teranews.com ; (Hit the [ESC] key to stop ; this Usenet listing.) ; NOTE: The editor reads, AND allows you to SAVE EDITS back to the server: editor ftp://user:pass@website.com/public_html/index.html Transferring data between devices connected by any supported protocol is easy - just read and write: ; read data from a web site, and paste it into the local clipboard: write clipboard:// (read http://rebol.com) ; afterward, try pasting into ; your favorite text editor ; read a page from one web site, and write it to another: write ftp://user:pass@website2.com (read http://website1.com) ; again, notice that the "write" function takes TWO parameters Sending email is just as easy, using a similar syntax: send user@website.com "Hello" send user@website.com (read %file.txt) ; sends an email, with ; file.txt as the body The "/binary" modifier is used to read or write binary (non-text) data. You'll use read/binary and write/binary to read and write images, sounds, videos and other non-text files: write/binary %/c/bay.jpg read/binary http://rebol.com/view/bay.jpg For clarification, remember that the write function takes two parameters. The first parameter above is "%/c/bay.jpg". The second parameter is the binary data read from http://rebol.com/view/bay.jpg: write/binary (%/c/bay.jpg) (read/binary http://rebol.com/view/bay.jpg) The "load" and "save" functions also read and write data, but in the process, automatically format certain data types for use in REBOL. Try this: ; assign the word "picture" to the image "load"ed from a given URL: picture: load http://rebol.com/view/bay.jpg ; save the image to a given file name, and automatically convert it ; to .png format; save/png %/c/picture.png picture ; show it in a GUI window (much more about this in the next section): view layout [image load %/c/picture.png] "Load" and "save" are used to conveniently manage certain types of data in formats directly usable by REBOL (images, sounds, DLLs, certain native data structures, etc. can be loaded and used immediately). You'll use "read" and "write" more commonly to store and retrieve typical types of data, exactly byte for byte, to/from a storage medium, when no conversion or formatting is necessary. REBOL automatically knows how to perform appropriate computations on times, dates, IP addresses, coordinate values, and other common types of data: print 3:30am + 00:07:19 ; increment time values properly print now ; print current date and time print now + 0:0:30 ; print 30 seconds from now print now - 10 ; print 10 days ago print 23x54 + 19x31 ; easily add coordinate pairs print 192.168.1.1 + 000.000.000.37 ; easily increment ip addresses view layout [image picture effect [flip]] ; apply effects to image types REBOL also natively understands how to use URLs, email addresses, files/directories, money values, tuples, hash tables, sounds, and other common values in expected ways, simply by the way the data is formatted. You don't need to declare, define, or otherwise prepare such types of data as in other languages - just use them. To determine the type of any value, use the "type?" function: some-text: "This is a string of text" ; strings of text go between type? some-text ; "quotes" or {curly braces} an-integer: 3874904 ; integer values are just pos- type? an-integer ; itive/negative whole numbers a-decimal: 7348.39 ; decimal numbers are recognized type? a-decimal ; by the decimal point web-site: http://musiclessonz.com ; URLs are recognized by the type? web-site ; http://, ftp://, etc. email-address: user@website.com ; email values are in the type? email-address ; format user@somewebsite.domain the-file: %/c/myfile.txt ; files are preceded by the % type? the-file ; character bill-amount: $343.56 ; money is preceded by the $ type? bill-amount ; symbol html-tag:
; tags are places between <> type? html-tag ; characters binary-info: #{ddeedd} ; binary data is put between type? binary-info ; curly braces and preceded by ; the pound symbol image: load http://rebol.com/view/bay.jpg ; REBOL can even automatically type? image ; recognize the data type of ; most common image formats. a-sound: load %/c/windows/media/tada.wav ; And sounds too! a-sound/type Data types can be specifically "cast" (created, or assigned to different types) using "to-(type)" functions: numbr: 4729 ; The label 'numbr now represents the integer ; 4729. strng: to-string numbr ; The label 'strng now represents a piece of ; quoted text made up of the characters ; "4729". Try adding strng + numbr, and ; you'll get an error. ; This example creates and adds two coordinate pairs. The pairs are ; created from individual integer values, using the "to-pair" function: x: 12 y: 33 q: 18 p: 7 pair1: to-pair rejoin [x "x" y] ; 12x33 pair2: to-pair rejoin [q "x" p] ; 18x7 print pair1 + pair2 ; 12x33 + 18x7 = 30x40 ; This example builds and manipulates a time value using the "to-time" ; function: hour: 3 minute: 45 second: 00 the-time: to-time rejoin [hour ":" minute ":" second] ; 3:45am later-time: the-time + 3:00:15 print rejoin ["3 hours and 15 seconds after 3:45 is " later-time] ; This converts REBOL color values (tuples) to HTML colors and visa versa: to-binary request-color to-tuple #{00CD00} REBOL has many built-in helper functions for dealing with common data types. Another way to create pair values is with the "as-pair" function. You'll see this sort of pair creation commonly in games which plot graphics at coordinate points on the screen: x: 12 y: 33 q: 18 p: 7 print (as-pair x y) + (as-pair q p) ; much simpler! Built-in network protocols, native data types, and consistent language syntax for reading, writing, and manipulating data allow you to perform common coding chores easily and intuitively in REBOL. Remember to type or paste every example into the REBOL interpreter to see how each function and language construct operates. ---GUIs (Program Windows) Graphic user interfaces ("GUI"s) are easier to create in REBOL than in any other language. The functions "view" and "layout" are used together to display GUIs. The parameters passed to the layout function are enclosed in brackets. Those brackets can include identifiers for all types of GUI elements ("widgets"): view layout [btn] ; creates a GUI with a button view layout [field] ; creates a GUI with a text input field view layout [text "REBOL is really pretty easy to program"] view layout [text-list] ; a selection list view layout [ button field text "REBOL is really pretty easy to program." text-list check ] In REBOL, widgets are called "styles", and the entire GUI dialect is called "VID". You can adjust the visual characteristics of any style in VID by following it with appropriate modifiers: view layout [ button red "Click Me" field "Enter some text here" text font-size 16 "REBOL is really pretty easy to program." purple text-list 400x300 "line 1" "line 2" "another line" check yellow ] The size of your program window can be specified by either of these two formats: view layout [size 400x300] view layout/size [] 400x300 ; both these lines do exactly the same thing A variety of functions are available to control the alignment, spacing, and size of elements in a GUI layout: view layout [ size 500x350 across btn "side" btn "by" btn "side" return btn "on the next line" tab btn "over a bit" tab btn "over more" below btn 160 "underneath" btn 160 "one" btn 160 "another" at 359x256 btn "at 359x256" ] VERY IMPORTANT: You can have widgets perform functions when clicked, or when otherwise activated. Just put the functions inside another set of brackets after the widget. This is how you get your GUIs to 'do something' (using the fundamentals introduced in the previous section): view layout [button "click me" [alert "You clicked the button."]] view layout [btn "Display Rebol.com HTML" [editor read http://rebol.com]] view layout [btn "Write current time to HD" [write %time.txt now/time]] ; The word "value" refers to data contained in a currently activated ; widget: view layout [ text "Some action examples. Try using each widget:" button red "Click Me" [alert "You clicked the red button."] field 400 "Type some text here, then press [Enter] on your keyboard" [ alert value ] text-list 400x300 "Select this line" "Then this line" "Now this one" [ alert value ] check yellow [alert "You clicked the yellow check box."] button "Quit" [quit] ] To react to right-button mouse clicks on a widget, put the functions to be performed inside a second set of brackets after the widget: view layout [ btn "Right Click Me" [alert "left click"][alert "right click"] ] You can assign keyboard shortcuts (keystrokes) to any widget, so that pressing the key reacts the same way as activating the GUI widget: view layout [ btn "Click me or press the 'A' key on your keyboard" #"a" [ alert "You just clicked the button OR pressed the 'A' key" ] ] You can assign a word label to any widget, and refer to data and properties of that widget by its label. The "text" property is especially useful: view layout [ page-to-read: field "http://rebol.com" ; page-to-read/text now refers to the text contained in that field btn "Display HTML" [editor read (to-url page-to-read/text)] ] You can also set various properties of a widget using its assigned label. When the "Edit HTML Page" button is clicked below, the text of the multi-line area widget is set to contain the text read from the given URL. The "show" function in the example below is very important. It must be used to update the GUI display any time a widget property is changed (if you ever create a GUI that doesn't seem to respond properly, the first thing to check is that you've used a "show" function to properly update any changes on screen): view layout [ page-to-read: field "http://rebol.com" the-html: area 600x440 btn "Download HTML Page" [ the-html/text: read (to-url page-to-read/text) ; try commenting out the following line to see what happens: show the-html ] ] Below are two more examples of the above code pattern (getting and setting a widget's text property) - it's a very important idiom in REBOL GUIs. In the first example, the variable "f" is assigned to the field widget, then the variable "t" is assigned to the text contained in that field. In the second example, "t" is assigned the text contained in the f1 field, then the text in f2 is set to "t" - again, all using the colon symbol. Note the use of the "show" function to update the display: view layout [ f: field btn "Display Variable" [ ; When the button is pressed, set the variable ; "t" to hold the text currently in the field ; above, then alert the contents of that variable: t: f/text alert t ] ] view layout [ f1: field btn "Display Variable" [ ; Set the variable "t" to the text contained ; in the f1 field above: t: f1/text ; Now CHANGE the text in the f2 below to ; to equal the text stored in variable "t": f2/text: t show f2 ] f2: field ] ; You GET the text from a widget by assigning a VALUE to equal the ; widget's text property. You SET/CHANGE the text of a widget by ; assigning THE TEXT PROPERTY of that widget to equal a value. The "offset" of a widget holds its coordinate position. It's another useful property, especially for GUIs which involve movement: view layout [ size 600x440 jumper: button "click me" [ jumper/offset: random 580x420 ; The "random" function creates a random value within ; a specified range. In this example, it creates a ; random coordinate pair within the range 580x420, ; every time the button is clicked. That random value ; is assigned to the position of the button. ] ] The "style" function is very powerful. It allows you to assign a specific widget definition, including all its properties and actions, to any word label you choose. Any instance of that word label is thereafter treated as a replication of the entire widget definition: view layout [ size 600x440 style my-btn btn green "click me" [ face/offset: random 580x420 ] ; "my-btn" now refers to all the above code at 254x84 my-btn at 19x273 my-btn at 85x348 my-btn at 498x12 my-btn at 341x385 my-btn ] REBOL is great at dealing with all types of common data - not just text. You can easily display photos and other graphics in your GUIs, play sounds, display web pages, etc. Here's some code that downloads an image from a web server and displays it in a GUI - notice the "view layout" functions again: view layout [image (load http://rebol.com/view/bay.jpg)] The "image" widget inside the brackets displays a picture (.bmp, .jpg, .gif., .png) in the GUI. The "load" function downloads the image to be displayed. REBOL can apply many built-in effects to images: view layout [image (load http://rebol.com/view/bay.jpg) effect [Emboss]] view layout [image (load http://rebol.com/view/bay.jpg) effect [Flip 1x1]] ; The parentheses are not required: view layout [image load http://rebol.com/view/bay.jpg effect [Grayscale]] ; There are MANY more built-in effects. You can impose images onto most types of widgets: view layout [area load http://rebol.com/view/bay.jpg] ; Use the "fit" effect to stretch or shrink the size of the image to that ; of the widget: view layout [area load http://rebol.com/view/bay.jpg effect [Fit]] view layout [button load http://rebol.com/view/bay.jpg effect [Fit]] view layout [field load http://rebol.com/view/bay.jpg effect [Fit Emboss]] ; You can still type into the field and area widgets, as usual. You can apply colors directly to images, just like any other widget. Notice that you can perform calculations directly on color values: view layout [image load http://rebol.com/view/bay.jpg yellow] view layout [image load http://rebol.com/view/bay.jpg (yellow / 2)] view layout [image load http://rebol.com/view/bay.jpg (yellow + 0.0.132)] Color gradients (fades from one color to another) are also simple to apply to any widget: view layout [area effect [gradient red blue]] view layout [ size 500x400 backdrop effect [gradient 1x1 tan brown] box effect [gradient 123.23.56 254.0.12] box effect [gradient blue gold/2] ] You can assign a word label to any layout of GUI widgets, and then display those widgets simply by using the assigned word: gui-layout1: [button field text-list] view layout gui-layout1 You can save any GUI layout as an image, using the "to-image" function. This enables a built in screen shot mechanism, and also allows you to easily create/save/manipulate new images using any of the graphic capabilities in REBOL: ; assign the label "picture" to an image of a layout: picture: to-image layout [ page-to-read: field "http://rebol.com" btn "Display HTML" ] ; save it to the hard drive as a .png file: save/png %/c/layout.png picture Here are some other GUI elements used in REBOL's "VID" layout language: view layout [ backcolor white h1 "More GUI Examples:" box red 500x2 bar: progress slider 200x16 [bar/data: value show bar] area "Type here" drop-down across toggle "Click" "Here" [print value] rotary "Click" "Again" "And Again" [print value] choice "Choose" "Item 1" "Item 2" "Item 3" [print value] radio radio radio led arrow return text "Normal" text "Bold" bold text "Italic" italic text "Underline" underline text "Bold italic underline" bold italic underline text "Serif style text" font-name font-serif text "Spaced text" font [space: 5x0] return h1 "Heading 1" h2 "Heading 2" h3 "Heading 3" h4 "Heading 4" tt "Typewriter text" code "Code text" below text "Big" font-size 32 title "Centered title" 200 across vtext "Normal" vtext "Bold" bold vtext "Italic" italic vtext "Underline" underline vtext "Bold italic underline" bold italic underline vtext "Serif style text" font-name font-serif vtext "Spaced text" font [space: 5x0] return vh1 "Video Heading 1" vh2 "Video Heading 2" vh3 "Video Heading 3" vh4 "Video Heading 3" label "Label" below vtext "Big" font-size 32 banner "Banner" 200 ] Here's a list of all the built in widgets (remember, in REBOL's VID language, widgets are called "styles"): probe extract svv/vid-styles 2 Here's a list of the changeable attributes ("facets") available to all widgets: probe remove-each i copy svv/facet-words [function? :i] And here's a list of available layout words: probe svv/vid-words NOTE: By default, all REBOL GUIs contain the text "REBOL - " in the window title bar. In Windows, you can eliminate that text with the following code. Just set the "tt" variable to hold the title text you want displayed: tt: "Your Title" user32.dll: load/library %user32.dll gf: make routine![return:[int]]user32.dll"GetFocus" sc: make routine![hw[int]a[string!]return:[int]]user32.dll"SetWindowTextA" so: :show show: func[face][so[face]hw: gf sc hw tt] That's just the tip of the iceberg. With REBOL, even absolute beginners can create nice looking, powerful graphic interfaces in minutes. See http://rebol.com/docs/easy-vid.html and http://rebol.com/docs/view-guide.html for more information. Here's a little game that demonstrates common GUI techniques (this whole program was presented earlier in the demo app, in a more compact format without any comments. It's tiny.): REBOL [] ; Here's the code presented above, to alter the Windows title bar: tt: "Tile Game" user32.dll: load/library %user32.dll gf: make routine![return:[int]]user32.dll"GetFocus" sc: make routine![hw[int]a[string!]return:[int]]user32.dll"SetWindowTextA" so: :show show: func[face][so[face]hw: gf sc hw tt] ; Create a GUI that's centered on the user's screen: view center-face layout [ ; Define some basic layout parameters. "origin 0x0" ; starts the layout in the upper left corner of the ; GUI window. "space 0x0" dictates that there's no ; space between adjacent widgets, and "across" lays ; out consecutive widgets next to each other: origin 0x0 space 0x0 across ; The section below creates a newly defined button ; style called "piece", with an action block that ; swaps the current button's position with that of ; the adjacent empty space. That action is run ; whenever one of the buttons is clicked: style piece button 60x60 [ ; The line below checks to see if the clicked button ; is adjacent to the empty space. The "offset" ; refinement contains the position of the given ; widget. The word "face" is used to refer to the ; currently clicked widget. The "empty" button is ; defined later (at the end of the GUI layout). ; It's ok that the empty button is not yet defined, ; because this code is not evaluated until the ; the entire layout is built and "view"ed: if not find [0x60 60x0 0x-60 -60x0 ] (face/offset - empty/offset) [exit] ; In English, that reads 'subtract the position of ; the empty space from the position of the clicked ; button (the positions are in the form of ; Horizontal x Vertical coordinate pairs). If that ; difference isn't 60 pixels on one of the 4 sides, ; then don't do anything.' (60 pixels is the size of ; the "piece" button defined above.) ; The next three lines swap the positions of the ; clicked button with the empty button. ; First, create a variable to hold the current ; position of the clicked button: temp: face/offset ; Next, move the button's position to that of the ; current empty space: face/offset: empty/offset ; Last, move the empty space (button), to the old ; position occupied by the clicked button: empty/offset: temp ] ; The lines below draw the "piece" style buttons onto ; the GUI display. Each of these buttons contains all ; of the action code defined for the piece style above: piece "1" piece "2" piece "3" piece "4" return piece "5" piece "6" piece "7" piece "8" return piece "9" piece "10" piece "11" piece "12" return piece "13" piece "14" piece "15" ; Here's the empty space. Its beveled edge is removed ; to make it look less like a movable piece, and more ; like an empty space: empty: piece 200.200.200 edge [size: 0] ] Advanced users may be interested in understanding why the two words "view" and "layout" are used to create GUIs. Those functions represent two complete and separate language dialects in REBOL. The "view" function is a front end to the lower level graphic compositing engine and user interface system built into REBOL. "Layout" is a higher level function that simply assembles view functions required to draw and manipulate common GUI elements. Understanding how the two operate under the hood is helpful in understanding just how deep, compact, and powerful the REBOL language and dialecting design is. For more information, see http://rebol.com/docs/view-system.html. ---Blocks, Series, and Strings In REBOL, all multiple pieces of grouped data items are stored in "blocks". Blocks are delineated by starting and ending brackets: [ ] Data items in blocks are separated by white space. Here's a block of text items: ["John" "Bill" "Tom" "Mike"] Blocks were snuck in earlier as multiple text arguments passed to the "rejoin" function, and as brackets used to delineate GUI code passed to the 'view layout' functions: rejoin ["Hello " "there!"] view layout [button "Click Me" [alert "Hello there!"]] Blocks are actually the fundamental structure used to organize REBOL code. You'll find brackets throughout the language syntax to delineate functions, parameters, and other items. In the next section of this tutorial, you'll see more about functions and control structures that use brackets to separate grouped items of code. This section will cover how data can be grouped into blocks. The key concept to understand with blocks is that they are used to hold multiple pieces of data. Like any other variable data, blocks can be assigned word labels: some-names: ["John" "Bill" "Tom" "Mike"] ; "some-names" now refers to all 4 of those text items print some-names Blocks of text data (lists) can be displayed in GUIs, using the "text-list" widget: view layout [text-list data (some-names)] The "append" function is used to add items to a block: append some-names "Lee" print some-names append gui-layout1 [text "This text was appended to the GUI block."] view layout gui-layout1 The "foreach" function is used to do something to/with each item in a block: foreach item some-names [alert item] The "remove-each" function can be used to remove items from a block that match a certain criteria: remove-each name some-names [find name "i"] ; removes all names containing the letter "i" - returns ["John" "Tom"] Empty data blocks are created with the "copy" function. "Copy" assures that blocks are erased and defined without any previous content. You'll use "copy" whenever you need to create an empty block: ; Create a new empty block like this: empty-block: copy [] ; NOT like this: empty-block: [] Here's a very typical example that uses a block to save text entered into the fields of a GUI. When the "Save" button is pressed, the text in each of the fields is appended to a new empty block, then that whole block is saved to a text file. To later retrieve the saved values, the block is loaded from the text file, and its items assigned back to the appropriate fields in the GUI: view gui: layout [ ; label some text fields: field1: field field2: field field3: field ; add a button: btn "Save" [ ; when the button is clicked, create a new empty block: save-block: copy [] ; add the text contained in each field to the block: append save-block field1/text append save-block field2/text append save-block field3/text ; save the block to a file: save %save.txt save-block alert {SAVED -- Now try running this script again, and load the data back into the fields.} ] ; another button: btn "Load" [ ; load the saved block: save-block: load %save.txt ; set the text in each field to the contents of the block: field1/text: save-block/1 field2/text: save-block/2 field3/text: save-block/3 ; update the GUI display: show gui ] ] After running the script above, open the save.txt file with a text editor, and you'll see it contains the text from the fields in the GUI. You can edit the save.txt file with your text editor, then click the "Load" button, and the edited values will appear back in the GUI. You'll use blocks regularly to store and retrieve multiple pieces of data in this way, using text files. +++Series Functions In REBOL, blocks can be automatically treated as lists of data, called "series", and manipulated using built-in functions that enable searching, sorting, and otherwise organizing the blocked data: some-names: ["John" "Bill" "Tom" "Mike"] sortednames: sort some-names ; sort alphabetically/ordinally print first sortednames ; displays the first item ("Bill") print sortednames/1 ; ALSO displays the first item ("Bill") ; (just an alternate syntax) print pick sortednames 1 ; ALSO displays the first item ("Bill") ; (another alternate syntax) find some-names "John" ; SEARCH for "John" in the block, ; set a position marker after that ; item - a very important function find/last some-names "John" ; search for "John" backwards from ; the end of the block select some-names "John" ; search for "John" in the block ; and return the Next item. reverse sortednames ; reverse the order of items in the ; block length? sortednames ; COUNT items in the block - important head sortednames ; set a position marker at the ; beginning of the block next sortednames ; set a position marker at the next ; item in the block back sortednames ; set a position marker at the ; previous item in the block last sortednames ; set a position marker at the last ; item in the block tail sortednames ; set a position marker after the ; last item in the block at sortednames x ; set a position marker at the x ; numbered item in the block skip sortednames x ; set a position marker x items ; forward or backward in the block extract sortednames 3 ; collect every third item from the ; block index? sortednames ; retrieves position number of the ; currently marked item in the block insert sortednames "Lee" ; add the name "Lee" at the current ; position in the block append sortednames "George" ; add "George" to the tail of the block ; and set position marker to the head remove sortednames ; remove the item at the currently ; marked position in the block remove find sortednames "Mike" ; ... find the "Mike" item in the ; block and remove it change sortednames "Phil" ; change the item at the currently ; marked position to "Phil" change third sortednames "Phil" ; change the third item to "Phil" poke sortednames 3 "Phil" ; another way to change the third item ; to "Phil" copy/part sortednames 2 ; get the first 2 items in the block clear sortednames ; remove all items in the block after ; the currently marked position replace/all sortednames "Lee" "Al" ; replace all occurrences of "Lee" in ; the block with "Al" both: join some-names sortednames ; concatenate both blocks together intersect sortednames some-names ; returns the items found in both ; blocks difference sortednames some-names ; returns the items that are NOT ; found in BOTH blocks exclude sortednames some-names ; returns the items in sortednames that ; are NOT also in some-names union sortednames some-names ; returns the items found in both ; blocks, ignoring duplicates unique sortednames ; returns all items in the block, ; with duplicates removed empty? sortednames ; returns true if the block is empty write %/c/names.txt some-names ; write the block to the hard drive ; as raw text data save %/c/namess.txt some-names ; write the block to the hard drive ; as native REBOL formatted code Learning to use series functions is absolutely fundamental to using REBOL. They will be covered by example throughout this text. See http://www.rebol.com/docs/dictionary.html for a list of additional series functions. For more information and examples, be sure to read sections 6 and 7 from the REBOL/Core Users Guide by Carl Sassenrath. +++REBOL Strings In REBOL, a "string" is simply a series of characters. If you have experience with other programming languages, this can be one of the sticking points in learning REBOL. REBOL's solution is actually a very powerful, easy to learn and consistent with the way other operations work in the language. Proper string management simply requires a good understanding of series. Take a look at the following examples to see how to do a few common operations: the-string: "abcdefghijklmnopqrstuvwxyz" ; Left String: (get the left 7 characters of the string): copy/part the-string 7 ; Right String: (Get the right 7 characters of the string): copy at tail the-string -7 ; Mid String 1: (get 7 characters from the middle of the string, ; starting with the 12th character): copy/part (at the-string 12) 7 ; Mid String 2: (get 7 characters from the middle of the string, ; starting 7 characters back from the letter "m"): copy/part (find the-string "m") -7 ; Mid String 3: (get 7 characters from the middle of the string, ; starting 12 characters back from the letter "t"): copy/part (skip (find the-string "t") -12) 7 ; 3 different ways to get just the 7th character: the-string/7 pick the-string 7 seventh the-string ; Change "cde" to "123" replace the-string "cde" "123" ; Several ways to change the 7th character to "7" change (at the-string 7) "7" poke the-string 7 #"7" ; the pound symbol refers to a single character poke the-string 7 (to-char "7") ; another way to use single characters print the-string ; Remove 15 characters, starting at the 3rd position: remove/part (at the-string 3) 15 print the-string ; Insert 15 characters, starting at the 3rd position: insert (at the-string 3) "cdefghijklmnopq" print the-string ; Insert 3 instances of "-+" at the beginning of the string: insert/dup head the-string "-+ " 3 print the-string ; Replace every instance of "-+ " with " ": replace/all the-string "-+ " " " print the-string ; Remove spaces from a string (type "? trim" to see all its refinements!): trim the-string print the-string ; Get every third character from the string: extract the-string 3 ; Get the ASCII value for "c" (ASCII 99): to-integer third the-string ; Get the character for ASCII 99 ("c"): to-char 99 ; Convert the above character value to a string value: to-string to-char 99 ; Convert any value to a string: to-string now to-string $2344.44 to-string to-char 99 to-string system/locale/months ; An even better way to convert values to strings: form now form $2344.44 form to-char 99 form system/locale/months ; convert blocks to nicely formed strings ; Covert strings to a block of characters: the-block: copy [] foreach item the-string [append the-block item] probe the-block REBOL's series functions are very versatile. Often, you can devise several ways to do the same thing: ; Remove the last part of a URL: the-url: "http://website.com/path" clear at the-url (index? find/last the-url "/") print the-url ; Another way to do it: the-url: "http://website.com/path" print copy/part the-url (length? the-url)-(length? find/last the-url "/") (Of course, REBOL has a built-in helper function to accomplish the above goal, directly with URLs): the-url: http://website.com/path print first split-path the-url There are a number of additional functions that can be used to work specifically with string series. Run the following script for an introduction: string-funcs: [ build-tag checksum clean-path compress debase decode-cgi decompress dehex detab dirize enbase entab import-email lowercase mold parse-xml reform rejoin remold split-path suffix? uppercase ] echo %string-help.txt ; "echo" saves console activity to a file foreach word string-funcs [ print "___________________________________________________________^/" print rejoin ["word: " uppercase to-string word] print "" do compose [help (to-word word)] ] echo off editor at read %string-help.txt 4 See http://www.rebol.com/docs/dictionary.html and http://rebol.com/docs/core23/rebolcore-8.html for more information about the above functions. +++Indentation Blocks often contain other blocks. Such compound blocks are typically indented with consecutive tab stops. Starting and ending brackets are normally placed at the same indentation level. This is conventional in most programming languages, because it makes complex code easier to read, by grouping things visually. For example, the compound block below: big-block: [[may june july] [[1 2 3] [[yes no] [monday tuesday friday]]]] can be written as follows to show the beginnings and endings of blocks more clearly: big-block: [ [may june july] [ [1 2 3] [ [yes no] [monday tuesday friday] ] ] ] probe first big-block probe second big-block probe first second big-block probe second second big-block probe first second second big-block probe second second second big-block Indentation is not required, but it's very helpful. +++More About Why/How Blocks are Useful IMPORTANT: In REBOL, blocks can contain mixed data of ANY type (text and binary items, embedded lists of items (other blocks), variables, etc.): some-items: ["item1" "item2" "item3" "item4"] an-image: load http://rebol.com/view/bay.jpg append some-items an-image ; "some-items" now contains 4 text strings, and an image! ; You can save that entire block of data, INCUDING THE BINARY ; IMAGE data, to your hard drive as a SIMPLE TEXT FILE: save/all %some-items.txt some-items ; to load it back and use it later: some-items: load %some-items.txt view layout [image fifth some-items] Take a moment to examine the example above. REBOL's block structure works in a way that is dramatically easy to use compared to other languages and data management solutions (much more simply than most database systems). It's is a very flexible, simple, and powerful way to store data in code! The fact that blocks can hold all types of data using one simple syntactic structure is a fundamental reason it's easier to use than other programming languages and computing tools. You can save/load block code to the hard drive as a simple text file, send it in an email, display it in a GUI, compress it and transfer it to a web server to be downloaded by others, transfer it directly over a point-to-point network connection, or even convert it to XML, encrypt, and store parts of it in a secure multiuser database to be accessed by other programming languages, etc... Remember, all programming, and computing in general, is essentially about storing, organizing, manipulating, and transferring data of some sort. REBOL makes working with all types of data very easy - just put any number of pieces of data, of any type, in between two brackets, and that data is automatically searchable, sortable, storable, transferable, and otherwise usable in your programs. +++Evaluating Variables in Blocks: Compose, Reduce, Pick and More You will often find that you want to refer to an item in a block by its index (position number), as in the earlier 'some-items' example: view layout [image some-items/5] You may not, however, always know the specific index number of the data item you want to access. For example, as you insert data items into a block, the index position of the last item changes (it increases). You can obtain the index number of the last item in a block simply by determining the number of items in the block (the position number of the last item in a block is always the same as the total number of items in the block). In the example below, that index number is assigned the variable word "last-item": last-item: length? some-items Now you can use that variable to pick out the last item: view layout [image (pick some-items last-item)] ; In our earlier example, with 5 items in the block, the ; line above evaluates the same as: view layout [image (pick some-items 5)] You can refer to other items by adding and subtracting index numbers: alert pick some-items (last-item - 4) There are several other ways to do the exact same thing in REBOL. The "compose" function allows variables in parentheses to be evaluated and inserted as if they'd been typed explicitly into a code block: view layout compose [image some-items/(last-item)] ; The line above appears to the interpreter as if the following ; had been typed: view layout [image some-items/5] The "compose" function is very useful whenever you want to refer to data at variable index positions within a block. The "reduce" function can also be used to produce the same type of evaluation. Function words in a reduced block should begin with the tick (') symbol: view layout reduce ['image some-items/(last-item)] Another way to use variable values explicitly is with the ":" format below. This code evaluates the same as the previous two examples: view layout [image some-items/:last-item] Think of the colon format above as the opposite of setting a variable. As you've seen, the colon symbol placed after a variable word sets the word to equal some value. A colon symbol placed before a variable word gets the value assigned to the variable, and inserts that value into the code as if it had been typed explicitly. You can use the "index?" and "find" functions to determine the index position(s) of any data you're searching for in a block: index-num: index? (find some-items "item4") Any of the previous 4 formats can be used to select the data at the determined variable position: print pick some-items index-num print compose [some-items/(index-num)] print reduce [some-items/(index-num)] ; no function words are used in the block above, so no ticks are required print some-items/:index-num Here's an example that displays variable image data contained in a block, using a foreach loop. The "compose" function is used to include dynamically changeable data (image representations), as if that data had been typed directly into the code: photo1: load http://rebol.com/view/bay.jpg photo2: load http://rebol.com/view/demos/palms.jpg ; The REBOL interpreter sees the following line as if all the code ; representing the above images had been typed directly in the block: photo-block: compose [(photo1) (photo2)] foreach photo photo-block [view layout [image photo]] Block concepts may seem a bit vague at this point. The practical application of block structures will be presented much more thoroughly, by example, throughout this tutorial, and clarification about the usefulness of blocks will come from seeing them in working code. For additional detailed information about using blocks and series functions see http://www.rebol.com/docs/core23/rebolcore-6.html. ---Conditions +++If Conditions are used to manage program flow. The most basic conditional evaluation is "if": if (this expression is true) [do this block of code] ; parentheses are not required Math operators are typically used to perform conditional evaluations: = < > <> (equal, less-than, greater-than, not-equal): if now/time > 12:00 [alert "It's after noon."] Here's an example that gets a username and password from the user, tests that data using an "if" evaluation, and alerts the user if the response is correct: userpass: request-pass/title "Type 'username' and 'password'" if (userpass = ["username" "password"]) [alert "Welcome back!"] +++Either "Either" is an if/then/else evaluation that chooses between two blocks to evaluate, based on whether the given condition is true or false. Its syntax is: either (condition) [ block to perform if the condition is true ][ block to perform if the condition is false ] For example: either now/time > 8:00am [ alert "It's time to get up!" ][ alert "You can keep on sleeping." ] userpass: request-pass either userpass = ["username" "password"] [ alert "Welcome back!" ][ alert "Incorrect user/password combination!" ] +++Switch The "switch" evaluation chooses between numerous functions to perform, based on multiple evaluations. Its syntax is: switch/default (main value) [ (value 1) [block to execute if value 1 = main value (value 2) [block to execute if value 2 = main value] (value 3) [block to execute if value 3 = main value] ; etc... ] [default block of code to execute if none of the values match] You can compare as many values as you want against the main value, and run a block of code for each matching value: favorite-day: request-text/title "What's your favorite day of the week?" switch/default favorite-day [ "Monday" [alert "Monday is the worst! The work week begins..."] "Tuesday" [alert "Tuesdays and Thursdays are both ok, I guess..."] "Wednesday" [alert "The hump day - the week is halfway over!"] "Thursday" [alert "Tuesdays and Thursdays are both ok, I guess..."] "Friday" [alert "Yay! TGIF!"] "Saturday" [alert "Of course, the weekend!"] "Sunday" [alert "Of course, the weekend!"] ] [alert "You didn't type in the name of a day!"] +++Case You can choose between multiple evaluations of any complexity using the "case" structure. If none of the cases evaluate to true, you can use any true value to trigger a default evaluation: name: "john" case [ find name "a" [print {Your name contains the letter "a"}] find name "e" [print {Your name contains the letter "e"}] find name "i" [print {Your name contains the letter "i"}] find name "o" [print {Your name contains the letter "o"}] find name "u" [print {Your name contains the letter "u"}] true [print {Your name doesn't contain any vowels!}] ] for i 1 100 1 [ case [ (0 = modulo i 3) and (0 = modulo i 5) [print "fizzbuzz"] 0 = modulo i 3 [print "fizz"] 0 = modulo i 5 [print "buzz"] true [print i] ] ] By default, the case evaluation automatically exits once a true evaluation is found (i.e., in the name example above, if the name contains more than one vowel, only the first vowel will be printed). To check all possible cases before ending the evaluation, use the /all refinement: name: "brian" found: false case/all [ find name "a" [print {Your name contains the letter "a"} found: true] find name "e" [print {Your name contains the letter "e"} found: true] find name "i" [print {Your name contains the letter "i"} found: true] find name "o" [print {Your name contains the letter "o"} found: true] find name "u" [print {Your name contains the letter "u"} found: true] found = false [print {Your name doesn't contain any vowels!}] ] +++Multiple Conditions: "and", "or", "all", "any" You can check for more than one condition to be true, using the "and", "or", "all", and "any" words: ; first set some initial values all to be true: value1: value2: value3: true ; then set some additional values all to be false: value4: value5: value6: false ; The following prints "both true", because both the first ; condition AND the second condition are true: either ( (value1 = true) and (value2 = true) ) [ print "both true" ] [ print "not both true" ] ; The following prints "both not true", because the second ; condition is false: either ( (value1 = true) and (value4 = true) ) [ print "both true" ] [ print "not both true" ] ; The following prints "either one OR the other is true" ; because the first condition is true: either ( (value1 = true) or (value4 = true) ) [ print "either one OR the other is true" ] [ print "neither is true" ] ; The following prints "either one OR the other is true" ; because the second condition is true: either ( (value4 = true) or (value1 = true) ) [ print "either one OR the other is true" ] [ print "neither is true" ] ; The following prints "either one OR the other is true" ; because both conditions are true: either ( (value1 = true) or (value4 = true) ) [ print "either one OR the other is true" ] [ print "neither is true" ] ; The following prints "neither is true": either ( (value4 = true) or (value5 = true) ) [ print "either one OR the other is true" ] [ print "neither is true" ] For comparisons involving more items, you can use "any" and "all": ; The following lines both print "yes", because ALL comparisons are true. ; "All" is just shorthand for the multiple "and" evaluations: if ((value1 = true) and (value2 = true) and (value3 = true)) [ print "yes" ] if all [value1 = true value2 = true value3 = true] [ print "yes" ] ; The following lines both print "yes" because ANY ONE of the comparisons ; is true. "Any" is just shorthand for the multiple "or" evaluations: if ((value1 = true) or (value4 = true) or (value5 = true)) [ print "yes" ] if any [value1 = true value4 = true value5 = true] [ print "yes" ] ---Loops +++Forever "Loop" structures provide programmatic ways to methodically repeat actions, manage program flow, and automate lengthy data processing activities. The "forever" function creates a simple repeating loop. Its syntax is: forever [block of actions to repeat] The following code uses a forever loop to continually check the time. It alerts the user when 60 seconds has passed. Notice the "break" function, used to stop the loop: alarm-time: now/time + :00:60 forever [if now/time = alarm-time [alert "1 minute has passed" break]] Here's a more interactive version using some info provided by the user. Notice how the forever loop, if evaluation, and alert arguments are indented to clarify the grouping of related parameters: event-name: request-text/title "What do you want to be reminded of?" seconds: to-integer request-text/title "Seconds to wait?" alert rejoin [ "It's now " now/time ", and you'll be alerted in " seconds " seconds." ] alarm-time: now/time + seconds forever [ if now/time = alarm-time [ alert rejoin [ "It's now "alarm-time ", and " seconds " seconds have passed. It's time for: " event-name ] break ] ] Here's a forever loop that displays/updates the current time in a GUI: view layout [ timer: field button "Start" [ forever [ set-face timer now/time wait 1 ] ] ] +++Loop The "loop" function allows you to repeatedly evaluate a block of code, a specified number of times: loop 50 [print "REBOL is great!"] +++Repeat Like "loop", the "repeat" function allows you to repeatedly evaluate a block of code, a specified number of times. It additionally allows you to specify a counter variable which is automatically incremented each time through the loop: repeat count 50 [print rejoin ["This is loop #: " count]] The above code does the same thing as: count: 0 loop 50 [ count: count + 1 print rejoin ["This is loop #: " count] ] +++For "For" loops allow you to control repetition patterns that involve consecutively changing values. You specify a start value, end value, incremental value, and a variable name to hold the current value during the loop. Here's the "for" loop syntax: for {variable word to hold current value} {starting value} {ending value} {incremental value} [block of code to perform, which can use the current variable value] For example: for counter 1 10 1 [print counter] ; starts on 1 and counts to 10 by increments of 1 for counter 10 1 -1 [print counter] ; starts on 10 and counts backwards to 1 by increments of -1 for counter 10 100 10 [print counter] ; starts on 10 and counts to 100 by increments of 10 for counter 1 5 .5 [print counter] ; starts on 1 and counts to 5 by increments of .5 for timer 8:00 9:00 0:05 [print timer] ; starts at 8:00am and counts to 9:00am by increments of 5 minutes for dimes $0.00 $1.00 $0.10 [print dimes] ; starts at 0 cents and counts to 1 dollar by increments of a dime for date 1-dec-2005 25-jan-2006 8 [print date] ; starts at December 12, 2005 and counts to January 25, 2006 ; and by increments of 8 days for alphabet #"a" #"z" 1 [prin alphabet] ; starts at the character a and counts to z by increments of 1 letter Notice that REBOL properly increments dates, money, time, etc. This "for" loop displays the first 5 file names in the current folder on your hard drive: files: read %. for count 1 5 1 compose [print files/(count)] Notice the "compose" word used in the for loop. "files/1" represents the first item in the file list, "files/2" represents the second, and so on. The first time though the loop, the code reads as if [print files/1] had been typed in manually, etc. The following "for" loop displays all the files in the current folder: files: read %. filecount: length? files for count 1 filecount 1 compose [print files/(count)] +++Foreach (very important!) The "foreach" function lets you easily loop through a block of data. Its syntax is: foreach {variable name referring to each consecutive item in the given block} [given block] [block of functions to be executed upon each item in the given block, using the variable name to refer to each successive item] This example prints the name of every file in the current directory on your hard drive: folder: read %. foreach file folder [print file] This line reads and prints each successive message in a user's email box: foreach mail (read pop://user:pass@website.com) [print mail] Here's a slightly more complex foreach example: ; define a block of text items: some-names: ["John" "Bill" "Tom" "Mike"] ; define a variable used to count items in the block: count: 0 ; go through each item in the block: foreach name some-names [ ; increase the counter variable by 1, for each item: count: count + 1 ; print the count number, and the associated text item: print rejoin ["Item " count ": " name] ] Here's an example in which an empty block is created and data is appended using a foreach loop. The data is then converted to a text string and displayed in a GUI: ; define a block of text items: some-names: ["John" "Bill" "Tom" "Mike"] ; create another new, empty block: data-block: copy [] ; define a variable used to count items in the block: count: 0 ; go through each item in the block: foreach name some-names [ ; increase the counter variable by 1, for each item: count: count + 1 ; for each item, add some rejoined text to the originally empty block: append data-block rejoin ["Item " count ": " name newline] ] ; convert the newly created block to a string, and show it in a ; GUI text area widget: view layout [area (to-string data-block)] You can select multiple values from a block during each iteration of a foreach loop, using the following format: users: [ "John Smith" "123 Tomline Lane Forest Hills, NJ" "555-1234" "Paul Thompson" "234 Georgetown Pl. Peanut Grove, AL" "555-2345" "Jim Persee" "345 Pickles Pike Orange Grove, FL" "555-3456" "George Jones" "456 Topforge Court Mountain Creek, CO" "" "Tim Paulson" "" "555-5678" ] ; Use the following format to get 3 consecutive values from the above ; block, each time through the loop: foreach [name address phone] users [ print rejoin [ "^/Name: " name ; gets 1 value from the block "^/Address: " address ; gets the next value from the block "^/Phone: " phone ; gets a third value from the block ] ] You will use the foreach function very often in REBOL code. It will be demonstrated many times, by example, throughout this tutorial. +++Forall and Forskip "Forall" loops through a block, incrementing the marked index number of the series as it loops through: some-names: ["John" "Bill" "Tom" "Mike"] foreach name some-names [print index? some-names] ; index doesn't change forall some-names [print index? some-names] ; index changes foreach name some-names [print name] forall some-names [print first some-names] ; same effect as line above "Forskip" works like forall, but skips through the block, jumping a periodic number of elements on each loop: some-names: ["John" "Bill" "Tom" "Mike"] forskip some-names 2 [print first some-names] +++While and Until The "while" function repeatedly evaluates a block of code while the given condition is true. While loops are formatted as follows: while [condition] [ block of functions to be executed while the condition is true ] This example counts to 5: x: 1 ; create an initial counter value while [x <= 5] [ alert to-string x x: x + 1 ] In English, that code reads: "x" initially equals 1. While x is less than or equal to 5, display the value of x, then add 1 to the value of x and repeat. Some additional "while" loop examples: while [not request "End the program now?"] [ alert "Select YES to end the program." ] ; "not" reverses the value of data received from ; the user (i.e., yes becomes no and visa versa) alert "Please select today's date" while [request-date <> now/date] [ alert rejoin ["Please select TODAY's date. It's " now/date] ] while [request-pass <> ["username" "password"]] [ alert "The username is 'username' and the password is 'password'" ] "Until" loops are similar to "while" loops. They do everything in a given block, repeatedly, until the last expression in the block evaluates to true: x: 10 until [ print rejoin ["Counting down: " x] x: x - 1 x = 0 ] The example below uses several loops to alert the user to feed the cat, every 6 hours between 8am and 8pm. It uses a for loop to increment the times to be alerted, a while loop to continually compare the incremented times with the current time, and a forever loop to do the same thing every day, continuously. Notice the indentation: forever [ for timer 8:00am 8:00pm 6:00 [ while [now/time <= timer] [wait :00:01] alert rejoin ["It's now " now/time ". Time to feed the cat."] ] ] +++ Loops in a GUI The following code template can be used to accomplish forever loops in a GUI. This technique is described in more detail later in the tutorial. For now, just know that you can insert the following "invisible box" widget template (the entire indented code for the box widget inside the view layout block), and it will perform as a continuously repeating forever loop, without interfering with the main event loop of the GUI (without holding up any other operations in the GUI - the events in this loop will run simultaneously along with other happenings in the GUI): view layout [ button [print "button pressed"] at 0x0 box 0x0 rate 0 feel [engage: func [f a e] [if a = 'time [ print "looping" ; your repeating loop code goes here ]]] ] ---User Defined Functions and Imported Code REBOL's built-in functions satisfy many fundamental needs. To achieve more complex or specific computations, you can create your own function definitions. Data and function words contained in blocks can be evaluated (their actions performed and their data values assigned) using the "do" word. Because of this, any block of code can essentially be treated as a function. That's a powerful key element of the REBOL language design: some-actions: [ alert "Here is one action." print "Here's a second action." write %/c/anotheraction.txt "Here's a third action." ] do some-actions New function words can also be defined using the "does" and "func" words. "Does" is included directly after a word label definition, and forces a block to be evaluated every time the word is encountered: more-actions: does [ alert "4" alert "5" alert "6" ] ; now to use that function, just type the word label: more-actions Here's a useful function to clear the command line screen in the REBOL interpreter. cls: does [prin "^(1B)[J"] cls The "func" word creates an executable block in the same way as "does", but additionally allows you to pass your own specified parameters to the newly defined function word. The first block in a func definition contains the name(s) of the variable(s) to be passed. The second block contains the actions to be taken. Here's the "func" syntax: func [names of variable(s) to be passed] [ actions to be taken with those variables ] This function definition: sqr-add-var: func [num1 num2] [print square-root (num1 + num2)] Can be used as follows. Notice that no brackets, braces, or parentheses are required to contain the data arguments. Data parameters simply follow the function word, on the same line of code: sqr-add-var 12 4 ; prints "4", the square root of 12 + 4 (16) sqr-add-var 96 48 ; prints "12", the square root of 96 + 48 (144) Here's a simple function to display images: display: func [filename] [view layout [image load to-file filename]] display (request-file) By default, the last value evaluated by a function is returned when the function is complete: concatenate: func [string1 string2] [join string1 string2] string3: concatenate "Hello " "there." print string3 By default, values used inside functions are treated as global, which means that if any variables are changed inside a function, they will be changed throughout the rest of your program: x: 10 change-x-globally: func [y z] [x: y + z] change-x-globally 10 20 print x You can change this default behavior, and specify that any value be treated as local to the function (not changed throughout the rest of your program), by using the "/local" refinement: x: 10 change-x-locally: func [y z /local x] [x: y + z] change-x-locally 10 20 ; inside the function, x is now 30 print x ; outside the function, x is still 10 You can specify refinements to the way a function operates, simply by preceding optional operation arguments with a forward slash ("/"): compute: func [x y /multiply /divide /subtract] [ if multiply [return x * y] if divide [return x / y] if subtract [return x - y] return x + y ] compute/multiply 10 20 compute/divide 10 20 compute/subtract 10 20 compute 10 20 The "help" function provides usage information for any function, including user defined functions: help for help compute You can include documentation for any user defined function by including a text string as the first item in it's argument list. This text is included in the description displayed by the help function: doc-demo: func ["This function demonstrates doc strings"] [help doc-demo] doc-demo Acceptable data types for any parameter can be listed in a block, and doc strings can also be included immediately after any parameter: concatenate-string-or-num: func [ "This function will only concatenate strings or integers." val1 [string! integer!] "First string or integer" val2 [string! integer!] "Second string or integer" ] [ join val1 val2 ] help concatenate-string-or-num concatenate-string-or-num "Hello " "there." ; this works correctly concatenate-string-or-num 10 20 ; this works correctly concatenate-string-or-num 10.1 20.3 ; this creates an error +++Importing Code You can "do" a module of code contained in any text file, as long as it contains the minimum header "REBOL [ ]" (this includes HTML files and any other files that can be read via REBOL's built-in protocols). For example, if you save the previous functions in a text file called "myfunctions.r": REBOL [] ; THIS HEADER TEXT MUST BE INCLUDED AT THE TOP OF ANY REBOL FILE sqr-add-var: func [num1 num2] [print square-root (num1 + num2)] display: func [filename] [view layout [image load filename]] cls: does [prin "^(1B)[J"] You can import and use them in your current code, as follows: do %myfunctions.r ; now you can use those functions just as you would any other ; native function: sqr-add-var display cls Here's an example function that plays a .wave sound file. Save this code as C:\play_sound.r: REBOL [title: "play-sound"] ; you can add a title to the header play-sound: func [sound-file] [ wait 0 ring: load sound-file sound-port: open sound:// insert sound-port ring wait sound-port close sound-port ] Then run the code below to import the function and play selected .wav files: do %/c/play_sound.r play-sound %/C/WINDOWS/Media/chimes.wav play-sound to-file request-file/file %/C/WINDOWS/Media/tada.wav Imported files can contain data definitions and any other executable code, including that which is contained in additional nested source files imported with the "do" function. Any code or data contained in a source file is evaluated when the file is "do"ne. ---Quick Review and Synopsis The list below summarizes some key characteristics of the REBOL language. Knowing how to put these elements to use constitutes a fundamental understanding of how REBOL works: # To start off, REBOL has hundreds of built-in function words that perform common tasks. As in other languages, function words are typically followed by passed parameters. Unlike other languages, passed parameters are placed immediately after the function word and are not necessarily enclosed in parenthesis. To accomplish a desired goal, functions are arranged in succession, one after another. The value(s) returned by one function are often used as the argument(s) input to another function. Line terminators are not required at any point, and all expressions are evaluated in left to right order, then vertically down through the code. Empty white space (spaces, tabs, newlines, etc.) can be inserted as desired to make code more readable. Text after a semicolon and before a new line is treated as a comment. You can complete significant work by simply knowing the predefined functions in the language, and organizing them into a useful order. # REBOL contains a rich set of conditional and looping structures, which can be used to manage program flow and data processing activities. If, switch, while, for, foreach, and other typical structures are supported. # Because many common types of data values are automatically recognized and handled natively by REBOL, calculating, looping, and making conditional decisions based upon data content is straightforward and natural to perform, without any external modules or toolkits. Numbers, text strings, money values, times, tuples, URLs, binary representations of images, sounds, etc. are all automatically handled. REBOL can increment, compare, and perform proper computations on most common types of data (i.e., the interpreter automatically knows that 5:32am + 00:35:15 = 6:07:15am, and it can automatically apply visual effects to raw binary image data, etc.). Network resources and Internet protocols (http documents, ftp directories, email accounts, dns services, etc.) can also be accessed natively, just as easily as local files. Data of any type can be written to and read from virtually any connected device or resource (i.e., "write %file.txt data" works just as easily as "write ftp://user:pass@website.com data", using the same common syntax). The percent symbol ("%") and the syntax "%(/drive)/path/path/.../file.ext" are used cross-platform to refer to local file values on any operating system. # Any data or code can be assigned a word label. The colon character (":") is used to assign word labels to constants, variable values, evaluated expressions, functions, and data/action blocks of any type. Once assigned, variable words can be used to represent all of the data and/or actions contained in the given expression, block, etc. Just put a colon at the end of a word, and thereafter it represents all the following actions and/or data. That forms a significant part of the REBOL language structure, and is the basis for it's flexible natural language dialecting abilities. # Multiple pieces of data are stored in "blocks", which are delineated by starting and ending brackets ("[]"). Blocks can contain data of any type: groups of text strings, arrays of binary data, collections of actions (functions), other enclosed blocks, etc. Data items contained in blocks are separated by white space. Blocks can be automatically treated as lists of data, called "series", and manipulated using built-in functions that enable searching, sorting, ordering, and otherwise organizing the blocked data. Data and function words contained in blocks can be evaluated (their actions performed and their data values assigned) using the "do" word. New function words can also be defined using the "does" and "func" words. "Does" forces a block to be evaluated every time its word label is encountered. The "func" word creates an executable block in the same way as "does", but additionally allows you to pass your own specified parameters to the newly defined function word. You can "do" a module of code contained in a text file, as long as it contains the minimum header "rebol[]". Blocks are also used to delineate most of the syntactic structures in REBOL (i.e., in conditional evaluations, function definitions, etc.). # The syntax "view layout [block]" is used to create basic GUI layouts. You can add graphic widgets to the layout simply by adding widget identifier words to the enclosed block: "button", "field", "text-list", etc. Color, position, spacing, and other facet words can be added after each widget identifier. Action blocks added immediately after any widget will perform the enclosed functions whenever the widget is activated (i.e., when the widget is clicked with a mouse, when the enter key pressed, etc.). Path refinements can be used to refer to items in the GUI layout (i.e., "face/offset" refers to the position of the selected widget face). Those simple guidelines can be used to create useful GUIs for data input and output, in a way that's native (doesn't require any external toolkits) and much easier than any other language. ---A Telling Comparison To provide a quick idea of how much easier REBOL is than other languages, here's a short example. The following code to create a basic program window with REBOL was presented earlier: view layout [size 400x300] It works on every type of computer, in exactly the same way. Code for the same simple example is presented below in the popular programming language "C++". It does the exact same thing as the REBOL one-liner above, except it only works in Microsoft Windows. If you want to do the same thing on a Macintosh computer, you need to memorize a completely different page of C++ code. The same is true for Unix, Linux, Beos, or any other operating system. You have to learn enormous chunks of code to do very simple things, and those chunks of code are different for every type of computer. Furthermore, you typically need to spend a semester's worth of time learning very basic things about coding format and fundamentals about how a computer 'thinks' before you even begin to tackle useful basics like the code below: #include /* Declare Windows procedure */ LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM); /* Make the class name into a global variable */ char szClassName[ ] = "C_Example"; int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil) { HWND hwnd; /* This is the handle for our window */ MSG messages; /* Here messages to the application are saved */ WNDCLASSEX wincl; /* Data structure for the windowclass */ /* The Window structure */ wincl.hInstance = hThisInstance; wincl.lpszClassName = szClassName; wincl.lpfnWndProc = WindowProcedure; /* This function is called by windows */ wincl.style = CS_DBLCLKS; /* Catch double-clicks */ wincl.cbSize = sizeof (WNDCLASSEX); /* Use default icon and mouse-pointer */ wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION); wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION); wincl.hCursor = LoadCursor (NULL, IDC_ARROW); wincl.lpszMenuName = NULL; /* No menu */ wincl.cbClsExtra = 0; /* No extra bytes after the window class */ wincl.cbWndExtra = 0; /* structure or the window instance */ /* Use Windows's default color as window background */ wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND; /* Register window class. If it fails quit the program */ if (!RegisterClassEx (&wincl)) return 0; /* The class is registered, let's create the program*/ hwnd = CreateWindowEx ( 0, /* Extended possibilites for variation */ szClassName, /* Classname */ "C_Example", /* Title Text */ WS_OVERLAPPEDWINDOW, /* default window */ CW_USEDEFAULT, /* Windows decides the position */ CW_USEDEFAULT, /* where the window ends up on the screen */ 400, /* The programs width */ 300, /* and height in pixels */ HWND_DESKTOP, /* The window is a child-window to desktop */ NULL, /* No menu */ hThisInstance, /* Program Instance handler */ NULL /* No Window Creation data */ ); /* Make the window visible on the screen */ ShowWindow (hwnd, nFunsterStil); /* Run the message loop. It will run until GetMessage() returns 0 */ while (GetMessage (&messages, NULL, 0, 0)) { /* Translate virtual-key messages into character messages */ TranslateMessage(&messages); /* Send message to WindowProcedure */ DispatchMessage(&messages); } /* The program return-value is 0 - The value that PostQuitMessage() gave */ return messages.wParam; } /* This function is called by the Windows function DispatchMessage() */ LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { switch (message) /* handle the messages */ { case WM_DESTROY: PostQuitMessage (0); /* send a WM_QUIT to the message queue */ break; default: /* for messages that we don't deal with */ return DefWindowProc (hwnd, message, wParam, lParam); } return 0; } Yuck. Back to REBOL... ===More Essential Topics ---Built-In Help and Online Resources The "help" function displays required syntax for any REBOL function: help print "?" is a synonym for "help": ? print The "what" function lists all built-in words: what Together, those two words provide a built-in reference guide for the entire core REBOL language. Here's a script that saves all the above documentation to a file. Give it a few seconds to run: echo %words.txt what echo off ; "echo" saves console activity to a file echo %help.txt foreach line read/lines %words.txt [ word: first to-block line print "___________________________________________________________^/" print rejoin ["word: " uppercase to-string word] print "" do compose [help (to-word word)] ] echo off editor at read %help.txt 4 You can use help to search for defined words and values, when you can't remember the exact spelling of the word. Just type a portion of the word (hitting the tab key will also show a list of words for automatic word completion): ? to- ; shows a list of all built-in type conversions ? reques ; shows a list of built-in requester functions ? "load" ; shows all words containing the characters "load" ? "?" ; shows all words containing the character "?" Here are some more examples of ways to search for useful info using help: ? datatype! ; shows a list of built-in data types ? function! ; shows a list of built-in functions ? native! ; shows a list of native (compiled C code) functions ? char! ; shows a list of built-in control characters ? tuple! ; shows a list of built-in colors (RGB tuples) ? .gif ; shows a list of built-in .gif images You can view the source code for built-in "mezzanine" (non-native) functions with the "source" function. There is a huge volume of REBOL code accessible right in the interpreter, and all of the mezzanine functions were created by the language's designer, Carl Sassenrath. Studying mezzanine source is a great way to learn more about advanced REBOL code patterns: source help source request-text source view source layout source ctx-viewtop ; try this: view layout [image load ctx-viewtop/13] +++The REBOL System Object, and Help with GUI Widgets "Help system" displays the contents of the REBOL system object, which contains many important settings and values. You can explore each level of the system object using path notation, like this: ? system/console/history ; the current console session history ? system/options ? system/locale/months ? system/network/host-address You can find info about all of REBOL's GUI components in "system/view/VID": ? system/view/VID The system/view/VID block is so important, REBOL has a built-in short cut to refer to it: ? svv You'll find a list of REBOL's GUI widgets in "svv/vid-styles". Use REBOL's "editor" function to view large system sections like this: editor svv/vid-styles Here's a script that neatly displays all the words in the above "svv/vid-styles" block: foreach i svv/vid-styles [if (type? i) = word! [print i]] Here's a more concise way to display the above widgets, using the "extract" function: probe extract svv/vid-styles 2 This script lets you browse the object structure of each widget: view layout [ text-list data (extract svv/vid-styles 2) [ a/text: select svv/vid-styles value show a focus a ] a: area 500x250 ] REBOL's GUI layout words are available in "svv/vid-words": ? svv/vid-words The following script displays all the images in the svv/image-stock block: b: copy [] foreach i svv/image-stock [if (type? i) = image! [append b i]] v: copy [] foreach i b [append v reduce ['image i]] view layout v The changeable attributes ("facets") available to all GUI widgets are listed in "svv/facet-words": editor svv/facet-words Here's a script that neatly displays all the above facet words: b: copy [] foreach i svv/facet-words [if (not function? :i) [append b to-string i]] view layout [text-list data b] Some GUI widgets have additional facet words available. The following script displays all such functions, and their extra attributes: foreach i (extract svv/vid-styles 2) [ x: select svv/vid-styles i ; additional facets are held in a "words" block: if x/words [ prin join i ": " foreach q x/words [ if not (function? :q) [prin join q " "] ] print "" ] ] To examine the function(s) that handle any of the additional facets for the widgets above, type the path to the widget's "words" block, i.e.: svv/vid-styles/TEXT-LIST/words For more information on system/view/VID, see http://www.mail-archive.com/rebol-bounce@rebol.com/msg01898.html and http://www.rebol.org/ml-display-message.r?m=rmlHJNC. It's important to note that you can SET any system value. Just use a colon, like when assigning variable values: system/user/email: user@website.com Familiarity with the system object yields many useful tools. +++Viewtop Resources The REBOL desktop that appears by default when you run the view.exe interpreter can be used as a gateway into a world of "Rebsites" that developers use to share useful code. Surfing the public rebsites is a great way to explore the language more deeply. All of the code in the rebol.org archive, and much more, is available on the rebsites. When typing at the interpreter console, the "desktop" function brings up the REBOL desktop (also called the "Viewtop"): desktop Click the "REBOL" or "Public" folders to see hundreds of interesting demos and useful examples. Source code for every example is available by right-clicking individual program icons and selecting "edit". You don't need a web browser or any other software to view the contents of Rebsites - the Viewtop and all its features are part of the REBOL executable. You can learn volumes about the REBOL language using only the resources built directly into the 600k interpreter! For detailed, categorized, and cross-referenced information about built-in functions, see the REBOL Dictionary rebsite, found in the REBOL desktop folder REBOL->Tools (an HTML version is also available at http://www.rebol.com/docs/dictionary.html). +++Online Documentation, The Mailing List and The AltME Community Forum If you can't find answers to your REBOL programming questions using built-in help and resources, the first place to look is http://rebol.com/docs.html. Googling online documentation also tends to provide quick results, since the word "REBOL" is uncommon. To ask a question directly of other REBOL developers, you can join the community mailing list by sending an email to rebol-request@rebol.com , with the word "subscribe" in the subject line. Use your normal email program, or just paste the following code into your REBOL interpreter (be sure your email account settings are set up correctly in REBOL): send rebol-request@rebol.com "subscribe" You can also ask questions of numerous gurus and regular users in AltME, a messaging program which makes up the most active forum of REBOL users around the world. Rebol.org maintains a searchable history of several hundred thousand posts from both the mailing list and AltME, along with a rich script archive. The REBOL user community is friendly, knowledgeable and helpful, and you will typically find answers to just about any question already in the archives. Unlike other programming communities, REBOL does not have a popular web based support forum. AltME is the primary way that REBOL developers interact. If you want to speak with others, you must download the AltME program and set up a user account (it's fast and easy to do). Just follow the instructions at http://www.rebol.org/aga-join.r. ---Saving and Running REBOL Scripts So far in this tutorial, you've been typing or copying/pasting code snippets directly into the REBOL interpreter. As you begin to work with longer examples and full programs, you'll need to save your scripts for later execution. Whenever you save a REBOL program to a text file, the code must begin with the following bit of header text: REBOL [] That header tells the REBOL interpreter that the file contains a valid REBOL program. You can optionally document any information about the program in the header block. The "title" variable in the header block is displayed in the title bar of GUI program windows: REBOL [ title: "My Program" author: "Nick Antonaccio" date: 29-sep-2009 ] view layout [text 400 center "Look at the title bar."] The code below is a web cam video viewer program. Type in or copy/paste the complete code source below into a text editor such as Windows Notepad or REBOL's built-in text editor (type "editor none" at the REBOL console prompt). Save the text as a file called "webcam.r" on your C:\ drive. REBOL [title: "Webcam Viewer"] ; try http://www.webcam-index.com/USA/ for more webcam links. temp-url: "http://209.165.153.2/axis-cgi/jpg/image.cgi" while [true] [ webcam-url: to-url request-text/title/default "Web cam URL:" temp-url either attempt [webcam: load webcam-url] [ break ] [ either request [ "That webcam is not currently available." "Try Again" "Quit" ] [ temp-url: to-string webcam-url ] [ quit ] ] ] resize-screen: func [size] [ webcam/size: to-pair size window/size: (to-pair size) + 40x72 show window ] window: layout [ across btn "Stop" [webcam/rate: none show webcam] btn "Start" [ webcam/rate: 0 webcam/image: load webcam-url show webcam ] rotary "320x240" "640x480" "160x120" [ resize-screen to-pair value ] btn "Exit" [quit] return webcam: image load webcam-url 320x240 with [ rate: 0 feel/engage: func [face action event][ switch action [ time [face/image: load webcam-url show face] ] ] ] ] view center-face window Once you've saved the webcam.r program to C:\, you can run it in any one of the following ways: # If you've already installed REBOL on your computer, just double-click your saved ".r" script file (find the C:\webcam.r file icon in your file explorer (click My Computer -> C: -> webcam.r)). By default, during REBOL's initial installation, all files with a ".r" extension are associated with the interpreter. They can be clicked and run as if they're executable programs, just like ".exe" files. The REBOL interpreter automatically opens and executes any selected ".r" text file. This is the most common way to run REBOL scripts, and it works the same way on all major graphic operating systems. If you want other people to be able to run your scripts, just have them download and install the tiny REBOL interpreter - it only takes a few seconds. # Use the built-in editor in REBOL. Type "editor %/c/webcam.r" at the interpreter prompt, or type "editor none" and copy/paste the script into the editor. Pressing F5 in the editor will automatically save and run the script. This is a convenient way to work with scripts, and enables REBOL to be its own simple, self contained IDE. # Type "do %/c/webcam.r" into the REBOL interpreter. # Scripts can be run at the command line. In Windows, copy rebol.exe and webcam.r to the same folder (C:\), then click Start -> Run, and type "C:\rebol.exe C:\webcam.r" (or open a DOS box and type the same thing). Those commands will start the REBOL interpreter and do the webcam.r code. You can also create a text file called webcam.bat, containing the text "C:\rebol.exe C:\webcam.r" . Click on the webcam.bat file in Windows, and it'll run those commands. In Unix, you can also run scripts at scheduled times with Cron. Just enter the path to the script. # Use a program such as XpackerX to package and distribute the program. XpackerX allows you to wrap the REBOL interpreter and webcam.r program into a single executable file that has a clickable icon, and automatically runs both files. That allows you to create a single file executable Windows program that can be distributed and run like any other application. Just click it and run... (this technique is covered in the next section). # Buy the commercial "SDK" version of REBOL, which provides the most secure method of packaging REBOL applications. VERY IMPORTANT: To turn off the default security requester that continually asks permission to read/write the hard drive, type "secure none" in the REBOL interpreter, and then run the program with "do {filename}". Running "C:\rebol.exe -s {filename}" does the same thing . The "-s" launches the REBOL interpreter without any security features turned on, making it behave like a typical Windows program. ---"Compiling" REBOL Programs - Distributing Packaged .EXE Files The REBOL.exe interpreter is tiny and does not require any installation to operate properly. By packaging it, your REBOL script(s), and any supporting data file(s) into a single executable with an icon of your choice, XpackerX works like a REBOL 'compiler' that produces regular Windows programs that look and act just like those created by other compiled languages. To do that, you'll need to create a text file in the following format (save it as "template.xml"): your_program_name your_program_name.exe false your_rebol_script.r your_rebol_script.r C:\Program Files\rebol\view\Rebol.exe rebol.exe $TMPRUN\rebol.exe -si $TMPRUN\your_rebol_script.r Just download the free XpackerX program and alter the above template so that it contains the filenames you've given to your script(s) and file(s), and the correct path to your REBOL interpreter. Run XpackerX, and it'll spit out a beautifully packaged .exe file that requires no installation. Your users do not need to have REBOL installed to run this type of executable. To them it appears and runs just like any other native compiled Windows program. What actually happens is that every time your packaged .exe file runs, the REBOL interpreter and your script(s)/data file(s) are unzipped into a temporary folder on your computer. When your script is done running, the temporary folder is deleted. Most modern compression (zip) applications have an "sfx" feature that allows you to create .exe packages from zip files. You can create a packaged REBOL .exe in the same way as XpackerX using just about any sfx packaging application (there are dozens of freeware zip/compression applications that can do this - use the one you're most familiar with). There is an explanation of how to use the NSIS install creator to make REBOL .exe's here. To create a self-extracting REBOL executable for Linux, first create a .tgz file containing all the files you want to distribute (the REBOL interpreter, your script(s), any external binary files, etc.). For the purposes of this example, name that bundle "rebol_files.tgz". Next, create a text file containing the following code, and save it as "sh_commands": #!/bin/sh SKIP=`awk '/^__REBOL_ARCHIVE__/ { print NR + 1; exit 0; }' $0` tail +$SKIP $0 | tar xz exit 0 __REBOL_ARCHIVE__ Finally, use the following command to combine the above script file with the bundled .tgz file: cat sh_commands rebol_files.tgz > rebol_program.sh The above line will create a single executable file named "rebol_program.sh" that can be distributed and run by end users. The user will have to set the file permissions for rebol_program.sh to executable before running it ("chmod +x rebol_program.sh"), or execute it using the syntax "sh rebol_program.sh". ---Embedding Binary Resources and Using REBOL's Built In Compression The following program can be used to encode external files (images, sounds, DLLs, .exe files, etc.) so that they can be included within the text of your program code. Use "load (data)" to make use of any text data created by this program: REBOL [Title: "Simple Binary Embedder"] system/options/binary-base: 64 file: to-file request-file/only data: read/binary file editor data The example below uses a text representation of the image at http://musiclessonz.com/test.png, encoded with the program above: picture: load 64#{ iVBORw0KGgoAAAANSUhEUgAAAFUAAABkCAIAAAB4sesFAAAAE3RFWHRTb2Z0d2Fy ZQBSRUJPTC9WaWV3j9kWeAAAAU1JREFUeJztlzEOgzAQBHkaT7s2ryZUUZoYRz4t e9xsSzTjEXIktqP3trsPcPPo7z36e4/+3qO/9y76t/qjn3766V/oj4jBb86nUyZP lM7kidKZPFE6kydq/Pjxq/nSElGv3qv50vj/o59++hNQM6Z93+P3zqefAw12Fyqh v/ToX+4Pt0ubiNKZPFE6Ux5q/O/436lkh6affvrpp38ZRT/99Ov6+f4tPPqX+8Ps /meidCZPlM7kidKZPFE6kydKZ/JE6UyeKJ3JE6UzeaJ0Jk+UzuSJ0pk8UTMmvn8L j/7l/nC7tIkonekLdXm9dafSmeinn376D/rpp5/+vv1GqBkT37+FR/9yf7hd2kSU zuSJ0pk8UTqTJ0pn8kTpTJ4onckTpTN5onQmT5TO5InSmTxROpMnasbE92/h0b/Q //jR33v09x79vUd/73XvfwNmVzlr+eOLmgAAAABJRU5ErkJggg== } view layout [image picture] The program below allows you to compress and embed files in your code. This program will be referred to many times throughout the tutorial. Save it to a .r file so that it can be run later: REBOL [Title: "Binary Resource Embedder"] system/options/binary-base: 64 file: to-file request-file/only if not file [quit] uncompressed: read/binary file compressed: compress to-string uncompressed editor compressed alert rejoin ["Uncompressed size: " length? uncompressed " bytes. Compressed size: " length? compressed " bytes."] To use the compressed version of data created by the program above, use the following code: to-binary decompress {compressed data} For example: image-compressed: load to-binary decompress 64#{ eJzrDPBz5+WS4mJgYOD19HAJAtL/GRgYdTiYgKzm7Z9WACnhEteIkuD8tJLyxKJU hiBXJ38f/bDM1PL+m2IVDAzsFz1dHEMq5ry9u3GijKcAy0Fh3kVzn/0XmRW5WXGV sUF25EOmKwrSjrrF9v89o//u+cs/IS75763Tv7ZO/5qt//p63LX1e9fEV0fu/7ap 7m0qZRIJf+2DmGZoVER5MQiz+ntzJix6kKnJ6CNio6va0Nm0fCmLQeCHLVMY1Ljm TRM64HLwMpGK/334Hf4n+vkn+1pr9md7jAVsYv+X8Z3Z+M/yscIX/j32H7sl/0j3 KK+of/CX8/X63sV1w51WqNj1763MjOS/xcccX8hzzFtXDwyXL9f/P19/f0vxz4f2 OucaHfmZDwID+P7Hso/5snw8m+qevH1030pG4kr8fhNC4f/34Z89ov+vHe4vAeut SsdqX8T/OYUCv9iblr++f67R8pp9ukzLv8YHL39tL07o+3pekn1h/dDVBgzLU/d3 9te/Lki4cNgBmA6/lO+J/RPdzty8Rr5y94/tfOxsX6/r8xJK0/UW9vlH93/9oAzR e09yKIUBVbT9/br/U/m7x6CU98VAAJS2ZPPF/197eEDhtfs9vX9rDzc6/v3qzUyo nJA/dz76Y77tHw+w3gXlbEMpDKihza/+7/o/c3+DU54tDwsobR2/fXR/qYXBiV8T t3eDEmpA/d9LDASK0y/tnz+H/Ynmt78E1vti7lAKA6pouxz/X7v+uR045ZFdRE6x 1q21pG7NiSzx1f5R40pvvdNn+oB1P4Onq5/LOqeEJgCemFy1KQgAAA== } view layout [image image-compressed] ---Running Command Line Applications The "call" function executes commands in your computer's operating system (i.e., DOS and Unix commands). The example below opens Windows' Notepad to edit the "C:\YOURNAME.txt" text file created earlier (leaving out the /show option runs the program in a hidden window): call/show "notepad.exe c:\YOURNAME.txt" This next example opens Windows' Paint program to edit an image we downloaded earlier in the tutorial: call/show "mspaint.exe c:\bay.jpg" Here's an example that embeds an executable program into the code, decompresses, and writes the program to the hard drive, and then runs it with the call function: program: load to-binary decompress 64#{ eJztF11sU2X03K4VqJsrkZJp6OzchhFJsx8qDB9od1fHdIO6ds7AgJX2jttyey/p vWUjJuNnmNhMibzwaCSLi+EBE1ziGIkBGh0BSYTwwAMme9Dk4kgkgSiKcj3nu7es QrKFhMUQOcn5+c7fd875+vXe27FJAg4AbIiGAQwWIwZMEbqTcmODN5xRdmRi6aoy Z83YogngLlaNtV+s6kV7q9KelHeu9LYqQTXt7e/v97UqLcLuqKJIvriShnAIoJ0r gXvPn+StlDAF5dyzHLwAdlw4TZ1Mm7oQvWDu7jKLslsxBc4KQ30bb9bMHF3F/D5j MFAHEIbHD+cwb88s9riSEIjvK7EKogZs//bxAvQmYlqM5JsOUwHPWFgEAYDTvqTp eYdy1Fn5Sh/O96h9nLrrDcD4IpQm7UOkWL/nt6MlqMvxrkl+GVWS7xqWalzDzqGz 9rbyD5ehpmnl+ezt3M/RSPe7Q9/ajeh5+9Ztm3vKh9xoM7SaimLUR18C2JKf+Kg2 APoJwzDOuiAF+hHU/pHXryObdLyP+y2kEhx7UaLfo0gq/RJa60/n88Ndrpz7FmqG u5bk3L8zwdWXc0+jdOYXkn4lnYfW++/qOPLyDz7BfH3jTXVnplx949inhPvnSgw/ 8RSIHM7P8PdSUYtxlxSkONE+o/u7EkNElMbpcuRKUhTjmLH/iHbDQQ7DHqL77zbh oQxeRa9duBQHkRj+HnIdr7y/e178AvmmnHt5VQAmaNo59/EZ8QSJAY7EURJvMu2x KipYj2CaEToYve2eYYiwl4rWY6jN8RWF5XtsuWSyhO7aJG8XXQFkNdWYIqIHK8nH 8FOSFJMoteEfZfQEo1SNCPCW2/BTjWK1uXkp9dDDegjrDqpkAUtiJhNp4ma3qUrx MG6dqkyFMQ2ExQmaxgU2c/07D2ZJsCz3Q68Xh76Cvac2pZwi8jCO8rIZd4jielmc uHxmsEMe1vMBZJf0YY8Pda95yH5p+tWrI86XMZbTE5a1gVlXFKyryeowp0Cy4Wf+ hdSrWGp26N008hW4XnS6/OBS7MnUVHoK0osoTV+22qF56c95qKdtZBzB66J/imSc /Rmsg/KDdHFbA9O3RrZWByD/qPf1KTCwze3y2KCbn9vnP4ExoItiwr11zvncqq6+ oXGV//XVa5qCzXxL6M3ZfBfMZyFPBvywgD3FGDjLnGVl83o4T+HJAZ/PFxWTqrcj GxerHljRqyL9sWXxqU2/nkHki1H4HDkvJeM7vZooeLdnNU2R10K34G1XdgveTmE7 vmv7fNDcFY1u3ABpNa5J6rZd9MouqGpjw6z1GLXn6vDxV/s9o1cYvcroNUanGP2J UZ3RG4zeZPQ2o3cY/YtRqCdqZ3Qho6WMuhitYHQZ0pr6mRr21Zvv03VFuuMoX0Gd VqT7BlupKFoXw8eo/8yynUR+HvEa4g3EPxEXYuwSxOWIaxADiGHEBKKGeADxCOIx a1wXkE81zH/ut0OdG0LtjQ2+hCSBzLUKWoeSyErC+pickIQgfAmhgaSG319xPEvo ioQ6Ld9D0CL04ddZQuknaxA4W1hRtXeySa0DXWM7BHjDFhHkhLUKYs2cJTcrA0H4 mmtXYgk+m1GVTBBOsVVbXJGDsNTWKexIqpqQ4aWYqgbps4LPCDFNMPcLYXQpldrC g0bcVHcKcQ220DqyB4PTHYKWScZVgCGsw/LBEgHWsjYLZR2zRTMxWZUwfaFwOAot SXVXTIuLM9V/ZeuSMw/UxW/s4KOF6W2GNjmp8Uo6rci8ImsZRVLxG+1hZWhgrlv6 /4F/ABcSIgQAEAAA } write/binary %program.exe program call/show %program.exe The "call" function has many options that allow you to monitor, control, and make use of output from external command line applications. Type "help call" into the REBOL interpreter for an introduction. For more information, see http://rebol.com/docs/shell.html. ---Responding to Special Events in a GUI - "Feel" REBOL's simple GUI syntax makes it easy for widgets to respond to mouse clicks. As you've seen, you can simply put the block of code you want evaluated immediately after the widget that activates it: view layout [btn "Click me" [alert "Thank you for the click :)"]] But what if you want your GUI to respond to events other than a mouse click directly on a widget? What if, for example, you want the program to react whenever a user clicks anywhere on the GUI screen (in a paint program, for example), or if you want a widget to do something after a certain amount of time has passed, or if you want to capture clicks on the GUI close button so that the user can't accidentally shut down an important data screen. That's what the "feel" object and "insert-event-func" function are used for. Here's an example of the basic feel syntax: view layout [ text "Click, right-click, and drag the mouse over this text." feel [ engage: func [face action event] [ print action print event/offset ] ] ] The above code is often shortened using "f a e" to represent "face action event": view layout [ text "Mouse me." feel [ engage: func [f a e] [ print a print e/offset ] ] ] You can respond to specific events as follows: view layout [ text "Mouse me." feel [ engage: func [f a e] [ if a = 'up [print "You just released the mouse."] ] ] ] This example demonstrates how to combine full screen mouse detection with normal mouse clicks on widgets. To do this, an invisible box the same size as the screen, with a feel event attached, is used for full screen detection. Then, other widgets are simply placed on top of it, starting over at the window origin: print "Click anywhere in the window, then click the text." view center-face layout [ size 400x200 box 400x200 feel [ engage: func [f a e] [ print a print e/offset ] ] origin text "Click me" [print "Text clicked"] [print "Text right-clicked"] box blue [print "Box clicked"] ] You can also assign timer events to any widget, as follows: view layout [ text "This text has a timer event attached." rate 00:00:00.5 feel [ engage: func [f a e] [ if a = 'time [print "1/2 second has passed."] ] ] ] Here's a button with a time event attached (a rate of "0" means don't wait at all). Every 0 seconds, when the timer event is detected, the offset (position) of the button is updated. This creates animation: view layout/size [ mover: btn rate 0 feel [ engage: func [f a e] [ if a = 'time [ mover/offset: mover/offset + 5x5 show mover ] ] ] ] 400x400 Here's a little shooting game that uses a timer event to automate the movement of GUI graphics around the screen, check for collisions, and control other game operations: REBOL [title: "VID Shooter"] score: 0 speed: 20 fire: false do game: [ view center-face layout [ size 600x440 at 270x0 text join "Score: " score at 280x440 x: box 2x20 yellow at (as-pair 0 (random 300) + 30) y: btn 50x20 red "Enemy" at 280x420 z: btn 50x20 blue "Player" box 0x0 #"l" [z/offset: z/offset + 10x0 show z] box 0x0 #"k" [z/offset: z/offset + -10x0 show z] box 0x0 #" " [ if fire = false [ fire: true x/offset: as-pair z/offset/1 440 ] ] box 0x0 rate speed feel [ engage: func [f a e] [ if a = 'time [ y/offset: y/offset + 5x0 if y/offset/1 > 600 [ y/offset: as-pair -10 ((random 300) + 30) ] show y if fire = true [x/offset: x/offset + 0x-20] if x/offset/2 < 0 [ x/offset/2: 440 fire: false ] show x if within? x/offset y/offset 50x25 [ alert "Kablammmm!!!" score: score + 1 speed: speed + 5 fire: false unview do game ] ] ] ] ] ] By updating the offset of a widget every time it's clicked, you can enable drag-and-drop operations: view layout/size [ text "Click and drag this text" feel [ ; remember f="face", a="action", e="event": engage: func [f a e] [ ; first, record the coordinate at which the mouse is ; initially clicked: if a = 'down [initial-position: e/offset] ; if the mouse is moved while holding down the button, ; move the position of the clicked widget the same amount ; (the difference between the initial clicked coordinate ; recorded above, and the new current coordinate determined ; whenever a mouse move event occurs): if find [over away] a [ f/offset: f/offset + (e/offset - initial-position) ] show f ] ] ] 600X440 Feel objects and event functions can be included right inside a style definition. The definition below allows you to easily create multiple GUI widgets that can be dragged around the screen. "movestyle" is defined as a block of code that's later passed to a widget's "feel" object, and is therefore included in the overall style definition (the remove and append functions have been added here to place the moved widget on top of other widgets in the GUI (i.e., to bring the dragged widget to the visual foreground)). You can add this "feel movestyle" code to any GUI widget to make it drag-able: movestyle: [ engage: func [f a e] [ if a = 'down [ initial-position: e/offset remove find f/parent-face/pane f append f/parent-face/pane f ] if find [over away] a [ f/offset: f/offset + (e/offset - initial-position) ] show f ] ] view layout/size [ style moveable-object box 20x20 feel movestyle ; "random 255.255.255" represents a different random ; color for each piece: at random 600x400 moveable-object (random 255.255.255) at random 600x400 moveable-object (random 255.255.255) at random 600x400 moveable-object (random 255.255.255) at random 600x400 moveable-object (random 255.255.255) at random 600x400 moveable-object (random 255.255.255) text "This text and all the boxes are movable" feel movestyle ] 600x440 The "detect" function inside a feel block is useful for constantly checking events. The following program constantly checks for mouse movements, and if the mouse is ever positioned over the button, the button is moved to a random position. This technique can be useful, for example, in video games controlled by mouse movement: view center-face layout [ size 600x440 at 270x209 b: btn "Click Me!" feel [ detect: func [f e] [ ; The following line checks for any mouse movement: if e/type = 'move [ ; This line checks if the mouse position is within the ; coordinates of the button (i.e., touching the button): if (within? e/offset b/offset 59x22) [ ; If so, move the button to a random position: b/offset: b/offset + ((random 50x50) - (random 50x50)) ; Check if the button has been moved off screen: if not within? b/offset -59x-22 659x462 [ ; If so, move back to the center of the window: b/offset: 270x209 ] ; Update the screen: show b ] ] ; When using the detect function, always return the event: e ] ] ] To handle global events in a GUI such as resizing and closing, "insert-event-func" is useful. The following example checks for resize events: insert-event-func [ either event/type = 'resize [ alert "I've been resized" none ; return this value when you don't want to ; do anything else with the event. ][ event ; return this value if the specified event ; is not found ] ] view/options layout [text "Resize this window."] [resize] You can use that technique to adjust the window layout, and specifically reposition widgets when a screen is resized: insert-event-func [ either event/type = 'resize [ stay-here/offset: stay-here/parent-face/size - stay-here/size - 20x20 show stay-here none ; return this value when you don't want to ; do anything else with the event. ][ event ; return this value if the specified event ; is not found ] ] view/options layout [ stay-here: text "Resize this window." ] [resize] To remove an installed event handler, use "remove-event-func". The following example captures three consecutive close events, and then removes the event handler, allowing you to close the GUI on the 4th try: count: 1 evtfunc: insert-event-func [ either event/type = 'close [ if count = 3 [remove-event-func :evtfunc] count: count + 1 none ][ event ] ] view layout [text "Try to close this window 4 times."] For more information about handling events see http://www.rebol.com/how-to/feel.html, http://www.codeconscious.com/rebol/view-notes.html, and http://www.rebol.com/docs/view-system.html. ---Common REBOL Errors, and How to Fix Them Listed below are solutions to a variety of common errors you'll run into when first experimenting with REBOL: 1) "** Syntax Error: Script is missing a REBOL header" - Whenever you "do" a script that's saved as a file, it must contain at least a minimum required header at the top of the code. Just include the following text at the beginning of the script: REBOL [] 2) "** Syntax Error: Missing ] at end-of-script" - You'll get this error if you don't put a closing bracket at the end of a block. You'll see a similar error for unclosed parentheses and strings. The code below will give you an error, because it's missing a "]" at the end of the block: fruits: ["apple" "orange" "pear" "grape" print fruits Instead it should be: fruits: ["apple" "orange" "pear" "grape"] print fruits Indenting blocks helps to find and eliminate these kinds of errors. 3) "** Script Error: request expected str argument of type: string block object none" - This type of error occurs when you try to pass the wrong type of value to a function. The code below will give you an error, because REBOL automatically interprets the website variable as a URL, and the "alert" function requires a string value: website: http://rebol.com alert website The code below solves the problem by converting the URL value to a string before passing it to the alert function: website: to-string http://rebol.com alert website Whenever you see an error of the type "expected _____ argument of type: ___ ____ ___ ...", you need to convert your data to the appropriate type, using one of the "to-(type)" functions. Type "? to-" in the REBOL interpreter to get a list of all those functions. 4) "** Script Error: word has no value" - Miss-spellings will elicit this type of error. You'll run into it any time you try to use a word that isn't defined (either natively in the REBOL interpreter, or by you, in previous code): wrod: "Hello world" print word 5) If an error occurs in a "view layout" block, and the GUI becomes unresponsive, type "unview" at the interpreter command line and the broken GUI will be closed. To restart a stopped GUI, type "do-events". To break out of any endless loop, or to otherwise stop the execution of any errant code, just hit the [Esc] key on your keyboard. 6) "** User Error: Server error: tcp 550 Access denied - Invalid HELO name (See RFC2821 4.1.1.1)" and "** User Error: Server error: tcp -ERR Login failed.", among others, are errors that you'll see when trying to send and receive emails. To fix these errors, your mail server info needs to be set up in REBOL's user settings. The most common way to do that is to edit your mail account info in the graphic Viewtop or by using the "set-net" function (http://www.rebol.com/docs/words/wset-net.html). You can also set everything manually - this is how to adjust all the individual settings: system/schemes/default/host: your.smtp.address system/schemes/default/user: username system/schemes/default/pass: password system/schemes/pop/host: your.pop.address system/user/email: your.email@site.com 7) Here's a quirk of REBOL that doesn't elicit an error, but which can cause confusing results, especially if you're familiar with other languages: unexpected: [ empty-variable: "" append empty-variable "*" print empty-variable ] do unexpected do unexpected do unexpected The line: empty-variable: "" doesn't re-initialize the variable to an empty state. Instead, every time the block is run, "empty-variable" contains the previous value. In order to set the variable back to empty, as intended, use the word "copy" as follows: expected: [ empty-variable: copy "" append empty-variable "*" print empty-variable ] do expected do expected do expected 8) Load/Save, Read/Write, Mold, Reform, etc. - another point of confusion you may run into initially with REBOL has to do with various words that read, write, and format data. When saving data to a file on your hard drive, for example, you can use either of the words "save" or "write". "Save" is used to store data in a format more directly usable by REBOL. "Write" saves data in a raw, 'unREBOLized' form. "Load" and "read" share a comparable relationship. "Load" reads data in a way that is more automatically understood and put to use in REBOL code. "Read" opens data in exactly the format it's saved, byte for byte. Generally, data that is "save"d should also be "load"ed, and data that's "write"ed should be "read". For more information, see the following REBOL dictionary entries: http://rebol.com/docs/words/wload.html http://rebol.com/docs/words/wsave.html http://rebol.com/docs/words/wread.html http://rebol.com/docs/words/wwrite.html Other built-in words such as "mold" and "reform" help you deal with text in ways that are either more human-readable or more natively readable by the REBOL interpreter. For a helpful explanation, see http://www.rebol.net/cookbook/recipes/0015.html. 9) Order of precedence - REBOL expressions are always evaluated from left to right, regardless of the operations involved. If you want specific mathematical operators to be evaluated first, they should either be enclosed in parenthesis or put first in the expression. For example, to the REBOL interpreter: 2 + 4 * 6 is the same as: (2 + 4) * 6 ; the left side is evaluated first == 6 * 6 == 36 This is contrary to other familiar evaluation rules. In many languages, for example, multiplication is typically handled before addition. So, the same expression: 2 + 4 * 6 is treated as: 2 + (4 * 6) ; the multiplication operator is evaluated first == 2 + 24 == 26 Just remember, evaluation is always left to right, without exception. 10) You may run into problems when copying/pasting interactive console scripts directly into the REBOL interpreter, especially when the code contains functions such as "ask", which require a response from the user before the remainder of the script is evaluated (each line of the script simply runs, as the pasting operation completes, without any response from the user, leaving necessary variables unassigned). To fix such interactivity problems when copying/pasting console code into the interpreter, simply wrap the entire script in square brackets and then "do" that block: do [...your full script code...]. This will force the entire script to be loaded before any of the code is evaluated. If you want to run the code several times, simply assign it a word label, and then run the word label as many times as needed: do x: [...your full script code...] do x do x do x .... This saves you from having to paste the code more than once. Another effective option, especially with large scripts, is to run the code from the clipboard using "do read clipboard://". This performs much faster than watching large amounts of text paste into the console. +++Trapping Errors There are several simple ways to keep your program from crashing when an error occurs. The words "error?" and "try" together provide a way to check for and handle expected error situations. For example, if no Internet connection is available, the code below will crash abruptly with an error: html: read http://rebol.com The adjusted code below will handle the error more gracefully: if error? try [html: read http://rebol.com] [ alert "Unavailable." ] The word "attempt" is an alternative to the "error? try" routine. It returns the evaluated contents of a given block if it succeeds. Otherwise it returns "none": if not attempt [html: read http://rebol.com] [ alert "Unavailable." ] To clarify, "error? try [block]" evaluates to true if the block produces an error, and "attempt [block]" evaluates to false if the block produces an error. For a complete explanation of REBOL error codes, see: http://www.rebol.com/docs/core23/rebolcore-17.html. ===EXAMPLE PROGRAMS - Learning How All The Pieces Fit Together The examples in this section demonstrate how REBOL code is put together to create complete programs. The code is heavily commented to provide line-by-line explanations of how each element works. The recommended way to run the examples is to install REBOL on your computer, paste the code for each program into a text editor, save the code file as "(program_name).r" and then double click the icon for the text file you've created. With REBOL installed, any file with a ".r" extension will automatically run as if it's an .exe program. Downloadable Windows executables and screen shots of these examples are available at: http://musiclessonz.com/rebol_tutorial/examples Be sure to check out the hundreds of additional code examples available directly from rebsites on the desktop of the REBOL interpreter! ---Little Email Client The first example is a complete graphical email client that can be used to read and send messages: ; Every program requires a minimum header: REBOL [Title: "Little Email Client"] ; The line below creates the program's GUI window: view layout [ ; This line adds a text label to the GUI: h1 "Send Email:" ; This line adds a button to the GUI: btn "Server settings" [ ; When the button is clicked, the following lines are run. ; These lines set all the email user account information ; required to send and receive email. The settings are gotten ; from the user with the "request-text" function, and assigned ; to their appropriate locations in REBOL's system object: system/schemes/default/host: request-text/title "SMTP Server:" system/schemes/pop/host: request-text/title "POP Server:" system/schemes/default/user: request-text/title "SMTP User Name:" system/schemes/default/pass: request-text/title "SMTP Password:" system/user/email: to-email request-text/title "Your Email Addr:" ] ; This line creates a text entry field, containing the default text ; "recipient@website.com". The variable word "address" is assigned to ; this widget: address: field "recipient@website.com" ; Heres another text entry field, for the email subject line: subject: field "Subject" ; This line creates a larger, multi-line text entry area for the body ; text of the email: body: area "Body" ; Here's a button displaying the word "send". The functions inside ; its action block are executed whenever the button is clicked: btn "Send" [ ; This line does most of the work. It uses the REBOL "send" ; function to send the email. The send function, with its ; "/subject" refinement accepts three parameters. It's passed the ; current text contained in each field labeled above (referred to ; as "address/text" "body/text" and "subject/text"). The ; "to-email" function ensures that the address text is treated as ; an email data value: send/subject (to-email address/text) body/text subject/text ; This line alerts the user when the previous line is complete: alert "Message Sent." ] ; Here's another text label: h1 "Read Email:" ; Here's another text entry field. The user's email account info is ; entered here. mailbox: field "pop://user:pass@site.com" ; This last button has an action block that reads messages from a ; specified mailbox. It only takes one line of code: btn "Read" [ ; The "to-url" function ensures that the text in the mailbox field ; is treated as a URL. The contents of the mailbox are read and ; displayed using REBOL's built-in text editor: editor read to-url mailbox/text ] ] Here's the same code, without comments - it's very simple. Try pasting it directly into the REBOL interpreter: REBOL [Title: "Little Email Client"] view layout [ h1 "Send Email:" btn "Server settings" [ system/schemes/default/host: request-text/title "SMTP Server:" system/schemes/pop/host: request-text/title "POP Server:" system/schemes/default/user: request-text/title "SMTP User Name:" system/schemes/default/pass: request-text/title "SMTP Password:" system/user/email: to-email request-text/title "Your Email Addr:" ] address: field "recipient@website.com" subject: field "Subject" body: area "Body" btn "Send" [ send/subject to-email address/text body/text subject/text alert "Message Sent." ] h1 "Read Email:" mailbox: field "pop://user:pass@site.com" btn "Read" [ editor read to-url mailbox/text ] ] ---Simple Web Page Editor The following program can be used to load, edit, and save HTML files (or any other text file) directly to/from a live web server or to/from a drive on your local computer. It requires 14 lines of code: REBOL [Title: "Web Page Editor"] ; required header ; Create a GUI window: view layout [ ; Here's a text entry field containing a generic URL address for ; the page to be edited. The label "page-to-read" is assigned to ; this widget: page-to-read: field 600 "ftp://user:pass@website.com/path/page.html" ; Here's a multi-line text field to hold and edit the HTML ; downloaded from the above URL. The label "the-html" is assigned ; to it: the-html: area 600x440 ; The "across" words lays out the next buttons on the same line: across ; Here's a button to download and display the HTML at the URL given ; above: btn "Download HTML Page" [ ; When the button is clicked, read the HTML at the URL above, ; insert it into the multi-line text area (by setting the text ; property of that field to the downloaded text), and update the ; display: the-html/text: read (to-url page-to-read/text) show the-html ] ; Here's another button to read and display text from a local file: btn "Load Local HTML File" [ ; When the button is clicked, read the HTML from a file selected ; by the user, insert it into the multi-line text area, and update ; the display: the-html/text: read (to-file request-file) show the-html ] ; Here's another button. When clicked, the edited contents of the ; multi-line text area are saved back to the URL: btn "Save Changes to Web Site" [ write (to-url page-to-read/text) the-html/text ] ; Here's another button to write the edited contents of the multi- ; line text area to a local file selected by the user: btn "Save Changes to Local File" [ write (to-file request-file/save) the-html/text ] ] ---Card File This is the quintessential simple text field storage application. It can be used as shown here, to save contact information, but by adjusting just a few lines of code and text labels, it could be easily adapted to store recipes, home inventory information, or any other type of related pages of data. REBOL [title: "Card File"] ; The line below writes a new empty data file to the hard drive, if it ; doesn't already exist. If the file DOES already exist, then this ; function simply writes an empty string to it (i.e., leaves the file ; alone): write/append %data.txt "" ; This line loads all saved records from the database file: database: load %data.txt ; Here's the GUI window: view center-face gui: layout [ ; Here's a text label to instruct the user: text "Load an existing record:" ; This text list displays an alphabetically sorted list of the ; names found in the database (every forth item). The number ; pair indicates the widget's pixel size: name-list: text-list blue 400x100 data (sort extract database 4) [ ; The following line is included to avoid potential errors. ; When an item in the text list is clicked, we first check that ; the selected data (represented by the word "value") is NOT ; equal to nothing. If so, exit the widget's action block ; (the "return" word quits the text-list's action routine): if value = none [return] ; The following code finds the selected name in the loaded ; database. The display fields in the GUI are then set ; to show the found name, and each of the 3 items after ; it in the database (name = field 1, address = field 2, ; phone = field 3, notes = field 4): marker: index? find database value n/text: pick database marker a/text: pick database (marker + 1) p/text: pick database (marker + 2) o/text: pick database (marker + 3) ; Update the display to show the changed text fields (notice ; the "gui" label defined above - it refers to the entire GUI ; layout): show gui ] ; Here are the text display fields, and some text labels to show ; what should be typed into each field: text "Name:" n: field 400 text "Address:" a: field 400 text "Phone:" p: field 400 text "Notes:" o: area 400x100 ; The "across" word adds widgets to the GUI next to one another, ; instead of beneath one another, which is the default behavior ; (the following 3 buttons will appear next to each other): across ; Here's a GUI button to let the user save the contents of the ; text fields to the database: btn "Save" [ ; When this button is clicked, make sure the required field ; contains some text. If not, notify the user, and then exit ; this button's routine (the "return" word quits the save ; button's action block): if n/text = "" [alert "You must enter a name." return] ; Now run through every forth item in the database to check if ; the name already exists. If so, give the user the option to ; overwrite that record. If they respond yes, delete the old ; record from the database ("remove/part" deletes 4 items at ; the location where the selected name is found). If the user ; responds no, escape out of the save button's routine: if find (extract database 4) n/text [ either true = request "Overwrite existing record?" [ remove/part (find database n/text) 4 ] [ return ] ] ; Now update the database with the new data, and write it to ; the hard drive. The "repend" function appends the evaluated ; variables inside the brackets (in this case a block of 4 ; separate text strings contained in the GUI fields) to the ; database: save %data.txt repend database [n/text a/text p/text o/text] ; Update the text-list to show the added record: name-list/data: sort (extract copy database 4) show name-list ] ; This button allows the user to clear the screen and enter a ; new record: btn "Delete" [ ; When this button is clicked, the code below gives the user ; the option to delete the selected record. If the user ; selects "yes", the "remove/part" function deletes 4 items ; from the database, at the location where the selected name ; is found. The database is saved, and the text fields are ; cleared ("do-face" runs the action block of the ; "clear-button" widget above, to clear the GUI fields), then ; the name list is updated: if true = request rejoin ["Delete " n/text "?"] [ remove/part (find database n/text) 4 save %data.txt database do-face clear-button 1 name-list/data: sort (extract copy database 4) show name-list ] ] clear-button: btn "New" [ ; When this button is clicked, set the text of each field to an ; empty string: n/text: copy "" a/text: copy "" p/text: copy "" o/text: copy "" ; As always, when any on data in the GUI is changed, the ; screen must be updated: show gui ] ] Here's the whole program, without comments: REBOL [title: "Card File"] write/append %data.txt "" database: load %data.txt view center-face gui: layout [ text "Load an existing record:" name-list: text-list blue 400x100 data sort (extract database 4) [ if value = none [return] marker: index? find database value n/text: pick database marker a/text: pick database (marker + 1) p/text: pick database (marker + 2) o/text: pick database (marker + 3) show gui ] text "Name:" n: field 400 text "Address:" a: field 400 text "Phone:" p: field 400 text "Notes:" o: area 400x100 across btn "Save" [ if n/text = "" [alert "You must enter a name." return] if find (extract database 4) n/text [ either true = request "Overwrite existing record?" [ remove/part (find database n/text) 4 ] [ return ] ] save %data.txt repend database [n/text a/text p/text o/text] name-list/data: sort (extract copy database 4) show name-list ] btn "Delete" [ if true = request rejoin ["Delete " n/text "?"] [ remove/part (find database n/text) 4 save %data.txt database do-face clear-button 1 name-list/data: sort (extract copy database 4) show name-list ] ] clear-button: btn "New" [ n/text: copy "" a/text: copy "" p/text: copy "" o/text: copy "" show gui ] ] ---Little Menu Example A module that produces full blown menus with all the bells and whistles is available at http://www.rebol.org/library/scripts/menu-system.r (covered later in this tutorial). Here's a simpler homemade example that can be included in your programs to provide basic menu functionality. It's constructed using only raw, native REBOL GUI components: REBOL [Title: "Simple Menu Example"] ; "center-face" centers the GUI window: view center-face gui: layout [ size 400x300 at 100x100 H3 "You selected:" display: field ; Here's the menu. Make sure it goes AFTER other GUI code. ; If you put it before other code, the menu will appear be- ; hind other widgets in the GUI. The menu is basically just ; a text-list widget, which is initially hidden off-screen ; at position -200x-200. When an item in the list is ; clicked upon, the action block for the text-list runs ; through a conditional switch structure, to decide what to ; do for the chosen item. The code for each option first ; re-hides the menu by repositioning it off screen (at ; -200x-200 again). For use in your own programs, you can ; put as many items as you want in the list, and the action ; block for each item can perform any actions you want. ; Here, each option just updates the text in the "display" ; text entry field, created above. Change, add to, or ; delete the "item1" "item2" and "quit" elements to suit ; your needs: origin 2x2 space 5x5 across at -200x-200 file-menu: text-list "item1" "item2" "quit" [ switch value [ "item1" [ face/offset: -200x-200 show file-menu ; PUT YOUR CODE HERE: set-face display "File / item1" ] "item2" [ face/offset: -200x-200 show file-menu ; PUT YOUR CODE HERE: set-face display "File / item2" ] "quit" [quit] ] ] ; The menu initially just appears as some text choices at ; the top of the GUI. When the "File" menu is clicked, ; the action block of that text widget repositions the ; text-list above, so that it appears directly underneath ; the File menu ("face/offset" is the location of the ; currently selected text widget). It disappears when ; clicked again - the code checks to see if the text-list ; is positioned beneath the menu. If so, it repositions ; it out of sight. at 2x2 text bold "File" [ either (face/offset + 0x22) = file-menu/offset [ file-menu/offset: -200x-200 show file-menu ][ file-menu/offset: (face/offset + 0x22) show file-menu ] ] ; Here's an additional top level menu option. It provides ; just a single choice. Instead of opening a text-list ; widget with multiple options, it simply ensures that the ; other menu is closed (re-hidden), and then runs some code. text bold "Help" [ file-menu/offset: -200x-200 show file-menu ; PUT YOUR CODE HERE: set-face display "Help" ] ] ---Loops and Conditions - A Simple Data Storage App One of the most important applications of loop structures is to step through lists of data. By stepping through elements in a block, loops can be used to process and perform actions on each item in a given data series. This technique is used in all types of programming, and it's a cornerstone of the way programmers think about working with tables of data (such as those found in databases). Because many programs work with lists of data, you'll very often come across situations that require the use of loops. Thinking about how to put looping structures to use is a fundamental part of learning to write code in any language. The example below demonstrates several ways in which you'll see loops commonly put to use. REBOL [title: "Loops and Conditions - a Simple Data Storage App"] ; First, a small user database is defined. It's organized ; into a block structure: the "users" block contains 5 ; blocks, which each contain 5 items of information for ; each user. Blank items are represented with empty quotes. users: [ ["John" "Smith" "123 Toleen Lane" "Forest Hills, NJ" "555-1234"] ["Paul" "Thompson" "234 Georgetown Pl." "Peanut Grove, AL" "555-2345"] ["Jim" "Persee" "345 Portman Pike" "Orange Grove, FL" "555-3456"] ["George" "Jones" "456 Topforge Court" "Mountain Creek, CO" ""] ["Tim" "Paulson" "" "" "555-5678"] ] ; This program does not have a GUI. Instead, it's a text ; based "console" program. Since there's no GUI, we need ; to format the output so that it's got a nice layout on the ; screen. Here's a little function that uses a loop to draw ; a line. It prints 65 dashes next to each other, and then ; a carriage return. We'll use those lines to help print ; nicely formatted output: draw-line: does [loop 65 [prin "-"] print ""] ; Note that this is not the most efficient way to draw a line ; of characters, because the program needs to run through ; the loop every time a line is drawn. You'll see some ; flicker on the screen every time this happens, because ; the computer has to run through the "prin" function 65 ; times for each line. Although it only takes a fraction of ; a second on a modern computer, it's still quite noticeable. ; It would be faster, instead, to build a block of characters ; once, and then print that block, as follows: ; ; a-line: copy [] ; loop 65 [append a-line "-"] ; ; remove the spaces and turn it ; ; into a string of characters: ; a-line: trim to-string a-line ; ; now you can print "a-line" ; ; anywhere you need it: ; print a-line ; ; The inefficient code above is left in this example to ; demonstrate a point about how the coding thought process ; can dramatically effect the performance of programs you ; create. That's especially true for programs that perform ; complex loops on large lists of data. The more efficient ; line printing function is implemented in another example ; following this one, to demonstrate the difference in its ; effectiveness. ; Next is a small function that prints out all of the data ; in the database. It uses a foreach loop to cycle through ; each block of user data, and then it prints a line ; displaying each element in the block (items numbered 1-5 ; in each block). This creates a nicely formatted display: print-all: does [ foreach user users [ draw-line print rejoin ["User: " user/1 " " user/2] draw-line print rejoin ["Address: " user/3 " " user/4] print rejoin ["Phone: " user/5] print newline ] ] ; The following code uses a forever loop to continually ; request a choice from the user. It uses several foreach ; loops to pull information from the data block, and a ; conditional "switch" structure to decide how to respond ; to the user's request. The "switch" inside a forever ; loop is a common design in command line programs: forever [ ; First, print some nice formatting and display info: prin "^(1B)[J" ; this code clears the screen. print "Here are the current users in the database:^/" ; The "^/" at the end of the line above prints a newline. draw-line ; run the function defined above ; Now print the list of user names. A foreach loop is ; used to get the first and last name of each user in the ; database. The first name is item 1 in each block, and ; the last name is item 2 in each block. So for each ; block in the database, "user/1" and "user/2" are ; printed: foreach user users [prin rejoin [user/1 " " user/2 " "]] print "" draw-line ; print some instructions: prin "Type the name of a user below " print "(part of a name will perform search):^/" print "Type 'all' for a complete database listing." print "Press [Enter] to quit.^/" ; Now ask the user for a choice: answer: ask {What person would you like info about? } print newline ; Decide what to do with the user's response: switch/default answer [ ; If they typed "all", execute the "print-all" ; function defined earlier: "all" [print-all] ; If they typed the [Enter] key alone (""), print a ; goodbye message, and end the program. Note that ; "ask" is used to display the message, instead of ; "print". This allows the program to wait for the ; user to press a key before ending the program: "" [ask "Goodbye! Press [Enter] to end." quit] ; If neither of the choices above were selected, the ; default block below is executed (this is the last ; part of the switch structure): ][ ; This section starts by creating a "flag" variable, ; which is used to track whether or not the user's ; choice has been found in the database - the word ; "found" is initially set to false to indicate that ; the user name has not yet been found: found: false ; Next, a foreach loop steps through each user block ; in the database: foreach user users [ ; If the entered user name is found in the ; database (either the first or last name), the ; info for that user is printed out in a nicely ; formatted display, and the "found" flag is set ; to true. The "rejoin" action is used to join ; the first name and last name, and is used in ; conjunction with the "find" action to check ; whether the user's answer matches any part of ; the names in the database (when you run this ; code, try entering single characters, or a ; part of a name, to see what happens). if find rejoin [user/1 " " user/2] answer [ draw-line print rejoin ["User: " user/1 " " user/2] draw-line print rejoin ["Address: " user/3 " " user/4] print rejoin ["Phone: " user/5] print newline found: true ] ] ; If the "found" variable is still false after ; looping through the entire user database, then the ; user name was not found in the database. Print a ; message to that effect: if found <> true [ ; "<>" means "not equal to" print "That user is not in the database!^/"] ] ; Wait for a user response, and then continue again at ; the beginning of the forever loop: ask "Press [ENTER] to continue" ] Here's the entire program without the comments. Try to follow the program flow on your own. NOTE: In this version, the inefficient "draw-line" function is replaced by the suggested "print a-line" routine above. As a result, you'll see a dramatic reduction in screen flicker: Rebol [] users: [ ["John" "Smith" "123 Tomline Lane" "Forest Hills, NJ" "555-1234"] ["Paul" "Thompson" "234 Georgetown Pl." "Peanut Grove, AL" "555-2345"] ["Jim" "Persee" "345 Pickles Pike" "Orange Grove, FL" "555-3456"] ["George" "Jones" "456 Topforge Court" "Mountain Creek, CO" ""] ["Tim" "Paulson" "" "" "555-5678"] ] a-line: copy [] loop 65 [append a-line "-"] a-line: trim to-string a-line print-all: does [ foreach user users [ print a-line print rejoin ["User: " user/1 " " user/2] print a-line print rejoin ["Address: " user/3 " " user/4] print rejoin ["Phone: " user/5] print newline ] ] forever [ prin "^(1B)[J" print "Here are the current users in the database:^/" print a-line foreach user users [prin rejoin [user/1 " " user/2 " "]] print "" print a-line prin "Type the name of a user below " print "(part of a name will perform search):^/" print "Type 'all' for a complete database listing." print "Press [Enter] to quit.^/" answer: ask {What person would you like info about? } print newline switch/default answer [ "all" [print-all] "" [ask "Goodbye! Press any key to end." quit] ][ found: false foreach user users [ if find rejoin [user/1 " " user/2] answer [ print a-line print rejoin ["User: " user/1 " " user/2] print a-line print rejoin ["Address: " user/3 " " user/4] print rejoin ["Phone: " user/5] print newline found: true ] ] if found <> true [ print "That user is not in the database!^/" ] ] ask "Press [ENTER] to continue" ] For some perspective, here's a GUI version of the same program that demonstrates how GUI and command line programming styles differ. Notice how much of the data handling is managed by the built-in GUI tools in the language, rather than by homemade loops: REBOL [title: "Loops and Conditions - Data Storage App - GUI Example"] users: [ ["John" "Smith" "123 Tomline Lane" "Forest Hills, NJ" "555-1234"] ["Paul" "Thompson" "234 Georgetown Pl." "Peanut Grove, AL" "555-2345"] ["Jim" "Persee" "345 Pickles Pike" "Orange Grove, FL" "555-3456"] ["George" "Jones" "456 Topforge Court" "Mountain Creek, CO" ""] ["Tim" "Paulson" "" "" "555-5678"] ] user-list: copy [] foreach user users [append user-list user/1] user-list: sort user-list view display-gui: layout [ h2 "Click a user name to display their information:" across list-users: text-list 200x400 data user-list [ current-info: [] foreach user users [ if find user/1 value [ current-info: rejoin [ "FIRST NAME: " user/1 newline newline "LAST NAME: " user/2 newline newline "ADDRESS: " user/3 newline newline "CITY/STATE: " user/4 newline newline "PHONE: " user/5 ] ] ] display/text: current-info show display show list-users ] display: area "" 300x400 wrap ] ---FTP Chat Room This example is a simple chat application that lets users send instant text messages back and forth across the Internet. It includes password protected access for administrators to erase chat contents. It also allows users to pause activity momentarily, and requires a username/password to continue ["secret" "password"]. The chat "rooms" are created by dynamically creating, reading, appending, and saving text files via ftp (to use the program, you'll need access to an available ftp server: ftp address, username, and password. Nothing else needs to be configured on the server). REBOL [title: "FTP Chat Room"] ; The following line gets the URL of a text file on the user's web server ; to use for the chat. The ftp username, password, domain, and filename ; must be entered in the format shown: webserver: to-url request-text/title/default { URL of text file on your server:} "ftp://user:pass@site.com/chat.txt" ; The following line gets the user's name: name: request-text/title "Enter your name:" ; In the following line, the word "cls" is assigned to a function ; definition which clears the screen: cls: does [prin "^(1B)[J"] ; The following line writes some text to the webserver file (obtained ; above), indicating that the user has entered the chat. The "/append" ; refinement adds to the existing text in the webserver file (as opposed ; to erasing what's already there). Using "rejoin", the text written to ; the webserver is the combined value of the user's name, some static ; text, the current date and time, and a carriage return: write/append webserver rejoin [now ": " name " has entered the room.^/"] ; Now the program uses a "forever" loop to continually wait for user ; input, and to do appropriate things with that input: forever [ ; First, read the messages that are currently in the "webserver" text ; file, and assign the variable word "current-chat" to that text: current-chat: read webserver ; Clear the screen using the function word defined above: cls ; Display a greeting and some instructions: print rejoin [ "--------------------------------------------------" newline {You are logged in as: } name newline {Type "room" to switch chat rooms.} newline {Type "lock" to pause/lock your chat.} newline {Type "quit" to end your chat.} newline {Type "clear" to erase the current chat.} newline {Press [ENTER] to periodically update the display.} newline "--------------------------------------------------" newline ] print rejoin ["Here's the current chat text at: " webserver newline] print current-chat ; In the line below, the "ask" function is used to get some text from ; the user. The returned text (the text entered by the user) is ; assigned the label "entered-text", and concatenated with the user's ; name and the text " says: ". This prepares it to be added to the ; webserver file and displayed in the chat. Notice that the user ; must first respond to the "ask" function, before the rejoin ; evaluation can occur: sent-message: copy rejoin [ name " says: " entered-text: ask "You say: " ] ; The "switch" structure below is used to check for commands in the ; text entered by the user. If the user enters "quit", "clear", ; "room", or "lock", appropriate actions occur: switch/default entered-text [ ; If the user typed "quit", stop the forever loop (exit the ; program): "quit" [break] ; If the user typed "clear", erase the current text chat. But ; first, ask user for the administrator username/password (using ; the "request-pass" function): "clear" [ ; "if/else" does the same thing as "either" (deprecated): if/else request-pass = ["secret" "password"] [ write webserver "" ] [ alert { You must know the administrator password to clear the room! } ] ] ; If the user typed "room", request a new FTP address, and run ; some code that was presented earlier in the program, using the ; newly entered "webserver" variable, to effectively change chat ; "rooms": "room" [ ; Add a message the chat file, indicating that the user has ; left the chat: write/append webserver rejoin [ now ": " name " has left the room." newline ] ; Get the URL of a new chat text file (the new room address). ; Use the old address as the default displayed URL: webserver: to-url request-text/title/default { New Web Server Address:} to-string webserver ; Display a message in the newly chosen chat text file, ; showing that the user has entered the chat: write/append webserver rejoin [ now ": " name " has entered the room." newline ] ] "lock" [ ; Display a message to the user that the program will be ; paused: alert {The program will now pause for 5 seconds. You'll need the correct username and password to continue. } ; Assign a variable to the time 5 seconds from now: pause-time: now/time + 5 ; Don't go on until the user gets the password right: forever [ ; First, wait 5 seconds: if now/time = pause-time [ ; The while loop below continually asks the user for ; a password, until correct: while [ request-pass <> ["secret" "password"] ][ alert "Incorrect password - look in the source!" ] ; After the user has entered the correct username and ; password, exit the forever loop and continue with ; the program: break ] ] ] ][ ; The following line is the default case for the switch structure: ; as long as the entered message is not blank ([Enter]), write the ; entered message to the web server (append it to the current chat ; text): if entered-text <> "" [ write/append webserver rejoin [sent-message newline] ] ] ] ; When the "forever" loop is exited, do the following: cls print "Goodbye!" write/append webserver rejoin [now ": " name " has closed chat." newline] wait 1 The bulk of this program runs within the "forever" loop, and uses the conditional "switch" structure to decide how to respond to user input (as in the "Loops and Conditions - A Simple Data Storage App" example). This is a classic outline that can be adjusted to match a variety of generalized situations in which the computer repeatedly waits for and responds to user interaction at the command prompt. ---Image Effector The next application creates a GUI interface, downloads and displays an image from the Internet, allows you to apply effects to it, and lets you save the effected image to the hard drive. In the mix, there are several routines which get data, and alert the user with text information. ; A header is still required, even if a title isn't included: REBOL [] ; The following line creates a short list of image effects that are built ; into REBOL, and assigns the variable word "effect-types" to the block: effect-types: [ "Invert" "Grayscale" "Emboss" "Blur" "Sharpen" "Flip 1x1" "Rotate 90" "Tint 83" "Contrast 66" "Luma 150" "None" ] ; The code below imports the simple "play-sound" function created earlier ; in the tutorial. For this to work correctly, the play_sound.r file ; should be saved to C:\. The either condition checks to see if the file ; exists. If so, it runs the code and sets a variable that we'll use ; later to decide whether or not to play a sound. If the file doesn't ; exist, the variable is simply set to false: either exists? %/c/play_sound.r [ do %/c/play_sound.r sound-available: true ][ sound-available: false ] ; The line below asks user for the URL of a new image (with a default ; location), and assigns that address to the word "image-url": image-url: to-url request-text/title/default { Enter the URL of an image to use:} trim { http://rebol.com/view/demos/palms.jpg} ; Now a GUI block will be constructed, to be display later using ; "view layout": gui: [ ; This first line horizontally aligns all the following GUI widgets, ; so they appear next to each other in the layout (the default ; behavior in REBOL is to align elements vertically): across ; This line changes the spacing of consecutive widgets so they're on ; top of each other: space -1 ; The following code displays the program menu, using a "choice" ; button widget (a menu-select type of button built into REBOL). ; The button is 160 pixels across, and is placed at the uppermost, ; leftmost pixel in the GUI (0x0) using the built-in word "at". at 20x2 choice 160 tan trim { Save Image} "View Saved Image" "Download New Image" trim { -------------} "Exit" [ ; This is the action block for the choice selector. It contains ; various functions to be performed, based on the choice selected ; by the user. Conditional "if" evaluations are used to determine ; which actions to perform. This could have been done with less ; code, using a "switch" structure. "If" was used, however, to ; demonstrate that there are always alternate ways to express ; yourself in code - just like in spoken language: if value = "Save Image" [ ; Request a filename to save the image as (defaults to ; "c:\effectedimage.png"): filename: to-file request-file/title/file/save trim { Save file as:} "Save" %/c/effectedimage.png ; Save the image to hard drive: save/png filename to-image picture ] if value = "View Saved Image" [ ; Request a file name from the user (defaults to ; "c:\effectedimage.png"): view-filename: to-file request-file/title/file { View file:} "" %/c/effectedimage.png ; Read the selected image from the hard drive and ; display it in a new GUI window: view/new center-face layout [image load view-filename] ] if value = "Download New Image" [ ; Ask for the location of a new image, and assign the entered ; URL the word label "new-image": new-image: load to-url request-text/title/default trim { Enter a new image URL} trim { http://www.rebol.com/view/bay.jpg} ; Replace the old image with the new one: picture/image: new-image ; Update the GUI display: show picture ] if value = "-------------" [] ; don't do anything if value = "Exit" [ ; If the variable we set earlier indicates that sound is ; available, play a little closing sound: if sound-available = true [ play-sound %/c/windows/media/tada.wav ] ; Exit the program: quit ] ] ; Here's another choice button which simply displays a little "about" ; message: choice tan "Info" "About" [ alert "Image Effector - Copyright 2005, Nick Antonaccio" ] ; The following line vertically aligns all successive GUI widgets - ; the opposite of "across": below ; Spread out the following widgets by 5 pixels: space 5 ; Put 2 pixels of blank space before the next widget: pad 2 ; This box widget draws a line 550 pixels wide, 1 pixel tall (just a ; cosmetic separator): box 550x1 white ; Put some more space before the next widget: pad 10 ; Here's a big text header for the GUI: vh1 "Double click each effect in the list on the right:" ; Advance to the next row in the GUI, and then begin arranging ; successive widgets across the screen again: return across ; Load the image entered at the beginning of the program, and give it ; a label: picture: image load image-url ; The code below creates a text-list widget and assigns a block of ; actions to it, to be run whenever the user clicks on an item in the ; list. The first line assigns the word "current-effect" to the value ; which the user has selected from the list. The second line applies ; that effect to the image (the words "to-block" and "form" are ; required for the way effects are applied syntactically. The third ; line displays the newly effected image. The "show" word is _very_ ; important. It needs to be used whenever a GUI element is updated: text-list data effect-types [ current-effect: value picture/effect: to-block form current-effect show picture ] ] ; The following line displays the gui block above. "/options [no title]" ; displays the window without a title bar (so it can't be moved around), ; and "center-face" centers the window on the screen: view/options center-face layout gui [no-title] ---Guitar Chord Diagram Maker This program creates, saves, and prints collections of guitar chord fretboard diagrams. It demonstrates some common and useful file, data, and GUI manipulation techniques, including the drag-and-drop "feel" technique, used here to slide the pieces around the screen. It also demonstrates the very important technique of printing output to HTML, and then previewing in a browser (to be printed on paper, uploaded to a web site, etc.). This is a useful cross-platform technique that can be used to view and print formatted hard copies of REBOL data: REBOL [Title: "Guitar Chord Diagram Maker"] ; Load some image files which have been embedded using the "binary ; resource embedder" script from earlier in the tutorial: fretboard: load 64#{ iVBORw0KGgoAAAANSUhEUgAAAFUAAABkCAIAAAB4sesFAAAACXBIWXMAAAsTAAAL EwEAmpwYAAAA2UlEQVR4nO3YQQqDQBAF0XTIwXtuNjfrLITs0rowGqbqbRWxEEL+ RFU9wJ53v8DN7Gezn81+NvvZXv3liLjmPX6n/4NL//72s9l/QGbWd5m53dbc8/kR uv5RJ/QvzH42+9nsZ7OfzX62nfOPzZzzyNUxxh8+qhfVHo94/rM49y+b/Wz2s9nP Zj+b/WzuX/cvmfuXzX42+9nsZ7OfzX4296/7l8z9y2Y/m/1s9rPZz2Y/m/vX/Uvm /mWzn81+NvvZ7Gezn8396/4l2/n+y6N/f/vZ7Gezn81+tjenRWXD3TC8nAAAAABJ RU5ErkJggg== } barimage: load 64#{ iVBORw0KGgoAAAANSUhEUgAAAEoAAAAFCAIAAABtvO2fAAAACXBIWXMAAAsTAAAL EwEAmpwYAAAAHElEQVR4nGNsaGhgGL6AaaAdQFsw6r2hDIa59wCf/AGKgzU3RwAA AABJRU5ErkJggg== } dot: load 64#{ iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAIAAAACUFjqAAAACXBIWXMAAAsTAAAL EwEAmpwYAAAAFElEQVR4nGNsaGhgwA2Y8MiNYGkA22EBlPG3fjQAAAAASUVORK5C YII= } ; The following lines define the GUI design. The routine below was ; defined in the section about "feel": movestyle: [ engage: func [f a e] [ if a = 'down [ initial-position: e/offset remove find f/parent-face/pane f append f/parent-face/pane f ] if find [over away] a [ f/offset: f/offset + (e/offset - initial-position) ] show f ] ] ; With that defined, adding "feel movestyle" to any widget makes it ; movable within the GUI. It's very useful for all sorts of graphic ; applications. If you want to pursue building graphic layouts that ; respond to user events, learning all about how "feel" works in REBOL ; is very important. See the URL above for more info. gui: [ ; Make the GUI background white: backdrop white ; Show the fretboard image, and resize it (the saved image is ; actually only 85x100 pixels): currentfretboard: image fretboard 255x300 ; Show the bar image, resize it, and make it movable. Notice the ; "feel movestyle". Thats' what enables the dragging: currentbar: image barimage 240x15 feel movestyle ; Some text instructions: text "INSTRUCTIONS:" underline text "Drag dots and other widgets onto the fretboard." across text "Resize the fretboard:" ; "tab" aligns the next GUI element with a predefined column spacer: tab ; The rotary button below lets you select a size for the fretboard. ; In the action block, the fretboard image is resized, and then the ; bar image is also resized, according to the value chosen. This ; keeps the bar size proportioned correctly to the fretboard image. ; After each resize, the GUI is updated to actually display the ; changed image. The word "show" updates the GUI display. This ; needs to be done whenever a widget is changed within a GUI. Be ; aware of this - not "show"ing a changed GUI element is an easily ; overlooked source of errors: rotary "255x300" "170x200" "85x100" [ currentfretboard/size: to-pair value show currentfretboard switch value [ "255x300" [currentbar/size: 240x15 show currentbar] "170x200" [currentbar/size: 160x10 show currentbar] "85x100" [currentbar/size: 80x5 show currentbar] ] ] return ; The action block of the button below requests a filename from the ; user, and then saves the current fretboard image to that filename: button "Save Diagram" [ filename: to-file request-file/save/file "1.png" save/png filename to-image currentfretboard ] tab ; The action block of the button below prints out a user- ; selected set of images to an HTML page, where they can be ; viewed together, uploaded the Internet, sent to a printer, ; etc. button "Print" [ ; Get a list of files to print: filelist: sort request-file/title "Select image(s) to print:" ; Start creating a block to hold the HTML layout to be printed, ; and give it the label "html": html: copy "" ; This foreach loop builds an HTML layout that displays each of ; the selected images: foreach file filelist [ append html rejoin [ {} ] ] ; The following line finishes the HTML layout: append html [] ; Now the variable "html" contains a complete HTML document that ; can be written to the hard drive and opened in the default ; browser. The code below accomplishes that: write %chords.html trim/auto html browse %chords.html ] ] ; Each of the following loops puts 50 movable dots onto the GUI, all at ; the same locations. This creates three stacks of dots that the user ; can move around the screen and put onto the fretboard. There are three ; sizes to accommodate the resizing feature of the fretboard image. ; Notice the "feel movestyle" code at the end of each line. Again, ; that's what makes the each of the dots dragable: loop 50 [append gui [at 275x50 image dot 30x30 feel movestyle]] loop 50 [append gui [at 275x100 image dot 20x20 feel movestyle]] loop 50 [append gui [at 275x140 image dot 10x10 feel movestyle]] ; The following loops add some additional dragable widgets to the GUI: loop 6 [append gui [at 273x165 text "X" bold feel movestyle]] loop 6 [append gui [at 273x185 text "O" bold feel movestyle]] view layout gui ---Shoot-Em-Up Video Game This is a very simple graphic shoot-em-up which demonstrates important concepts required to make many types of 2D video games: REBOL [title: "VID Shooter"] ; First, we'll set some initial values for variables that will be used ; throughout the game. The "random/seed now/time" function ensures that ; random generated numbers will be truly random: score: 0 speed: 10 lives: 5 fire: false random/seed now/time ; This line provides the user with some instructions: alert "[SPACE BAR: fire] | [K: move left] | [L: move right]" ; When certain events occur, we'll want to reload a completely fresh ; game screen. A simple way to do that is to label the entire section ; of GUI code, unview the existing GUI, and then run that entire section ; of code again. Here, we'll label the section "game", and run it ; initially with the "do" function. You could also use this technique ; to implement a "play again" feature, for example. To do that, you'd ; Simply wrap the entire program in a block, label it, and "do" it at ; the very beginning of the code. To play again, just do the label ; again: do game: [ ; Here's the game window: view center-face layout [ ; Set some layout properties: size 600x440 backdrop black ; Display a simple text scoreboard: at 246x0 info: text tan rejoin ["Score: " score " Lives: " lives] ; For this game we'll use some generic buttons and boxes for ; graphics, but we could just as easily use images of any type ; (simply embed the images in code using the binary embedder ; program, label each image, and then use the "image" word to ; display them). In the code below, the yellow box labeled "x" ; is the missile, the orange button labeled "y" is the moving ; target being shot at, and the blue button labeled "z" is the ; player's graphic. Notice that the target graphic is placed at ; an initial coordinate 50 pixels off to the left of the GUI, ; and at a random height between 30 and 330 pixels. The ; "as-pair" function combines the two numbers into a coordinate: at 280x440 x: box 2x20 yellow at (as-pair -50 (random 300) + 30) y: btn 50x20 orange at 280x420 z: btn 50x20 blue ; The following boxes are invisible, as a result of their "0x0" ; size. They exist here solely to perform actions when certain ; keys are pressed by the user (each box has a separate key ; assigned - their action blocks will execute whenever those ; keys are pressed by the user). Notice that when the box ; assigned to the "l" key is activated, it moves the player ; graphic 10 pixels to the right. The "k" key moves the player ; left, and the space bar is used to set some variables that ; will be used below to fire a missile: box 0x0 #"l" [z/offset: z/offset + 10x0 show z] box 0x0 #"k" [z/offset: z/offset + -10x0 show z] box 0x0 #" " [ ; The "fire" variable is used to track whether or not ; a missile is currently in the air. When the space ; bar is pressed by the user, the following code is ; only run when a missile ISN'T currently moving: if fire = false [ ; Set the missile currently firing flag to true: fire: true ; Set the missile position to be centered on the ; player graphic, at the bottom of the screen: x/offset: as-pair (z/offset/1 + 25) 440 ] ] ; This box is also invisible. It's only purpose is to enable a ; feel-engage-time routine. The box has a rate set to our ; "speed" variable, and the feel-engage routine checks for a ; given amount of time to pass. Every time that occurs (the ; number of times per second indicated by the "speed" variable), ; the enclosed block of code is run. In effect, this works ; exactly like a forever loop, but WITHOUT stopping any of the ; other operations in the game: box 0x0 rate speed feel [ engage: func [f a e] [ if a = 'time [ ; If the "fire" variable is currently set to true, ; move the missile up 30 pixels: if fire = true [x/offset: x/offset + 0x-30] ; If the missile reaches the top of the screen, ; move it back down to the bottom (out of sight ; below the bottom edge of the GUI), and set ; the flag variable to false so that it stops ; moving: if x/offset/2 < 0 [x/offset/2: 440 fire: false] ; Update the display: show x ; The code below moves the target piece. The ; randow X and Y portions of the coordinate move ; the graphic generally from left to right, but ; in a slightly unpredictable path that is a bit ; harder to shoot at: y/offset: y/offset + as-pair ((random 20) - 5) ((random 10) - 5) ; Check if the target has made it all the way over ; to the right side of the screen: if y/offset/1 > 600 [ ; If so, decrease the number of lives by one: lives: lives - 1 ; If no more lives are available, notify the user ; and end the game: if lives = 0 [ alert join "GAME OVER!!! Final Score: " score quit ] ; Otherwise, notify the user and refresh the ; screen (this automatically updates the score ; board and resets the graphics to new starting ; positions): alert "-1 Life!" unview do game ] ; Update the display: show y ; Now that the graphics have been moved, check for ; a collision between the missile and the target ; (if the target and missile starting points are ; within the specified distance): if within? x/offset (y/offset - 5x5) 60x30 [ ; If a collision has occured, notify the user, ; adjust the score and speed, set the fire ; flag to false, and refresh the game screen: alert "Ka-blammmm!!!" score: score + 1 speed: speed + 5 fire: false unview do game ] ] ] ] ] ] Here's an even simpler game which demonstrates many of the same techniques. The point of the game is to catch the falling blocks. Move the player's piece left/right using the "O" and "P" keys. One point is added for each caught block. One point is subtracted for each missed block. Play as long as you'd like, and try to get the highest score. Speed can be adjusted manually using the "W" and "Q" keys: REBOL [title: "Catch"] alert "Arrow keys move left/right (up: faster, down: slower)" random/seed now/time speed: 11 score: 0 view center-face layout [ size 600x440 backdrop white across at 270x0 text "Score:" t: text bold 100 (form score) at 280x20 y: btn 50x20 orange at 280x420 z: btn 50x20 blue key keycode [left] [z/offset: z/offset - 10x0 show z] key keycode [right] [z/offset: z/offset + 10x0 show z] key keycode [up] [speed: speed + 1] key keycode [down] [if speed > 1 [speed: speed - 1]] box 0x0 rate 0 feel [engage: func [f a e] [if a = 'time [ y/offset: y/offset + (as-pair 0 speed) show y if y/offset/2 > 440 [ y/offset: as-pair (random 550) 20 show y score: score - 1 ] if within? z/offset (y/offset - 50x0) 100x20 [ y/offset: as-pair (random 550) 20 show y score: score + 1 ] t/text: (form score) show t ]]] ] ---Blogger This program allows users to create and add entries to an online blog page. The GUI has text fields which allow the user to enter a title, link, and blog text, as well as a button to select an image file which will be uploaded and included in the blog entry. When the "Upload" button is clicked, an HTML file is created and uploaded to the user's web server, along with the image. Be sure to edit the ftp-url and html-url variables to represent actual user account information. REBOL [title: "Blogger"] ; Store the blog file name in a variable: page: "blog.html" ; Store the FTP account address, with username and password: ftp-url: ftp://user:pass@site.com/public_html/folder/ ; Store the blog's web page URL in a variable: html-url: join http://site.com/folder/ page ; Create a 1 pixel blank image to upload, for when the user ; doesn't want to upload any image for a given blog entry: save/png %dot.png to-image layout/tight [box white 1x1] ; Here's the GUI: view center-face gui: layout [ ; Display the blog URL in the GUI (the "form" function converts ; the URL data type created above, to a string data type required ; by the h2 widget): h2 (form html-url) ; Here's a descriptive header and a text entry field where the user ; can enter a title for the blog. The field is labeled by the ; variable word "t": text "Title:" t: field 400 ; Header and entry field for a URL link to be included in the blog: text "Link:" l: field 400 ; Header and selection button for an image to be included in the ; blog. When the button is clicked, a file requestor pops up. The ; button's text is set to display the selected file name: text "Image:" i: btn 400 [i/text: request-file show i] ; Header and text entry field for the blog text: text "Text:" x: area 400x100 ; Layout all the following widgets across the screen: across ; Here's the GUI button which does most of the work: btn "Upload" [ ; When the button is clicked, first try to read the existing ; blog text (HTML source). If it's readable, assign that data ; the variable label "existing-text". If it's not readable, ; create the folder and an empty blog file on the FTP server, ; then assign the "existing-text" variable an emptry string: if error? try [existing-text: read html-url] [ make-dir ftp-url write (join ftp-url page) "" existing-text: copy "" ] ; Assign the variable word "picture" to the image file name ; chosen above ("last split-path" trims off the directory path ; portion of the file name (i.e., %/C/folder/myimage.jpg would ; be trimmed to %myimage.jpg)): picture: last split-path to-file i/text ; Write the image to the FTP server: write/binary (join ftp-url picture) (read/binary to-file i/text) ; Write the following rejoined HTML to the blog file on the FTP ; server: write (join ftp-url page) rejoin [ ; First add the title, enclosed in "h1" tags: {

} t/text {

} ; Now add a link to the uploaded picture, followed by 2 ; HTML line break tags: {

} ; Add the date and time, followed by 5 spaces, no line breaks: now/date { } now/time {     } ; Add a link tag (because there were no line breaks above, ; this link appears on the same line as the date and time in ; the blog), followed by 2 line breaks: {} l/text {

} ; Put the blog text inside a table which takes up 80% of the ; screen. Center the table on the screen (so it's indented). ; Use the "pre" tag to make sure that the text is formatted ; exactly the way it was typed in by the user (with carriage ; returns and spaces as entered into the area widget above), ; and use the "strong" tag to bold the text. Follow that ; entire section of HTML with a line break and then a ; "horizontal rule" tag (a separator line): {
}
                    x/text 
                {

} ; Add the previously existing blog HTML below the new entry: existing-text ] ; After the blog has been updated, open the blog URL in the ; browser: browse html-url ] ; Add a GUI button to open the blog URL in the browser: btn "View" [browse html-url] ; This GUI button allows the user to edit the existing blog file ; (the HTML data created by this program), using REBOL's built in ; text editor. Remember that REBOL's editor has the ability to ; read and SAVE data directly to/from FTP files, so this editor ; enables the user to actually edit and MAKE CHANGES to the blog ; file on the FTP server: btn "Edit" [editor (join ftp-url page)] ] Here's the whole program, without comments: REBOL [title: "Blogger"] page: "blog.html" ftp-url: ftp://user:pass@site.com/public_html/folder/ html-url: join http://site.com/folder/ page save/png %dot.png to-image layout/tight [box white 1x1] ; blank image view center-face gui: layout [ h2 (form html-url) text "Title:" t: field 400 text "Link:" l: field 400 text "Image:" i: btn 400 [i/text: request-file show i] text "Text:" x: area 400x100 across btn "Upload" [ if error? try [existing-text: read html-url] [ make-dir ftp-url write (join ftp-url page) "" existing-text: copy "" ] picture: last split-path to-file i/text write/binary (join ftp-url picture) (read/binary to-file i/text) write (join ftp-url page) rejoin [ {

} t/text {

} {

} now/date { } now/time {     } {} l/text {

} {
}
                    x/text 
                {

} existing-text ] browse html-url ] btn "View" [browse html-url] btn "Edit" [editor (join ftp-url page)] ] ---Listview Multi Column Data Grid Example This example uses the listview module found at http://www.hmkdesign.dk/rebol/list-view/list-view.r. The listview module handles all the main work of displaying, sorting, filtering, altering, and manipulating data, with a familiar user interface that's easy to program. Documentation is available at http://www.hmkdesign.dk/rebol/list-view/list-view.html. Clicking on a column header in the example below sorts the data by the selected column, ascending or descending. Clicking the diamond in the upper right hand corner returns the data to its unsorted order. Selecting a row of data with the mouse allows each cell to be edited directly. Because inline editing is possible, no additional GUI widgets are required for data input/output. That makes the listview module a very powerful tool which is useful in a wide variety of situations. REBOL [title: "Listview Data Grid"] ; The function below watches for the GUI close button, to keep ; the program from being shut down accidentally. The code was ; adjusted from an example at: ; http://www.rebolforces.com/view-faq.html evt-close: func [face event] [ either event/type = 'close [ inform layout [ across Button "Save Changes" [ ; when the save button is clicked, a backup data ; file is automatically created: backup-file: to-file rejoin ["backup_" now/date] write backup-file read %database.db save %database.db theview/data quit ] Button "Lose Changes" [quit] Button "CANCEL" [hide-popup] ] none ] [ event ] ] insert-event-func :evt-close ; Download and import/run ("do") the list-view.r module: if not exists? %list-view.r [write %list-view.r read http://www.hmkdesign.dk/rebol/list-view/list-view.r ] do %list-view.r ; The following conditional evaluation checks to see if a ; database file exists. If not, it creates a file with ; some empty blocks: if not exists? %database.db [write %database.db {[][]}] ; Now the stored data is read into a variable word: database: load %database.db ; Here's the guts of the program. Be sure to read the ; list-view documentation to see how the widget works. view center-face gui: layout [ h3 {To enter data, double-click any row, and type directly into the listview. Click column headers to sort:} theview: list-view 775x200 with [ data-columns: [Student Teacher Day Time Phone Parent Age Payments Reschedule Notes] data: copy database tri-state-sort: false editable?: true ] across button "add row" [theview/insert-row] button "remove row" [ if (to-string request-list "Are you sure?" [yes no]) = "yes" [ theview/remove-row ] ] button "filter data" [ filter-text: request-text/title trim { Filter Text (leave blank to refresh all data):} if filter-text <> none [ theview/filter-string: filter-text theview/update ] ] button "save db" [ backup-file: to-file rejoin ["backup_" now/date] write backup-file read %database.db save %database.db theview/data ] ] This example downloads the list-view module from the Internet, and then imports it from the hard drive. The following lines require that there is either an Internet connection available, or that the list-view.r module already exists on the user's hard drive: if not exists? %list-view.r [write %list-view.r read http://www.hmkdesign.dk/rebol/list-view/list-view.r ] do %list-view.r If you want to use the list-view.r module in a script, without having to download it or include it a separate file (so that no external dependencies are required to run the script), you can replace the above lines with the following code. The following code is the list-view.r file, compressed using "compress read http://www.hmkdesign.dk/rebol/list-view/list-view.r": do decompress #{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} ---Thumbnail Maker This program resizes and arranges a list of image files into a single preview image. The screen shot image sheet at the beginning of this tutorial was created using this application. REBOL [Title: "Thumbnail Maker"] ; Create a little GUI to allow the user to adjust image settings: view center-face layout [ text "Resize input images to this height:" height: field "200" text "Create output mosaic of this width:" width: field "600" text "Space between thumbnails:" padding-size: field "30" text "Color between thumbnails:" btn "Select color" [background-color: request-color/color white] text "Thumbnails will be displayed in this order:" the-images: area across btn "Select images" [ ; Select some files: some-images: request-file/title trim/lines {Hold down the [CTRL] key to select multiple images:} "" ; Error check: if some-images = none [return] ; Show the selected files in the area widget above, with ; each file on a new line: foreach single-image some-images [ append the-images/text single-image append the-images/text "^/" ] show the-images ] ; This button creates the output thumbnail mosaic: btn "Create Thumbnail Mosaic" [ ; Set sizing variables to the values entered in the GUI: y-size: to-integer height/text mosaic-size: to-integer width/text padding: to-integer padding-size/text ; Set the background color (white if none selected): if error? try [background-color: to-tuple background-color][ background-color: white ] ; The list of images that will be resized is stored in a block ; labeled "images". The "parse" function is covered later in ; this tutorial. The following code simply separates each line ; item in the text area above, and returns a block of all the ; items: images: copy parse/all the-images/text "^/" ; Error check: if empty? images [alert "No images selected." break] ; The output image will be created from a "view layout" GUI block. ; That block will be labeled "mosaic" and will contain all the ; resized image data and layout formatting needed to create the ; thumbnail image. We'll start building that block by ; including the background color, spacing, and "across" words ; needed to layout the GUI. Because the block contains some ; variables, we'll use the "compose" function to evaluate them ; (treat them as if they'd been typed in explicitly): mosaic: compose [ backcolor (background-color) space (padding) across ] ; Next, we'll use a foreach loop to go through the list of images, ; read and resize each image, and add the resized image data to ; the mosaic block. The variable "picture" will be used to refer ; to each image as the loop progresses through each item in the ; list: foreach picture images [ ; Give the user some feedback with a litte message: flash rejoin ["Resizing " picture "..."] ; Read the image data, and assign it the variable label ; "original": original: load to-file picture ; After the data is done loading, erase the message above: unview ; We can refer to the size of the original image using the ; format "orginal/size". That returns width and height ; values in the form of an XxY pair. To refer to the height ; (Y) value only, we can use the format "original/size/2" ; (the second element in the pair). If the height of the ; original image is larger than the "y-size" variable set at ; the beginning of the program, we'll resize the image so ; it fits that height, and append the resized image data to ; the "mosaic" block. Otherwise, we'll simply append the ; orginal image to the block. We're also going to include ; the "image" word, because the "mosaic" block needs to ; include all the functions and data needed to create a view ; layout GUI window: ; If the original image is taller than the prescribed height: either original/size/2 > y-size [ ; Figure a percentage amount the width needs to be ; resized: new-x-factor: y-size / original/size/2 ; Calculate the width of the new image size, and assign ; that value to the variable "new-x-size": new-x-size: round original/size/1 * new-x-factor ; Create the resized image by using the "layout" function ; (as in "view layout"). Specify a new size for the ; image by rejoining the "new-x-size" variable above with ; the "y-size" value specified earlier, and convert that ; value to a pair. Create a new image from that layout ; using the "to-image" function, and assign it to the ; variable "new-image": new-image: to-image layout/tight [ image original as-pair new-x-size y-size ] ; Next, append the resized image data to the "mosaic" ; block. We'll compose the block because we want the ; new-image data to be included as if it was typed in ; explicitly. The word "image" also needs to be included ; because that's needed to show an image in a view layout ; block: append mosaic compose [image (new-image)] ][ ; Here's the second part of the "either" condition above. ; If the height of the original is less than the "y-size" ; variable, simply append the original image to the ; "mosaic" block: append mosaic compose [image (original)] ] ; As the current foreach loop stands, each resized image is ; simply added to the "mosaic" layout from left to right. We ; need to check the size of the "mosaic" layout every time we ; add an image. If the layout is wider than the width we set ; at the beginning of the program (the "mosaic-size" ; variable), we need to insert a "return" word into the ; "mosaic" GUI layout block: ; Create a temporary layout of the "mosaic" block: current-layout: layout/tight mosaic ; If the width of the current layout is larger than the ; prescribed width, insert the "return" word BEFORE the ; current resized image. A tick mark is put onto the 'return ; word so that the actual unevaluated text "return" is ; appended to the mosaic block. "back back tail" puts the ; "return" word in the correct place in the layout block: if current-layout/size/1 > mosaic-size [ insert back back tail mosaic 'return ] ] ; Prompt the user for a file name to save the final "mosaic" ; layout image: filename: to-file request-file/file/save "mosaic.png" ; Create an image from the final "mosaic" layout block, and save ; that image to the file name above: save/png filename (to-image layout mosaic) ; Show the user the saved image: view/new layout [image load filename] ] ] You can use this program to quickly resize collections of photos for email, web sites, etc. ===Additional Topics ---Objects Objects are code structures that allow you to encapsulate and replicate code. They can be thought of as code containers which are easily copied and modified to create multiple versions of similar code and/or duplicate data structures. They're also used to provide context and namespace management features (i.e., to avoid assigning the same variable words and/or function names to different pieces of code in large projects). Object "prototypes" define a new object container. To create an original object prototype in REBOL, use the following syntax: label: make object! [object definition] The object definition can contain functions, values, and/or data of any type. Below is a blank user account object containing 6 variables which are all set to equal "none"): account: make object! [ first-name: last-name: address: phone: email-address: none ] The account definition above simply wraps the 6 variables into a container, or context, called "account". You can refer to data and functions within an object using refinement ("/path") notation: object/word In the account object, "account/phone" refers to the phone number data contained in the account. You can make changes to elements in an object as follows: object/word: data For example: account/phone: "555-1234" account/address: "4321 Street Place Cityville, USA 54321" Once an object is created, you can view all its contents using the "help" function: help object ? object ; "?" is a synonym for "help" If you've typed in all the account examples so far into the REBOL interpreter, then: ? account displays the following info: ACCOUNT is an object of value: first-name none! none last-name none! none address string! "4321 Street Place Cityville, USA 54321" phone string! "555-1234" email-address none! none You can obtain a list of all the items in an object using the format "first (object label)": first account The above line returns [self first-name last-name address phone email-address]. The first item in the list is always "self", and for most operations, you'll want to remove that item. To do that, use the format "next first (object label)": next first account To iterate through every item in an object, you can use a foreach loop on the above values: foreach item (next first account) [print item] To get the values referred to by individual word labels in objects, use "get in": get in account 'first-name get in account 'address ; notice the tick mark The following example demonstrates how to access and manipulate every value in an object: count: 0 foreach item (next first account) [ count: count + 1 print rejoin ["Item " count ": " item] print rejoin ["Value: " (get in account item) newline] ] Once you've created an object prototype, you can make a new object based on the original definition: label: make existing-object [ values to be changed from the original definition ] This behaviour of copying values based on previous object definitions (called "inheritance") is one of the main reasons that objects are useful. The code below creates a new account object labeled "user1": user1: make account [ first-name: "John" last-name: "Smith" address: "1234 Street Place Cityville, USA 12345" email-address: "john@hisdomain.com" ] In this case, the phone number variable retains the default value of "none" established in the original account definition. You can extend any existing object definition with new values: label: make existing-object [new-values to be appended] The definition below creates a new account object, redefines all the existing variables, and appends a new variable to hold the user's favorite color. user2: make account [ first-name: "Bob" last-name: "Jones" address: "4321 Street Place Cityville, USA 54321" phone: "555-1234" email-address: "bob@mysite.net" favorite-color: "blue" ] "user2/favorite-color" now refers to "blue". The code below creates a duplicate of the user2 account, with only the name and email changed: user2a: make user2 [ first-name: "Paul" email-address: "paul@mysite.net" ] "? user2a" provides the following info: USER2A is an object of value: first-name string! "Paul" last-name string! "Jones" address string! "4321 Street Place Cityville, USA 54321" phone string! "555-1234" email-address string! "paul@mysite.net" favorite-color string! "blue" You can include functions in your object definition: complex-account: make object! [ first-name: last-name: address: phone: none email-address: does [ return to-email rejoin [ first-name "_" last-name "@website.com" ] ] display: does [ print "" print rejoin ["Name: " first-name " " last-name] print rejoin ["Address: " address] print rejoin ["Phone: " phone] print rejoin ["Email: " email-address] print "" ] ] Note that the variable "email-address" is initially assigned to the result of a function (which simply builds a default email address from the object's first and last name variables). You can override that definition by assigning a specified email address value. Once you've done that, the email-address function no longer exists in that particular object - it is overwritten by the specified email value. Here are some implementations of the above object. Notice the email-address value in each object: user1: make complex-account [] user2: make complex-account [ first-name: "John" last-name: "Smith" phone: "555-4321" ] user3: make complex-account [ first-name: "Bob" last-name: "Jones" address: "4321 Street Place Cityville, USA 54321" phone: "555-1234" email-address: "bob@mysite.net" ] To print out all the data contained in each object: user1/display user2/display user3/display The display function prints out data contained in each object, and in each object the same variables refer to different values (the first two emails are created by the email-address function, and the third is assigned). Here's a small game in which multiple character objects are created from a duplicated object template. Each character can store, alter, and print its own separately calculated position value based on one object prototype definition: REBOL [] hidden-prize: random 15x15 character: make object! [ position: 0x0 move: does [ direction: ask "Move up, down, left, or right: " switch/default direction [ "up" [position: position + -1x0] "down" [position: position + 1x0] "left" [position: position + 0x-1] "right" [position: position + 0x1] ] [print newline print "THAT'S NOT A DIRECTION!"] if position = hidden-prize [ print newline print "You found the hidden prize. YOU WIN!" print newline halt ] print rejoin [ newline "You moved character " movement " " direction ". Character " movement " is now " hidden-prize - position " spaces away from the hidden prize. " newline ] ] ] character1: make character[] character2: make character[position: 3x3] character3: make character[position: 6x6] character4: make character[position: 9x9] character5: make character[position: 12x12] loop 20 [ prin "^(1B)[J" movement: ask "Which character do you want to move (1-5)? " if find ["1" "2" "3" "4" "5"] movement [ do rejoin ["character" movement "/move"] print rejoin [ newline "The position of each character is now: " newline newline "CHARACTER ONE: " character1/position newline "CHARACTER TWO: " character2/position newline "CHARACTER THREE: " character3/position newline "CHARACTER FOUR: " character4/position newline "CHARACTER FIVE: " character5/position ] ask "^/Press the [Enter] key to continue." ] ] You could, for example, extend this concept to create a vast world of complex characters in an online multi-player game. All such character definitions could be built from one base character definition containing default configuration values. +++Namespace Management In this example the same words are defined two times in the same program: var: 1234.56 bank: does [ print "" print rejoin ["Your bank account balance is: $" var] print "" ] var: "Wabash" bank: does [ print "" print rejoin [ "Your favorite place is on the bank of the: " var] print "" ] bank There's no way to access the bank account balance after the above code runs, because the "bank" and "var" words have been overwritten. In large coding projects, it's easy for multiple developers to unintentionally use the same variable names to refer to different pieces of code and/or data, which can lead to accidental deletion or alteration of values. That potential problem can be avoided by simply wrapping the above code into separate objects: money: make object! [ var: 1234.56 bank: does [ print "" print rejoin ["Your bank account balance is: $" var] print "" ] ] place: make object! [ var: "Wabash" bank: does [ print "" print rejoin [ "Your favorite place is on the bank of the: " var] print "" ] ] Now you can access the "bank" and "var" words in their appropriate object contexts: money/bank place/bank money/var place/var The objects below make further use of functions and variables contained in the above objects. Because the new objects "deposit" and "travel" are made from the "money" and "place" objects, they inherit all the existing code contained in the above objects: deposit: make money [ view layout [ button "Deposit $10" [ var: var + 10 bank ] ] ] travel: make place [ view layout [ new-favorite: field 300 trim { Type a new favorite river here, and press [Enter]} [ var: value bank ] ] ] Learning to use objects is important because much of REBOL is built using object structures. As you've seen earlier in the section about built-in help, the REBOL "system" object contains many important interpreter settings. In order to access all the values in the system object, it's essential to understand object notation: get in system/components/graphics 'date The same is true for GUI widget properties and many other features of REBOL. For more information about objects, see: http://rebol.com/docs/core23/rebolcore-10.html
http://en.wikibooks.org/wiki/REBOL_Programming/Language_Features/Objects
http://en.wikipedia.org/wiki/Prototype-based_programming ---Ports REBOL "ports" provide a single way to handle many types of data input and output. They enable access to a variety of data sources, and allow you to control them all in a consistent way, using standard REBOL series functions. You can open ports to POP email boxes, FTP directories, local text files, TCP network connections, keyboard input buffers, and more, and also use them to output data such as sounds and console interactions. Once a port is opened to a data source, the data contained in the port can be treated as a sequential list of items which can be traversed, arranged, searched, sorted, and otherwise organized/manipulated, all using series functions such as those covered earlier in this text (foreach, find, select, reverse, length?, head, next, back, last, tail, at, skip, extract, index?, insert, append, remove, change, poke, copy/part, clear, replace, join, intersect, difference, exclude, union, unique, empty?, write, save, etc.). In some cases, there are other native ways to access data contained in a given port, typically with "read" and "write" functions. In such cases, port access simply provides finer control of the data (dealing with email and file data are examples of such cases). In other cases, ports provide the primary interface for accessing data in the given data source (TCP sockets and other network protocols are examples). Ports are created using the "open" function, and are typically assigned a word label when created: my-files: open ftp://user:pass@site.com/public_html/ After opening the above port, the files in the FTP directory can be traversed sequentially or by index, using series functions: print first my-files print length? my-files print pick my-files ((length? my-files) - 7) ; 7th file from the end ; etc ... To change the marked index position in a port, re-assign the port label to the new index position: my-files: head my-files print index? my-files print first my-files my-files: next my-files print index? my-files print first my-files my-files: at my-files 10 print index? my-files print first my-files To close the connection to data contained in a port, use the "close" function: close my-files It is of course possible to read and write directly to/from the folder in the above examples without manually opening a port: print read ftp://user:pass@site.com/public_html/ write ftp://user:pass@site.com/public_html/temp.txt (read %temp.txt) The difference between opening a port to the above files, and simply reading/writing them is that the port connection offers more specific access to and control of individual files. The "get-modes" and "set-modes" functions can be used to set various properties of files: my-file: open %temp.txt set-modes port [ world-read: true world-write: true world-execute: true ] close my-file More benefits of port control are easy to understand when dealing with email accounts. All the email in a given account can be accessed by simply reading it: print read pop://user:pass/site.com If, for example, there are 10000 messages in the above email account, the above action could take a very long time to complete. Even to simply read one email from the above account, the entire account needs to be read: print second read pop://user:pass/site.com A much better solution is to open a port to the above data source: my-email: open pop://user:pass/site.com Once the above port is open, each of the individual emails in the given POP account can be accessed separately, without having to download any other emails in the account: print second my-email ; no download of 10000 emails required And you can jump around between messages in the account: my-email: head my-email print first my-email ; prints the 1st email in the box my-email: next my-email print first my-email ; prints the 2nd email in the box my-email: at my-email 4 print first my-email ; prints the 5th email in the box my-email: head my-email print first my-email ; prints email #1 again ; etc... You can also remove email messages from the account: my-email: head my-email remove my-email ; removes the 1st email Internally, REBOL actually deals with most types of data sources as ports. The following line: write/append %temp.txt "1234" Is the same as: temp: open %temp.txt append temp "1234" close temp REBOL ports are objects. You can see all the properties of an open port, using the "probe" function: temp: open %temp.txt probe temp close temp From the very important example above, you can see that various useful properties of the port data can be accessed using a consistent syntax: temp: open %temp.txt print temp/date print temp/path print temp/size close temp The state/inBuffer and state/outBuffer are particularly important values in any port. Those items are where changes to data contained in the port are stored, until the port is closed or updated. Take a close look at this example: ; First, create a file: write %temp.txt "" ; That file is now empty: print read %temp.txt ; Open the above file as a port: temp: open %temp.txt ; Append some text to it: append temp "1234" ; Display the text to be saved to the file: print temp/state/inBuffer ; The appended changes have NOT yet been saved to the file because the ; port has not yet been closed or updated: print read %temp.txt ; Either "update" or "close" can be used to save the changes to the file: update temp ; The "update" function has forced the appended data to be written to ; the file, but has NOT yet closed the port: print read %temp.txt ; We can still navigate the port contents and add more data to it: temp: head temp insert temp "abcd" ; Display the text to be saved to the file: print temp/state/inBuffer ; Those changes have not yet been saved to the file: print read %temp.txt ; Closing the port will save changes to the file: close temp ; Here are the saved changes: print read %temp.txt ; And additional changes can no longer be made: append temp "1q2w3e4r" ; (error) Ports can be opened with a variety of refinements to help deal with data appropriately. "Help open" displays the following list: /binary - Preserves contents exactly. /string - Translates all line terminators. /direct - Opens the port without buffering. /seek - Opens port in seek mode without buffering. /new - Creates a file. (Need not already exist.) /read - Read only. Disables write operations. /write - Write only. Disables read operations. /no-wait - Returns immediately without waiting if no data. /lines - Handles data as lines. /with - Specifies alternate line termination. (Type: char string) /allow - Specifies the protection attributes when created. (Type: block) /mode - Block of above refinements. (Type: block) /custom - Allows special refinements. (Type: block) /skip - Skips a number of bytes. (Type: number) Several of those options will be demonstrated in the following example applications. +++Console Email Application The following email program opens a port to a selected email account and allows the user to navigate through messages, read, send, delete, and reply to emails. It runs entirely at the command line - no VID GUI components or View graphics are required. You can store configuration information for as many email accounts as you'd like in the "accounts" block, and easily switch between them at any point in the program: REBOL [Title: "Console Email"] accounts: [ ["pop.server" "smtp.server" "username" "password" you@site.com] ["pop.server2" "smtp.server2" "username" "password" you@site2.com] ["pop.server3" "smtp.server3" "username" "password" you@site3.com] ] empty-lines: "^/" loop 400 [append empty-lines "^/"] ; # of lines it takes to clear screen cls: does [prin {^(1B)[J}] a-line:{-----------------------------------------------------------------} select-account: does [ cls print a-line forall accounts [ print rejoin ["^/" index? accounts ": " last first accounts] ] print join "^/" a-line selected: ask "^/Select an account #: " if selected = "" [selected: 1] t: pick accounts (to-integer selected) system/schemes/pop/host: t/1 system/schemes/default/host: t/2 system/schemes/default/user: t/3 system/schemes/default/pass: t/4 system/user/email: t/5 ] send-email: func [/reply] [ cls print rejoin [a-line "^/^/Send Email:^/^/" a-line] either reply [ print join "^/^/Reply-to: " addr: form pretty/from ] [ addr: ask "^/^/Recipient Email Address: " ] either reply [ print join "^/Subject: " subject: join "re: " form pretty/subject ] [ subject: ask "^/Email Subject: " ] print {^/Body (when finished, type "end" on a seperate line):^/} print join a-line "^/" body: copy "" get-body: does [ body-line: ask "" if body-line = "end" [return] body: rejoin [body "^/" body-line] get-body ] get-body if reply [ rc: ask "^/Quote original email in your reply (Y/n)? " if ((rc = "yes") or (rc = "y") or (rc = "")) [ body: rejoin [ body "^/^/^/--- Quoting " form pretty/from ":^/" form pretty/content ] ] ] print rejoin ["^/" a-line "^/^/Sending..."] send/subject to-email addr body subject cls print "Sent^/" wait 1 ] read-email: does [ pretty: none cls print "One moment..." ; THE FOLLOWING LINE OPENS A PORT TO THE SELECTED EMAIL ACCOUNT: mail: open to-url join "pop://" system/user/email cls while [not tail? mail] [ print "Reading...^/" pretty: import-email (copy first mail) either find pretty/subject "***SPAM***" [ print join "Spam found in message #" length? mail mail: next mail ][ print empty-lines cls prin rejoin [ a-line {^/The following message is #} length? mail { from: } system/user/email {^/} a-line {^/^/} {FROM: } pretty/from {^/} {DATE: } pretty/date {^/} {SUBJECT: } pretty/subject {^/^/} a-line ] confirm: ask "^/^/Read Entire Message (Y/n): " if ((confirm = "y") or (confirm = "yes") or (confirm = "")) [ print join {^/^/} pretty/content ] print rejoin [ {^/} a-line {^/} {^/[ENTER]: Go Forward (next email)^/} {^/ "b": Go Backward (previous email)^/} {^/ "r": Reply to current email^/} {^/ "d": Delete current email^/} {^/ "q": Quit this mail box^/} {^/ Any #: Skip forward or backward this # of messages} {^/^/} a-line {^/} ] switch/default mail-command: ask "Enter Command: " [ "" [mail: next mail] "b" [mail: back mail] "r" [send-email/reply] "d" [ remove mail cls print "Email deleted!^/" wait 1 ] "q" [ close mail cls print"Mail box closed^/" wait 1 break ] ] [mail: skip mail to-integer mail-command] if (tail? mail) [mail: back mail] ] ] ] ; begin the program: select-account forever [ cls print a-line print rejoin [ {^/"r": Read Email^/} {^/"s": Send Email^/} {^/"c": Choose a different mail account^/} {^/"q": Quit^/} ] print a-line response: ask "^/Select a menu choice: " switch/default response [ "r" [read-email] "s" [send-email] "c" [select-account] "q" [ cls print "DONE!" wait .5 quit ] ] [read-email] ] +++Network Ports One important use of ports is for transferring data via network connections (TCP and UDP "sockets"). When writing a network application, you must choose a specific port number through which data is to be transferred. Potential ports range from 0 to 65535, but many of those numbers are reserved for specific types of applications (email programs use port 110, web servers use port 80 by default, etc.). To avoid conflicting with other established network applications, it's best to choose a port number between 49152 and 65535 for small scripts. A list of reserved port numbers is available here. Network applications are typically made up of two or more separate programs, each running on different computers. Any computer connected to a network or to the Internet is assigned a specific "IP address", notated in the format xxx.xxx.xxx.xxx. The numbers are different for every machine on a network, but most home and small business machines are normally in the IP range "192.168.xxx.xxx". You can obtain the IP address of your local computer with the following REBOL code: read join dns:// (read dns://) "Server" programs open a chosen network port and wait for one or more "client" programs to open the same port and then insert data into it. The port opened by the server program is referred to in a client program by combining the IP address of the computer on which the server runs, along with the chosen port number, each separated by a colon symbol (i.e., 192.168.1.2:55555). The following simple set of scripts demonstrates how to use REBOL ports to transfer one line of text from a client to a server program. This example is intended to run on a single computer, for demonstration, so the word "localhost" is used to represent the IP address of the server (that's a standard convention used to refer to any computer's own local IP address). If you want to run this on two separate computers connected via a local area network, you'll need to obtain the IP address of the server machine (use the code above), and replace the word "localhost" with that number: Here's the SERVER program. Be sure to run it before starting the client, or you will receive an error: ; Open network port 55555, in line mode (this mode expects full lines ; of text delineated by newline characters): server: open/lines tcp://:55555 ; Wait for a connection to the above port: wait server ; Assign a label to the first connection made to the above port: connection: first server ; Get the data which has been inserted into the above port object: data: first connection ; Display the inserted data: alert rejoin ["Text received: " data] ; Close the server close server Here's the CLIENT. Run it in a separate instance of the REBOL interpreter, after the above program has been started: ; Open the port created by the server above (replace "localhost" with ; an IP address if running these scripts on separate machines): server-port: open/lines tcp://localhost:55555 ; Insert some text into the port: insert server-port "Hello Mr. Watson." ; Close the port: close server-port Typically, servers will continuously wait for data to appear in a port, and repeatedly do something with that data. The scripts below extend the above example with forever loops to continuously send, receive, and display messages transferred from client(s) to the server. This type of loop forms the basis for most peer-to-peer and client-server network applications. Type "end" in the client program below to quit both the client and server. Here's the server program (run it first): server: open/lines tcp://:55555 ; Open a TCP network port. print "Server started...^/" connection: first wait server ; Label the first connection. forever [ data: first connection ; Get a line of data. print rejoin ["Text received: " data] ; Display it. if find data "end" [ close server ; End the program if the print "Server Closed" ; client user typed "end". halt ] ] Here's the client program. Run it only after the server program has been started, and in a separate instance of the REBOL interpreter (or on a separate computer): server-port: open/lines tcp://localhost:55555 ; Open the server port. forever [ user-text: ask "Enter some text to send: " insert server-port user-text ; Transfer the data. if user-text = "end" [ close server-port ; End the program if the print "Client Closed" ; user typed "end". halt ] ] It's important to understand that REBOL servers like the one above can interact independently with more than one simultaneous client connection. The "connection" definition waits until a new client connects, and returns a port representing that first client connection. Once that occurs, "connection" refers to the port used to accept data transferred by the already connected client. If you want to add more simultaneous client connections during the forever loop, simply define another "first wait server". Try running the server below, then run two simultaneous instances of the above client: server: open/lines tcp://:55555 ; Open a TCP network port. print "Now start TWO clients..." connection1: first wait server ; Label the first connection. connection2: first wait server ; Label the second connection. forever [ data1: first connection1 ; Get a line of client1 data data2: first connection2 ; Get a line of client2 data print rejoin ["Client1: " data1] print rejoin ["Client2: " data2] if find data1 "end" [ close server ; End the program if the print "Server Closed" ; client user typed "end". halt ] ] Here's an example that demonstrates how to send data back and forth (both directions), between client and server. Again, run both programs in separate instances of the REBOL interpreter, and be sure to start the server first: ; Server: print "Server started...^/" port: first wait open/lines tcp://:55555 forever [ user-text: ask "Enter some text to send: " insert port user-text if user-text = "end" [close port print "^/Server Closed^/" halt] wait port print rejoin ["^/Client user typed: " first port "^/"] ] ; Client: port: open/lines tcp://localhost:55555 print "Client started...^/" forever [ user-text: ask "Enter some text to send: " insert port user-text if user-text = "end" [close port print "^/Client Closed^/" halt] wait port print rejoin ["^/Server user typed: " first port "^/"] ] The following short script combines many of the techniques demonstrated so far. It can act as either server or client, and can send messages (one at a time), back and forth between the server and client: do [ either find ask "Server or client? " "s" [ port: first wait open/lines tcp://:55555 ; server ] [ port: open/lines tcp://localhost:55555 ; client ] forever [ insert port ask "Send: " print join "Received: "first wait port ] ] The following script is a complete GUI network instant message application. Unlike the FTP Chat Room presented earlier, the text in this application is sent directly between two computers, across a network socket connection (users of the FTP chat room never connect directly to one another - they simply connect to a universally available third party FTP server): view layout [ btn "Set client/server" [ ip: request-text/title/default trim { Server IP (leave EMPTY to run as SERVER): } (to-string read join dns:// read dns://) either ip = "" [ port: first wait open/lines tcp://:55555 z: true ; server ] [ port: open/lines rejoin [tcp:// ip ":55555"] z: true ] ] r: area rate 4 feel [ engage: func [f a e] [ if a = 'time and value? 'z [ if error? try [x: first wait port] [quit] r/text: rejoin [form x newline r/text] show r ] ] ] f: field "Type message here..." btn "Send" [insert port f/text] ] Here's an even more compact version (probably the shortest instant messenger program you'll ever see!): view layout [ across q: btn "Serve"[focus g p: first wait open/lines tcp://:8 z: 1]text"OR" k: btn "Connect"[focus g p: open/lines rejoin[tcp:// i/text ":8"]z: 1] i: field form read join dns:// read dns:// return r: area rate 4 feel [engage: func [f a e][if a = 'time and value? 'z [ if error? try [x: first wait p] [quit] r/text: rejoin [x "^/" r/text] show r ]]] return g: field "Type message here [ENTER]" [insert p value focus face] ] And here's an extended version of the above script that uploads your chosen user name, WAN/LAN IP, and port numbers to an FTP server, so that that info can be shared with others online (which enables them to find and connect with you). Connecting as server uploads the user info and starts the application in server mode. Once that is done, others can click the "Servers" button to retrieve and manually enter your connection info (IP address and port), to connect as client. By using different port numbers and user names, multiple users can connect to other multiple users, anywhere on the Internet: server-list: ftp://username:password@yoursite.com/public_html/im.txt ;edit view layout [ across q: btn "Serve" [ parse read http://guitarz.org/ip.cgi[thrucopy p to] parse p [thru "Your IP Address is: " copy pp to end] write/append server-list rejoin [ b/text " " pp " " read join dns:// read dns://" " j/text "^/" ] focus g p: first wait open/lines join tcp:// j/text z: 1 ] text "OR" k: btn "Connect" [ focus g p: open/lines rejoin [tcp:// i/text j/text] z: 1 ] b: field 85 "Username" i: field 98 form read join dns:// read dns:// j: field 48 ":8080" return r: area rate 4 feel [engage: func [f a e][if a = 'time and value? 'z [ if error? try [x: first wait p] [quit] r/text: rejoin [x "^/" r/text] show r ]]] return g: field "Type message here [ENTER]" [insert p value focus face] tabs 181 tab btn "Servers" [print read server-list] ] If you want to run scripts like these between computers connected to the Internet by broadband routers, you'll likely need to learn how to "forward" ports from your router to the IP address of the machine running your server program. In most situations where a router connects a local home/business network to the Internet, only the router device has an IP address which is visible on the Internet. The computers themselves are all assigned IP addresses that are only accessible within the local area network. Port forwarding allows you to send data coming to the IP address of the router (the IP which is visible on the Internet), on a unique port, to a specific computer inside the local area network. A full discussion of port forwarding is beyond the scope of this tutorial, but it's easy to learn how to do - just type "port forwarding" into Google. You'll need to learn how to forward ports on your particular brand and model of router. With any client-server configuration, only the server machine needs to have an exposed IP address or an open router/firewall port. The client machine can be located behind a router or firewall, without any forwarded incoming ports. Another option that enables network applications to work through routers is "VPN" software. Applications such as hamachi, comodo, and OpenVPN allow you to connect two separate LAN networks across the Internet, and treat all the machines as if they are connected locally (connect to any computer in the VPN using a local IP address, such as 192.168.1.xxx). VPN software also typically adds a layer of security to the data sent back and forth between the connected machines. The down side of VPN software is that data transmission can be slower than direct connection using port forwarding (the data travels through a third party server). +++ Peer-to-Peer Instant Messenger The following text message example contains line by documentation of various useful coding techniques. For instructions, see the help documentation included in the code. REBOL [Title: "Peer-to-Peer Instant Messenger"] ; The following line sets a flag variable, used to mark whether or not ; the two machines have already connected. It helps to more gracefully ; handle connection and shutdown actions throughout the script: connected: false ; The code below traps the close button (just a variation of the routine ; used in the earlier listview example). It assures that all open ports ; are closed, and sends a message to the remote machine that the ; connection has been terminated. Notice that the lines in the disconnect ; message are sent in reverse order. When they're received by the other ; machine, they're printed out one at a time, each line on top of the ; previous - so it appears correctly when viewed on the other side: insert-event-func closedown: func [face event] [ either event/type = 'close [ if connected [ insert port trim { ************************************************* AND RECONNECT. YOU MUST RESTART THE APPLICATION TO CONTINUE WITH ANOTHER CHAT, THE REMOTE PARTY HAS DISCONNECTED. ************************************************* } close port if mode/text = "Server Mode" [close listen] ] quit ] [event] ] view/new center-face gui: layout [ across at 5x2 ; this code positions the following items in the GUI ; The text below appears as a menu option in the upper ; left hand corner of the GUI. When it's clicked, the ; text contained in the "display" area is saved to a ; user selected file: text bold "Save Chat" [ filename: to-file request-file/title/file/save trim { Save file as:} "Save" %/c/chat.txt write filename display/text ] ; The text below is another menu option. It displays ; the user's IP address when clicked. It relies on a ; public web server to find the external address. ; The "parse" command is used to extract the IP address ; from the page. Parse is covered in a separate ; dedicated section later in the tutorial. text bold "Lookup IP" [ parse read http://guitarz.org/ip.cgi [ thru copy my-ip to ] parse my-ip [ thru "Your IP Address is: " copy stripped-ip to end ] alert to-string rejoin [ "External: " trim/all stripped-ip " " "Internal: " read join dns:// read dns:// ] ] ; The text below is a third menu option. It displays ; the help text when clicked. text bold "Help" [ alert { Enter the IP address and port number in the fields provided. If you will listen for others to call you, use the rotary button to select "Server Mode" (you must have an exposed IP address and/or an open port to accept an incoming chat). Select "Client Mode" if you will connect to another's chat server (you can do that even if you're behind an unconfigured firewall, router, etc.). Click "Connect" to begin the chat. To test the application on one machine, open two instances of the chat application, leave the IP set to "localhost" on both. Set one instance to run as server, and the other as client, then click connect. You can edit the chat text directly in the display area, and you can save the text to a local file. } ] return ; Below are the widgets used to enter connection info. ; Notice the labels assigned to each item. Later, the ; text contained in these widgets is referred to as ;